update_banner.c

Go to the documentation of this file.

 
/* Storage capacities in elements; text buffers include the terminating NUL. */
#define TUI_UPDATE_BANNER_CLIPPED_BUFFER_SIZE 1024
#define TUI_UPDATE_BANNER_HEADING_BUFFER_SIZE 160
#define TUI_UPDATE_BANNER_INSTALLED_BUFFER_SIZE 160
#define TUI_UPDATE_BANNER_LATEST_BUFFER_SIZE 160
#define TUI_UPDATE_BANNER_INSTALLED_VERSION_BUFFER_SIZE 128
#define TUI_UPDATE_BANNER_COMMAND_BUFFER_SIZE 512
#define TUI_UPDATE_BANNER_INSTRUCTIONS_BUFFER_SIZE 128
#define TUI_UPDATE_BANNER_DOMAIN_LINK_BUFFER_SIZE 128
#define TUI_UPDATE_BANNER_STYLED_INSTRUCTIONS_BUFFER_SIZE 256
#define TUI_UPDATE_BANNER_INSTRUCTIONS_EXTENDED_BUFFER_SIZE 256
#define TUI_UPDATE_BANNER_OUTPUT_BUFFER_SIZE 2048
#define TUI_UPDATE_BANNER_NOTIFICATION_BUFFER_SIZE 1024
 
#include <ascii-chat/otel.h>
#include <ascii-chat/options/options.h>
#include <ascii-chat/ui/popup.h>
#include <ascii-chat/ui/progress.h>
#include <ascii-chat/ui/buttons.h>
 
#include <ascii-chat/tui/input.h>
#include <ascii-chat/tui/error_popup.h>
#include <ascii-chat/common/shutdown.h>
#include <ascii-chat/app_callbacks.h>
#include <ascii-chat/tui/controller.h>
#include <ascii-chat/ui/frame_buffer.h>
#include <ascii-chat/tui/update_banner.h>
#include <ascii-chat/tui/splash.h>
#include "session/display.h"
#include <ascii-chat/common.h>
#include <libplatform/terminal.h>
#include <ascii-chat/os/keyboard.h>
#include <libplatform/system.h>
#include <libplatform/filesystem.h>
#include <libplatform/thread.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/util/display.h>
#include <ascii-chat/util/string.h>
#include <ascii-chat/util/time.h>
#include <libplatform/lifecycle.h>
 
#include <stdio.h>
#include <stdatomic.h>
#include <signal.h>
#include <string.h>
#include <uv.h>
 
// Thread-safe storage for the update check result
static update_check_result_t g_update_result;
static mutex_t g_update_result_mutex;
static bool g_update_result_set = false;
static lifecycle_t g_update_result_lifecycle = LIFECYCLE_INIT_MUTEX(&g_update_result_mutex);
 
// Background update check thread
static platform_thread_t g_update_thread;
static bool g_update_thread_started = false;
static bool g_update_checking = false;
static bool g_update_finished = false;
static _Atomic bool g_update_overlay = false;
static _Atomic bool g_update_install_failed = false;
static _Atomic bool g_update_cancel_requested = false;
static _Atomic int g_update_selected_action = 0;
static _Atomic uint64_t g_update_visible_until_ns = 0;
static void update_banner_open_release(void);
static void update_banner_present_overlay(void);
 
static bool update_banner_copy_result(update_check_result_t *result) {
  if (!result || !lifecycle_is_initialized(&g_update_result_lifecycle)) {
    return false;
  }
  mutex_lock(&g_update_result_mutex);
  bool set = g_update_result_set;
  if (set) {
    *result = g_update_result;
  }
  mutex_unlock(&g_update_result_mutex);
  return set;
}
 
void update_banner_set_result(const update_check_result_t *result) {
  if (!result) {
    return;
  }
 
  // Resolve the command before publishing a result to the presentation thread.
  if (result->update_available && update_check_detect_install_method() == INSTALL_METHOD_ARCH_AUR)
    (void)update_check_get_aur_helper();
 
  if (lifecycle_init_once(&g_update_result_lifecycle)) {
    mutex_init(&g_update_result_mutex, "update_banner_result");
    lifecycle_init_commit(&g_update_result_lifecycle);
  }
 
  ascii_otel_ui_usage("update", result->check_succeeded ? "check_completed" : "check_failed", 0);
  mutex_lock(&g_update_result_mutex);
  memcpy(&g_update_result, result, sizeof(g_update_result));
  g_update_result_set = true;
  mutex_unlock(&g_update_result_mutex);
}
 
bool update_banner_has_update(void) {
  update_check_result_t result = {0};
  return update_banner_copy_result(&result) && result.update_available;
}
 
static void update_center_line(frame_buffer_t *out, int row, int left, int width, const char *text, log_color_t color) {
  char clipped[TUI_UPDATE_BANNER_CLIPPED_BUFFER_SIZE];
  truncate_with_ellipsis(text, clipped, sizeof(clipped), width);
  int padding = (width - display_width(clipped)) / 2;
  frame_buffer_printf(out, "\033[%d;%dH%s", row, left + padding, colored_string(color, clipped));
}
 
static void update_border(frame_buffer_t *out, int row, int left, int width, const char *first, const char *horizontal,
                          const char *last, log_color_t color) {
  frame_buffer_printf(out, "\033[%d;%dH%s", row, left, colored_string(color, first));
  int edges = (first[0] ? 1 : 0) + (last[0] ? 1 : 0);
  const char *stroke = colored_string(color, horizontal);
  for (int col = 0; col < width - edges; ++col)
    frame_buffer_append(out, stroke, strlen(stroke));
  frame_buffer_printf(out, "%s", colored_string(color, last));
}
 
static int update_action_count(bool startup, bool checking, bool available) {
  return startup ? 3 : checking ? 1 : available ? 4 : 2;
}
 
static bool update_select_key(int key, int count) {
  if (key != KEY_LEFT && key != KEY_UP && key != KEY_RIGHT && key != KEY_DOWN && key != '\t')
    return false;
  ui_button_t buttons[4] = {{.label = ""}, {.label = ""}, {.label = ""}, {.label = ""}};
  ui_buttons_t state = {.selected = (size_t)atomic_load(&g_update_selected_action)};
  (void)ui_buttons_key(&state, buttons, (size_t)count, (keyboard_key_t)key);
  atomic_store(&g_update_selected_action, (int)state.selected);
  ui_controller_redraw();
  return true;
}
 
static void render_update_dialog(terminal_size_t size, const update_check_result_t *result, bool startup,
                                 bool checking) {
  bool available = !checking && result->update_available;
  bool unicode = terminal_should_use_utf8(GET_OPTION(force_utf8));
  log_color_t cyan = LOG_COLOR_DEBUG;
  log_color_t muted = LOG_COLOR_GREY;
  log_color_t green = LOG_COLOR_INFO;
  log_color_t yellow = LOG_COLOR_WARN;
  const char *horizontal = unicode ? "─" : "-";
  const char *vertical = unicode ? "│" : "|";
  const char *labels[4] = {0};
  int count = update_action_count(startup, checking, available);
  if (startup) {
    labels[0] = " Enter  Update now ";
    labels[1] = " O  GitHub ";
    labels[2] = " Esc  Continue ";
  } else if (available) {
    labels[0] = " Enter  Update now ";
    labels[1] = " O  GitHub ";
    labels[2] = " Esc / F12 Close ";
    labels[3] = " R  Check again ";
  } else {
    labels[0] = " Esc / F12 Close ";
    labels[1] = " R  Check again ";
  }
  int buttons_width = (count - 1) * 3;
  for (int i = 0; i < count; ++i)
    buttons_width += display_width(labels[i]);
  int width = size.cols - 4;
  int preferred_width = available ? 78 : checking ? 62 : 58;
  if (width > preferred_width)
    width = preferred_width;
  bool stacked = buttons_width > width - 6;
  int height = (available ? 18 : checking ? 15 : 13) + (stacked ? count - 1 : 0);
  bool failed = atomic_load(&g_update_install_failed);
  if (width < 24 || height > size.rows - 2)
    return;
  int left = (size.cols - width) / 2 + 1;
  int top = (size.rows - height) / 2 + 1;
  frame_buffer_t *out = frame_buffer_create(size.rows, size.cols);
  if (!out)
    return;
  frame_buffer_printf(out, startup ? "\033[?25l\033[0m\033[2J\033[H" : "\033[?25l\033[0m");
  ui_popup_frame(out, top, left, width, height, cyan);
  const char *title = checking                  ? "Check for updates"
                      : available               ? "Update available"
                      : result->check_succeeded ? "You're up to date"
                                                : "Update check unavailable";
  char heading[TUI_UPDATE_BANNER_HEADING_BUFFER_SIZE];
  snprintf(heading, sizeof(heading), "\033[1m%s", title);
  update_center_line(out, top + (checking ? 1 : 2), left + 2, width - 4, heading,
                     checking                  ? cyan
                     : available               ? yellow
                     : result->check_succeeded ? green
                                               : yellow);
  if (checking) {
    ui_spinner_render(out, top + 3, left + (width - 7) / 2, time_get_ns());
    update_center_line(out, top + 7, left + 2, width - 4, "Contacting GitHub Releases...", LOG_COLOR_RESET);
    update_center_line(out, top + 9, left + 2, width - 4, "Video chat in your terminal", muted);
  } else if (result->check_succeeded) {
    char installed[TUI_UPDATE_BANNER_INSTALLED_BUFFER_SIZE], latest[TUI_UPDATE_BANNER_LATEST_BUFFER_SIZE],
        installed_version[TUI_UPDATE_BANNER_INSTALLED_VERSION_BUFFER_SIZE];
    snprintf(installed_version, sizeof(installed_version), "%s%s", result->current_version[0] == 'v' ? "" : "v",
             result->current_version);
    snprintf(installed, sizeof(installed), "Installed  %s",
             colored_string(available ? yellow : green, installed_version));
    snprintf(latest, sizeof(latest), "Latest     %s", colored_string(green, result->latest_version));
    update_center_line(out, top + 4, left + 2, width - 4, installed, LOG_COLOR_RESET);
    update_center_line(out, top + 5, left + 2, width - 4, latest, LOG_COLOR_RESET);
    if (available) {
      update_center_line(out, top + 6, left + 2, width - 4, "A new version of ascii-chat is available.", muted);
      char command[TUI_UPDATE_BANNER_COMMAND_BUFFER_SIZE];
      update_check_get_upgrade_suggestion(update_check_detect_install_method(), result->latest_version, command,
                                          sizeof(command));
      int command_width = display_width(command) + 6;
      if (command_width > width - 6)
        command_width = width - 6;
      int command_left = left + (width - command_width) / 2;
      update_border(out, top + 7, command_left, command_width, unicode ? "┌" : "+", horizontal, unicode ? "┐" : "+",
                    cyan);
      frame_buffer_printf(out, "\033[%d;%dH%s%*s%s", top + 8, command_left, colored_string(cyan, vertical),
                          command_width - 2, "", colored_string(cyan, vertical));
      update_center_line(out, top + 8, command_left + 2, command_width - 4, command, cyan);
      update_border(out, top + 9, command_left, command_width, unicode ? "└" : "+", horizontal, unicode ? "┘" : "+",
                    cyan);
      char instructions[TUI_UPDATE_BANNER_INSTRUCTIONS_BUFFER_SIZE];
      truncate_with_ellipsis("Full instructions on ascii-chat.com", instructions, sizeof(instructions), width - 4);
      int instructions_left = left + 2 + (width - 4 - display_width(instructions)) / 2;
      char domain_link[TUI_UPDATE_BANNER_DOMAIN_LINK_BUFFER_SIZE],
          styled_instructions[TUI_UPDATE_BANNER_STYLED_INSTRUCTIONS_BUFFER_SIZE];
      (void)terminal_format_hyperlink(domain_link, sizeof(domain_link), "https://ascii-chat.com", "ascii-chat.com",
                                      !GET_OPTION(strip_ansi));
      char *domain = strstr(instructions, "ascii-chat.com");
      if (domain) {
        *domain = '\0';
        snprintf(styled_instructions, sizeof(styled_instructions), "%s%s", instructions, domain_link);
      } else {
        snprintf(styled_instructions, sizeof(styled_instructions), "%s", instructions);
      }
      frame_buffer_printf(out, "\033[%d;%dH%s", top + 10, instructions_left,
                          colored_string(LOG_COLOR_WHITE, styled_instructions));
      update_center_line(out, top + 11, left + 2, width - 4,
                         "Binaries for every OS with release notes on GitHub:", muted);
      update_center_line(out, top + 12, left + 2, width - 4, result->release_url, cyan);
    } else {
      update_center_line(out, top + 7, left + 2, width - 4, "Checked just now", muted);
    }
  } else {
    update_center_line(out, top + 6, left + 2, width - 4, "No network result is available.", muted);
    update_center_line(out, top + 7, left + 2, width - 4, "Press R to retry.", muted);
  }
  int button_row = top + (available ? 16 : checking ? 13 : 11);
  if (failed) {
    update_center_line(out, button_row - 3, left + 2, width - 4, "Update command failed. See the logs and retry.",
                       yellow);
  }
  update_border(out, button_row - 2, left + 2, width - 4, "", horizontal, "", cyan);
  int selected = atomic_load(&g_update_selected_action) % count;
  ui_button_t buttons[4];
  for (int i = 0; i < count; ++i)
    buttons[i] = (ui_button_t){.label = labels[i]};
  ui_buttons_render(out, button_row, left + 3, width - 6, buttons, (size_t)count, (size_t)selected);
  ui_controller_write(STDOUT_FILENO, frame_buffer_get_content(out), frame_buffer_get_length(out));
  frame_buffer_destroy(out);
}
 
static void render_update_prompt(terminal_size_t size, const void *data) {
  render_update_dialog(size, data, true, false);
}
 
static void render_update_overlay(terminal_size_t size, const void *data) {
  (void)data;
  update_check_result_t result;
  mutex_lock(&g_update_result_mutex);
  result = g_update_result;
  bool checking = g_update_checking;
  mutex_unlock(&g_update_result_mutex);
  render_update_dialog(size, &result, false, checking);
}
 
bool update_banner_show_prompt(session_display_ctx_t *ctx) {
  if (!ctx || !terminal_can_prompt_user(!GET_OPTION(snapshot_mode)))
    return false;
  update_check_result_t result;
  mutex_lock(&g_update_result_mutex);
  result = g_update_result;
  mutex_unlock(&g_update_result_mutex);
  if (update_check_is_dismissed(&result)) {
    return false;
  }
  atomic_store(&g_update_selected_action, 0);
  if (ui_controller_submit(UI_SCREEN_UPDATE, STDOUT_FILENO, (terminal_size_t){.cols = 32, .rows = 23},
                           render_update_prompt, &result, sizeof(result)) != ASCIICHAT_OK)
    return false;
  bool update = false;
  while (!shutdown_is_requested()) {
    /* The update prompt is synchronous, but a failed DNS check can put the
     * error popup above it. Route keys to that modal until it is dismissed. */
    if (ui_error_popup_visible()) {
      (void)ui_input_wait_key(UI_SCREEN_ERROR, 100);
      continue;
    }
    keyboard_key_t key = ui_input_wait_key(UI_SCREEN_UPDATE, 100);
    if (g_update_overlay)
      return false;
    if (update_select_key(key, 3))
      continue;
    if (key == 'o' || key == 'O' || ((key == '\r' || key == '\n') && atomic_load(&g_update_selected_action) == 1)) {
      update_banner_open_release();
      continue;
    }
    if (key == '\r' || key == '\n') {
      update = atomic_load(&g_update_selected_action) == 0;
      break;
    }
    if (key == 'y' || key == 'Y') {
      update = true;
      break;
    }
    if (key == 'n' || key == 'N' || key == KEY_ESCAPE)
      break;
  }
  if (!g_update_overlay) {
    ui_controller_remove(UI_SCREEN_UPDATE);
  }
  if (!update && !g_update_overlay) {
    update_check_dismiss_for_a_week(&result);
    update_banner_set_result(&result);
  }
  return update;
}
 
void update_banner_print_instructions(void) {
  mutex_lock(&g_update_result_mutex);
  update_check_result_t result;
  memcpy(&result, &g_update_result, sizeof(result));
  mutex_unlock(&g_update_result_mutex);
 
  char domain_link[TUI_UPDATE_BANNER_DOMAIN_LINK_BUFFER_SIZE],
      instructions[TUI_UPDATE_BANNER_INSTRUCTIONS_EXTENDED_BUFFER_SIZE];
  (void)terminal_format_hyperlink(domain_link, sizeof(domain_link), "https://ascii-chat.com", "ascii-chat.com",
                                  !GET_OPTION(strip_ansi));
  snprintf(instructions, sizeof(instructions), "Full instructions on %s", domain_link);
  char output[TUI_UPDATE_BANNER_OUTPUT_BUFFER_SIZE];
  int len = snprintf(output, sizeof(output),
                     "\033[0m\033[2J\033[H\033[?25h"
                     "\nUpdated ascii-chat: %s -> %s\n\nRun ascii-chat again to start the new version.\n\n"
                     "Binaries for every OS with release notes on GitHub:\n%s\n\n"
                     "%s\n\n",
                     result.current_version, result.latest_version, result.release_url,
                     colored_string(LOG_COLOR_WHITE, instructions));
  if (len > 0 && len < (int)sizeof(output))
    ui_controller_finish(STDOUT_FILENO, output, (size_t)len);
}
 
bool update_banner_install_update(void) {
  update_check_result_t result = {0};
  if (!update_banner_copy_result(&result) || !result.update_available) {
    return false;
  }
  g_update_install_failed = false;
 
  install_method_t method = update_check_detect_install_method();
  int exit_code = -1;
#ifndef NDEBUG
  const char *test_command = SAFE_GETENV("ASCII_CHAT_TEST_UPDATE_COMMAND");
  if (test_command && test_command[0]) {
#ifdef _WIN32
    const char *argv[] = {"cmd", "/d", "/c", test_command, NULL};
    exit_code = platform_execute_subprocess("cmd", argv, NULL, 0, NULL, NULL);
#else
    const char *argv[] = {"/bin/sh", "-c", test_command, NULL};
    exit_code = platform_execute_subprocess("/bin/sh", argv, NULL, 0, NULL, NULL);
#endif
  } else
#endif
      if (method == INSTALL_METHOD_HOMEBREW) {
    const char *argv[] = {"brew", "upgrade", "ascii-chat", NULL};
    exit_code = platform_execute_subprocess("brew", argv, NULL, 0, NULL, NULL);
  } else if (method == INSTALL_METHOD_SCOOP) {
    // Scoop is a PowerShell script/shim, rather than a native executable.
    const char *argv[] = {"powershell", "-NoProfile", "-Command",
                          "$ErrorActionPreference = 'Stop'; scoop update ascii-chat; if (!$?) { exit 1 }", NULL};
    exit_code = platform_execute_subprocess("powershell", argv, NULL, 0, NULL, NULL);
  } else if (method == INSTALL_METHOD_ARCH_AUR) {
    const char *helper = update_check_get_aur_helper();
    if (!helper) {
      log_warn("No supported AUR helper is available");
      g_update_install_failed = true;
      ui_controller_redraw();
      return false;
    }
    const char *argv[] = {helper, "-S", "ascii-chat", NULL};
    exit_code = platform_execute_subprocess(helper, argv, NULL, 0, NULL, NULL);
  } else {
#ifdef _WIN32
    const char *argv[] = {
        "powershell", "-NoProfile", "-ExecutionPolicy",
        "Bypass",     "-Command",   "$ErrorActionPreference = 'Stop'; irm https://ascii-chat.com/install.ps1 | iex",
        NULL};
    exit_code = platform_execute_subprocess("powershell", argv, NULL, 0, NULL, NULL);
#else
    const char *argv[] = {"bash", "-o", "pipefail", "-c", "curl -fsSL https://ascii-chat.com/install.sh | bash", NULL};
    exit_code = platform_execute_subprocess("bash", argv, NULL, 0, NULL, NULL);
#endif
  }
  if (exit_code != 0) {
    log_warn("ascii-chat update command exited with status %d", exit_code);
    g_update_install_failed = true;
    ui_controller_redraw();
    return false;
  }
  update_banner_print_instructions();
  shutdown_request();
  APP_CALLBACK_VOID(signal_exit);
  return true;
}
 
typedef struct {
  bool exited;
  int64_t status;
  int signal;
} update_child_result_t;
 
static void update_child_exited(uv_process_t *process, int64_t status, int signal) {
  update_child_result_t *result = process->data;
  result->status = status;
  result->signal = signal;
  result->exited = true;
  uv_close((uv_handle_t *)process, NULL);
}
 
// A separate process can be terminated on shutdown even while DNS or TLS is blocked.
static asciichat_error_t update_check_background(update_check_result_t *result) {
  if (shutdown_is_requested() || atomic_load(&g_update_cancel_requested))
    return ERROR_SIGNAL_INTERRUPT;
  if (update_check_try_fresh_cache(result))
    return ASCIICHAT_OK;
  char executable[PLATFORM_MAX_PATH_LENGTH];
  if (!platform_get_executable_path(executable, sizeof(executable)))
    return SET_ERRNO(ERROR_PROCESS_FAILED, "Cannot locate executable for background update check");
  uv_loop_t loop;
  int rc = uv_loop_init(&loop);
  if (rc != 0)
    return SET_ERRNO(ERROR_PROCESS_FAILED, "Cannot initialize update process: %s", uv_strerror(rc));
  char *args[] = {executable, "--check-update", NULL};
  uv_stdio_container_t streams[3] = {0};
  for (size_t i = 0; i < 3; ++i)
    streams[i].flags = UV_IGNORE;
  update_child_result_t child_result = {0};
  uv_process_t child = {.data = &child_result};
  uv_process_options_t options = {.file = executable,
                                  .args = args,
                                  .exit_cb = update_child_exited,
                                  .stdio_count = 3,
                                  .stdio = streams,
                                  .flags = UV_PROCESS_WINDOWS_HIDE};
  rc = uv_spawn(&loop, &child, &options);
  if (rc != 0) {
    uv_loop_close(&loop);
    return SET_ERRNO(ERROR_PROCESS_FAILED, "Cannot start background update check: %s", uv_strerror(rc));
  }
  bool killed = false, timed_out = false;
  uint64_t deadline = time_get_ns() + 15 * NS_PER_SEC_INT;
  while (!child_result.exited) {
    uv_run(&loop, UV_RUN_NOWAIT);
    bool cancelled = shutdown_is_requested() || atomic_load(&g_update_cancel_requested);
    bool expired = time_get_ns() >= deadline;
    if (!child_result.exited && (cancelled || expired) && !killed) {
      int kill_result = uv_process_kill(&child, SIGKILL);
      if (kill_result != 0 && kill_result != UV_ESRCH) {
        log_warn("Cannot stop background update check: %s", uv_strerror(kill_result));
        uv_close((uv_handle_t *)&child, NULL);
        uv_run(&loop, UV_RUN_DEFAULT);
        uv_loop_close(&loop);
        return cancelled ? ERROR_SIGNAL_INTERRUPT : SET_ERRNO(ERROR_PROCESS_FAILED, "Cannot stop update check");
      }
      killed = true;
      timed_out = expired && !cancelled;
    }
    if (!child_result.exited)
      platform_sleep_ms(10);
  }
  uv_run(&loop, UV_RUN_DEFAULT);
  uv_loop_close(&loop);
  if (timed_out)
    return SET_ERRNO(ERROR_NETWORK, "Background update check timed out");
  if (killed)
    return ERROR_SIGNAL_INTERRUPT;
  if (child_result.status != 0 || child_result.signal != 0 || !update_check_try_fresh_cache(result))
    return SET_ERRNO(ERROR_NETWORK, "Background update check failed");
  return ASCIICHAT_OK;
}
 
static void *update_check_thread_func(void *arg) {
  bool force = arg != NULL;
  uint64_t visible_until = time_get_ns() + 2 * NS_PER_SEC_INT;
  update_check_result_t result;
  bool background = !force && !splash_should_display(true) &&
                    (GET_OPTION(detected_mode) == MODE_MIRROR || GET_OPTION(detected_mode) == MODE_CLIENT ||
                     GET_OPTION(detected_mode) == MODE_DISCOVERY);
  asciichat_error_t err;
  if (background) {
    asciichat_errno_scope_t scope = errno_scope_begin();
    bool previous_notifications = errno_notifications_suppress(true);
    err = update_check_background(&result);
    if (err != ASCIICHAT_OK && err != ERROR_SIGNAL_INTERRUPT)
      log_debug("Automatic update check failed: %s", asciichat_error_string(err));
    errno_notifications_suppress(previous_notifications);
    errno_scope_end(scope, ASCIICHAT_ERRNO_HANDLED);
  } else {
    asciichat_errno_scope_t scope = errno_scope_begin();
    bool previous_notifications = errno_notifications_suppress(true);
    err = force ? update_check_perform(&result) : update_check_startup(&result);
    errno_notifications_suppress(previous_notifications);
    errno_scope_end(scope, ASCIICHAT_ERRNO_HANDLED);
  }
  while (!shutdown_is_requested() && !atomic_load(&g_update_cancel_requested)) {
    uint64_t overlay_until = atomic_load(&g_update_visible_until_ns);
    if (overlay_until > visible_until)
      visible_until = overlay_until;
    if (time_get_ns() >= visible_until)
      break;
    platform_sleep_ms(10);
  }
  if (err == ASCIICHAT_OK) {
    if (result.update_available) {
      char notification[TUI_UPDATE_BANNER_NOTIFICATION_BUFFER_SIZE];
      update_check_format_notification(&result, notification, sizeof(notification));
      log_info("%s", notification);
      splash_set_update_notification(notification);
    } else {
      log_info("Already on latest version: %s", result.current_version);
    }
 
    // Store every terminal state for the reusable update overlay.
    update_banner_set_result(&result);
  } else {
    // A failed retry must not advertise an earlier successful result.
    update_check_result_t unavailable = {0};
    update_banner_set_result(&unavailable);
  }
  mutex_lock(&g_update_result_mutex);
  g_update_checking = false;
  g_update_finished = true;
  mutex_unlock(&g_update_result_mutex);
  // With no splash, the check runs in the background instead of holding up
  // the first frame. Notify interactively once its result is available.
  if (!force && err == ASCIICHAT_OK && result.update_available && !splash_should_display(true) &&
      (GET_OPTION(detected_mode) == MODE_MIRROR || GET_OPTION(detected_mode) == MODE_CLIENT) &&
      !atomic_load(&g_update_cancel_requested) && !shutdown_is_requested() &&
      terminal_can_prompt_user(!GET_OPTION(snapshot_mode)) && !update_check_is_dismissed(&result)) {
    bool expected = false;
    if (atomic_compare_exchange_strong(&g_update_overlay, &expected, true)) {
      atomic_store(&g_update_selected_action, 0);
      update_banner_present_overlay();
    }
  }
  ui_controller_redraw();
  return NULL;
}
 
static void update_banner_start_check_impl(bool force) {
  if (g_update_thread_started)
    return;
  atomic_store(&g_update_cancel_requested, false);
  if (lifecycle_init_once(&g_update_result_lifecycle)) {
    mutex_init(&g_update_result_mutex, "update_banner_result");
    lifecycle_init_commit(&g_update_result_lifecycle);
  }
  ascii_otel_ui_usage("update", "check_started", 0);
  mutex_lock(&g_update_result_mutex);
  g_update_checking = true;
  g_update_finished = false;
  atomic_store(&g_update_selected_action, 0);
  memset(&g_update_result, 0, sizeof(g_update_result));
  g_update_result_set = false;
  mutex_unlock(&g_update_result_mutex);
  if (platform_thread_create(&g_update_thread, "update_check", update_check_thread_func, force ? (void *)1 : NULL) ==
      0) {
    g_update_thread_started = true;
  } else {
    ascii_otel_ui_usage("update", "check_failed", 0);
    mutex_lock(&g_update_result_mutex);
    g_update_checking = false;
    g_update_finished = true;
    mutex_unlock(&g_update_result_mutex);
  }
  ui_controller_redraw();
}
 
void update_banner_start_check(void) {
  update_banner_start_check_impl(false);
}
 
void update_banner_toggle_overlay(void) {
  if (g_update_overlay) {
    ascii_otel_ui_usage("update", "dismissed", 0);
    g_update_overlay = false;
    ui_controller_remove(UI_SCREEN_UPDATE);
    return;
  }
  ascii_otel_ui_usage("update", "opened", 0);
  g_update_overlay = true;
  atomic_store(&g_update_visible_until_ns, time_get_ns() + 2 * NS_PER_SEC_INT);
  atomic_store(&g_update_selected_action, 0);
  bool finished = false;
  if (lifecycle_is_initialized(&g_update_result_lifecycle)) {
    mutex_lock(&g_update_result_mutex);
    finished = g_update_finished;
    mutex_unlock(&g_update_result_mutex);
  }
  if (g_update_thread_started && finished)
    update_banner_wait_for_check();
  if (!g_update_thread_started)
    update_banner_start_check_impl(true);
  update_banner_present_overlay();
}
 
static void update_banner_present_overlay(void) {
  const bool snapshot = true;
  asciichat_errno_scope_t scope = errno_scope_begin();
  if (ui_controller_submit(UI_SCREEN_UPDATE, STDOUT_FILENO, (terminal_size_t){.cols = 32, .rows = 24},
                           render_update_overlay, &snapshot, sizeof(snapshot)) != ASCIICHAT_OK) {
    g_update_overlay = false;
    LOG_ERRNO_IF_SET("Cannot show update checker");
  }
  errno_scope_end(scope, ASCIICHAT_ERRNO_HANDLED);
}
 
bool update_banner_is_checking(void) {
  if (!lifecycle_is_initialized(&g_update_result_lifecycle))
    return false;
  mutex_lock(&g_update_result_mutex);
  bool checking = g_update_checking;
  mutex_unlock(&g_update_result_mutex);
  return checking;
}
 
bool update_banner_is_overlay_open(void) {
  return g_update_overlay;
}
 
static void update_banner_open_release(void) {
  update_check_result_t result;
  mutex_lock(&g_update_result_mutex);
  result = g_update_result;
  mutex_unlock(&g_update_result_mutex);
  // The URL can originate in the disk cache. Keep it a single HTTPS argument,
  // including when Windows passes it through cmd's start builtin.
  if (!result.check_succeeded || strncmp(result.release_url, "https://", 8) != 0 || !result.release_url[8] ||
      strpbrk(result.release_url, "\"'&|^<>%!`()\\") != NULL)
    return;
  for (const unsigned char *ch = (const unsigned char *)result.release_url; *ch; ++ch) {
    if (*ch <= ' ' || *ch == 127)
      return;
  }
  ascii_otel_ui_usage("update", "release_open_requested", 0);
#ifdef _WIN32
  const char *argv[] = {"cmd", "/c", "start", "", result.release_url, NULL};
  (void)platform_execute_subprocess("cmd", argv, NULL, 0, NULL, NULL);
#elif defined(__APPLE__)
  const char *argv[] = {"open", result.release_url, NULL};
  (void)platform_execute_subprocess("open", argv, NULL, 0, NULL, NULL);
#else
  const char *argv[] = {"xdg-open", result.release_url, NULL};
  (void)platform_execute_subprocess("xdg-open", argv, NULL, 0, NULL, NULL);
#endif
}
 
bool update_banner_handle_key(int key) {
  if (key == KEY_F12) {
    update_banner_toggle_overlay();
    return true;
  }
  if (!g_update_overlay)
    return false;
  bool checking = update_banner_is_checking();
  update_check_result_t result = {0};
  bool available = !checking && update_banner_copy_result(&result) && result.update_available;
  int count = update_action_count(false, checking, available);
  if (update_select_key(key, count))
    return true;
  if (key == '\r' || key == '\n') {
    int selected = atomic_load(&g_update_selected_action) % count;
    if ((available && selected == 2) || (!available && selected == 0)) {
      update_banner_toggle_overlay();
      return true;
    }
    if (checking)
      return true;
    if (available && selected == 0) {
      (void)update_banner_install_update();
      return true;
    }
    if (available && selected == 1) {
      update_banner_open_release();
      return true;
    }
    key = 'r';
  }
  if (key == KEY_ESCAPE) {
    update_banner_toggle_overlay();
    return true;
  }
  if (key == 'o' || key == 'O') {
    if (!update_banner_is_checking())
      update_banner_open_release();
    return true;
  }
  if (key == 'r' || key == 'R') {
    if (update_banner_is_checking())
      return true;
    update_banner_wait_for_check();
    update_banner_start_check_impl(true);
    return true;
  }
  return g_update_overlay;
}
 
void update_banner_wait_for_check(void) {
  if (!g_update_thread_started) {
    return;
  }
  // Shutdown must remain responsive after cancellation.  The worker checks
  // g_update_cancel_requested and terminates its child process, so one second
  // is sufficient for normal teardown while avoiding a multi-second Ctrl-C
  // stall when a platform/network call is slow to unwind.
  int ret = thread_join_timeout(&g_update_thread, NULL, 1LL * NS_PER_SEC_INT);
  if (ret != 0) {
    // Timeout — thread is still alive. Do a blocking join to avoid orphaning it.
    // The thread has bounded runtime (DNS + HTTP both have timeouts) so this won't hang.
    log_warn("Update check thread did not finish within 1s, waiting for completion");
    thread_join(&g_update_thread, NULL);
  }
  g_update_thread_started = false;
}
 
void update_banner_cancel_check(void) {
  atomic_store(&g_update_cancel_requested, true);
}