update_checker.c

Go to the documentation of this file.

 
#include <ascii-chat/network/update_checker.h>
#include <ascii-chat/network/http_client.h>
#include <ascii-chat/network/dns.h>
#include <ascii-chat/version.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/platform/socket.h>
#include <ascii-chat/platform/network.h>
#include <ascii-chat/platform/system.h>
#include <ascii-chat/platform/filesystem.h>
#include <ascii-chat/util/path.h>
#include <ascii-chat/util/time.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/common.h>
 
#include <yyjson.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
 
// Cache file is stored in ~/.config/ascii-chat/last_update_check
#define UPDATE_CHECK_CACHE_FILENAME "last_update_check"
 
// Check is fresh if < 7 days old
#define UPDATE_CHECK_CACHE_MAX_AGE_SECONDS (7 * 24 * 60 * 60)
 
// DNS timeout for connectivity check
#define DNS_TIMEOUT_SECONDS 2
 
// GitHub API endpoint
#define GITHUB_API_HOSTNAME "api.github.com"
#define GITHUB_RELEASES_PATH "/repos/zfogg/ascii-chat/releases/latest"
 
static void trim_line_ending(char *line) {
  if (!line) {
    return;
  }
 
  size_t len = strlen(line);
  while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r')) {
    line[--len] = '\0';
  }
}
 
static char *get_cache_file_path(void) {
  // Get config directory
  char *config_dir = get_config_dir();
  if (!config_dir) {
    log_error("Failed to get config directory for update check cache");
    return NULL;
  }
 
  // The config directory may not exist on a first run. Create it before any
  // caller attempts to open the cache file for writing.
  if (platform_mkdir_recursive(config_dir, 0700) != ASCIICHAT_OK) {
    log_warn("Failed to create update check config directory: %s", config_dir);
  }
 
  // Build cache file path
  size_t path_len = strlen(config_dir) + strlen(UPDATE_CHECK_CACHE_FILENAME) + 2;
  char *cache_path = SAFE_MALLOC(path_len, char *);
  snprintf(cache_path, path_len, "%s%s", config_dir, UPDATE_CHECK_CACHE_FILENAME);
  SAFE_FREE(config_dir);
 
  return cache_path;
}
 
asciichat_error_t update_check_load_cache(update_check_result_t *result) {
  if (!result) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL result pointer");
  }
 
  memset(result, 0, sizeof(*result));
 
  char *cache_path = get_cache_file_path();
  if (!cache_path) {
    return SET_ERRNO(ERROR_FILE_OPERATION, "Could not determine cache file path");
  }
 
  FILE *f = platform_fopen("file_stream", cache_path, "r");
  if (!f) {
    const char *error_msg = file_read_error_message(cache_path);
    SAFE_FREE(cache_path);
    return SET_ERRNO(ERROR_FILE_OPERATION, "%s", error_msg);
  }
 
  // Read line 1: timestamp
  char line[512];
  if (!fgets(line, sizeof(line), f)) {
    fclose(f);
    SAFE_FREE(cache_path);
    return SET_ERRNO(ERROR_FILE_OPERATION, "Failed to read timestamp from cache");
  }
 
  // Parse timestamp safely with error checking
  errno = 0;
  char *endptr = NULL;
  long long timestamp_ll = strtoll(line, &endptr, 10);
  if (errno != 0 || endptr == line) {
    log_error("Failed to parse timestamp from cache: invalid value '%s'", line);
    fclose(f);
    SAFE_FREE(cache_path);
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid timestamp in cache file");
  }
  result->last_check_time = (time_t)timestamp_ll;
 
  // Read line 2: latest version (may be empty if check failed)
  if (fgets(line, sizeof(line), f)) {
    trim_line_ending(line);
    SAFE_STRNCPY(result->latest_version, line, sizeof(result->latest_version));
  }
 
  // Read line 3: latest SHA (may be empty if check failed)
  if (fgets(line, sizeof(line), f)) {
    trim_line_ending(line);
    SAFE_STRNCPY(result->latest_sha, line, sizeof(result->latest_sha));
  }
 
  // Read line 4: release URL. This field is required in the current cache
  // format; an older or partially-written cache must be refreshed.
  if (!fgets(line, sizeof(line), f)) {
    fclose(f);
    // Treat a legacy cache exactly like a missing cache. Close the file before
    // removing it so this also works on Windows, where open files cannot be
    // deleted.
    (void)remove(cache_path);
    SAFE_FREE(cache_path);
    return SET_ERRNO(ERROR_FORMAT, "Update cache format is obsolete");
  }
  trim_line_ending(line);
  SAFE_STRNCPY(result->release_url, line, sizeof(result->release_url));
 
  fclose(f);
 
  // Fill in current version/SHA
  SAFE_STRNCPY(result->current_version, ASCII_CHAT_VERSION_STRING, sizeof(result->current_version));
  SAFE_STRNCPY(result->current_sha, ASCII_CHAT_GIT_COMMIT_HASH, sizeof(result->current_sha));
 
  // Determine if update is available using version comparison (if we have cached data)
  if (result->latest_version[0] != '\0') {
    semantic_version_t current_ver = version_parse(result->current_version);
    semantic_version_t latest_ver = version_parse(result->latest_version);
 
    if (current_ver.valid && latest_ver.valid) {
      int cmp = version_compare(latest_ver, current_ver);
      result->update_available = (cmp > 0); // Update available if latest > current
      result->check_succeeded = true;
    } else {
      // Cache contains invalid version data - delete it
      log_warn("Update cache contains invalid version data (current:%s, latest:%s) - deleting corrupted cache",
               result->current_version, result->latest_version);
      if (remove(cache_path) != 0) {
        log_warn("Failed to delete corrupted cache file: %s", cache_path);
      }
      SAFE_FREE(cache_path);
      return SET_ERRNO(ERROR_FORMAT, "Corrupted cache file deleted");
    }
  }
 
  SAFE_FREE(cache_path);
  return ASCIICHAT_OK;
}
 
asciichat_error_t update_check_save_cache(const update_check_result_t *result) {
  if (!result) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL result pointer");
  }
 
  char *cache_path = get_cache_file_path();
  if (!cache_path) {
    return SET_ERRNO(ERROR_FILE_OPERATION, "Could not determine cache file path");
  }
 
  FILE *f = platform_fopen("file_stream", cache_path, "w");
  if (!f) {
    const char *error_msg = file_write_error_message(cache_path);
    SAFE_FREE(cache_path);
    return SET_ERRNO(ERROR_FILE_OPERATION, "%s", error_msg);
  }
 
  // Write timestamp
  fprintf(f, "%lld\n", (long long)result->last_check_time);
 
  // Write version (may be empty if check failed)
  fprintf(f, "%s\n", result->latest_version);
 
  // Write SHA (may be empty if check failed)
  fprintf(f, "%s\n", result->latest_sha);
 
  // Write the release URL so cached notifications retain the exact GitHub
  // source returned by the API.
  fprintf(f, "%s\n", result->release_url);
 
  fclose(f);
  SAFE_FREE(cache_path);
 
  return ASCIICHAT_OK;
}
 
bool update_check_is_cache_fresh(const update_check_result_t *result) {
  if (!result || result->last_check_time == 0) {
    return false;
  }
 
  time_t now = time(NULL);
  time_t age = now - result->last_check_time;
 
  return (age < UPDATE_CHECK_CACHE_MAX_AGE_SECONDS);
}
 
static bool parse_github_release_json(const char *json, char *tag_name, size_t tag_size, char *html_url,
                                      size_t url_size) {
  if (!json) {
    return false;
  }
 
  yyjson_doc *doc = yyjson_read(json, strlen(json), 0);
  if (!doc) {
    log_error("Failed to parse GitHub API response as JSON");
    return false;
  }
 
  yyjson_val *root = yyjson_doc_get_root(doc);
  yyjson_val *tag = yyjson_obj_get(root, "tag_name");
  yyjson_val *url = yyjson_obj_get(root, "html_url");
 
  bool ok = false;
  if (yyjson_is_str(tag) && yyjson_is_str(url)) {
    SAFE_STRNCPY(tag_name, yyjson_get_str(tag), tag_size);
    SAFE_STRNCPY(html_url, yyjson_get_str(url), url_size);
    ok = true;
  } else {
    if (!yyjson_is_str(tag)) {
      log_error("Failed to parse tag_name from GitHub API response");
    }
    if (!yyjson_is_str(url)) {
      log_error("Failed to parse html_url from GitHub API response");
    }
  }
 
  yyjson_doc_free(doc);
  return ok;
}
 
asciichat_error_t update_check_perform(update_check_result_t *result) {
  if (!result) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL result pointer");
  }
 
  memset(result, 0, sizeof(*result));
 
  // Fill in current version and SHA
  SAFE_STRNCPY(result->current_version, ASCII_CHAT_VERSION_STRING, sizeof(result->current_version));
  SAFE_STRNCPY(result->current_sha, ASCII_CHAT_GIT_COMMIT_HASH, sizeof(result->current_sha));
  result->last_check_time = time(NULL);
 
  // Test DNS connectivity first
  if (!dns_test_connectivity(GITHUB_API_HOSTNAME)) {
    log_warn("No internet connectivity detected, skipping update check");
    // Don't update cache - we'll retry when online
    return SET_ERRNO(ERROR_NETWORK, "DNS connectivity test failed");
  }
 
  // Fetch latest release from GitHub API
  log_info("Checking for updates from GitHub releases...");
  char *response = https_get(GITHUB_API_HOSTNAME, GITHUB_RELEASES_PATH);
  if (!response) {
    log_warn("Failed to fetch GitHub releases API (timeout or network error)");
    // Don't save cache on network failure — retry next startup
    result->check_succeeded = false;
    return SET_ERRNO(ERROR_NETWORK, "Failed to fetch GitHub releases");
  }
 
  // Parse JSON response
  char latest_tag[64] = {0};
  char release_url[512] = {0};
 
  if (!parse_github_release_json(response, latest_tag, sizeof(latest_tag), release_url, sizeof(release_url))) {
    log_error("Failed to parse GitHub API response");
    SAFE_FREE(response);
    // Don't save cache on parse failure — retry next startup
    result->check_succeeded = false;
    return SET_ERRNO(ERROR_FORMAT, "Failed to parse GitHub API JSON");
  }
 
  SAFE_FREE(response);
 
  // Fill in result
  SAFE_STRNCPY(result->latest_version, latest_tag, sizeof(result->latest_version));
  SAFE_STRNCPY(result->release_url, release_url, sizeof(result->release_url));
  result->latest_sha[0] = '\0';
  result->check_succeeded = true;
 
  // Compare versions semantically
  semantic_version_t current_ver = version_parse(result->current_version);
  semantic_version_t latest_ver = version_parse(result->latest_version);
 
  if (!current_ver.valid || !latest_ver.valid) {
    log_warn("Failed to parse version strings for comparison (current: %s, latest: %s)", result->current_version,
             result->latest_version);
    result->update_available = false;
  } else {
    int cmp = version_compare(latest_ver, current_ver);
    result->update_available = (cmp > 0); // Update available if latest > current
  }
 
  if (result->update_available) {
    log_info("Update available: %s → %s", result->current_version, result->latest_version);
  } else {
    log_info("Already on latest version: %s", result->current_version);
  }
 
  // Save to cache
  update_check_save_cache(result);
 
  return ASCIICHAT_OK;
}
 
static bool is_homebrew_install(void) {
  // Check if binary is in Homebrew Cellar directory
  char exe_path[1024];
  if (!platform_get_executable_path(exe_path, sizeof(exe_path))) {
    return false;
  }
 
  return (strstr(exe_path, "/Cellar/ascii-chat") != NULL || strstr(exe_path, "/opt/homebrew/") != NULL ||
          strstr(exe_path, "/usr/local/Cellar/") != NULL);
}
 
static bool is_arch_linux(void) {
#ifdef __linux__
  // Check /etc/os-release for Arch
  FILE *f = platform_fopen("file_stream", "/etc/os-release", "r");
  if (!f) {
    return false;
  }
 
  char line[256];
  bool is_arch = false;
  while (fgets(line, sizeof(line), f)) {
    if (strstr(line, "ID=arch") || strstr(line, "ID=\"arch\"")) {
      is_arch = true;
      break;
    }
  }
 
  fclose(f);
  return is_arch;
#else
  return false;
#endif
}
 
install_method_t update_check_detect_install_method(void) {
  if (is_homebrew_install()) {
    return INSTALL_METHOD_HOMEBREW;
  }
 
  if (is_arch_linux()) {
    return INSTALL_METHOD_ARCH_AUR;
  }
 
  // Default to GitHub releases
  return INSTALL_METHOD_GITHUB;
}
 
void update_check_get_upgrade_suggestion(install_method_t method, const char *latest_version, char *buffer,
                                         size_t buffer_size) {
  if (!buffer || buffer_size == 0) {
    return;
  }
 
  switch (method) {
  case INSTALL_METHOD_HOMEBREW:
    snprintf(buffer, buffer_size, "brew upgrade ascii-chat");
    break;
 
  case INSTALL_METHOD_ARCH_AUR: {
    // Cache AUR helper detection to avoid spawning subprocesses on every call
    static int aur_helper = -1; // -1 = unknown, 0 = none, 1 = paru, 2 = yay
    if (aur_helper == -1) {
      const char *argv_paru[] = {"paru", "--version", NULL};
      const char *argv_yay[] = {"yay", "--version", NULL};
      if (platform_execute_subprocess("paru", argv_paru, NULL, 0) == 0) {
        aur_helper = 1;
      } else if (platform_execute_subprocess("yay", argv_yay, NULL, 0) == 0) {
        aur_helper = 2;
      } else {
        aur_helper = 0;
      }
    }
    if (aur_helper == 1) {
      snprintf(buffer, buffer_size, "paru -S ascii-chat");
    } else if (aur_helper == 2) {
      snprintf(buffer, buffer_size, "yay -S ascii-chat");
    } else {
      snprintf(buffer, buffer_size, "<your-aur-helper> -Ss ascii-chat");
    }
    break;
  }
 
  case INSTALL_METHOD_GITHUB:
  case INSTALL_METHOD_UNKNOWN:
  default:
    snprintf(buffer, buffer_size, "https://github.com/zfogg/ascii-chat/releases/tag/%s",
             latest_version ? latest_version : "latest");
    break;
  }
}
 
void update_check_format_notification(const update_check_result_t *result, char *buffer, size_t buffer_size) {
  if (!result || !buffer || buffer_size == 0) {
    return;
  }
 
  // Get upgrade suggestion
  install_method_t method = update_check_detect_install_method();
  char suggestion[512];
  update_check_get_upgrade_suggestion(method, result->latest_version, suggestion, sizeof(suggestion));
 
  // Keep the notification useful even when it is displayed in a log line:
  // identify the versions, provide an actionable command or download URL, and
  // point to the exact GitHub release that was returned by the API.
  snprintf(buffer, buffer_size, "Update available: %s → %s. %s%s. Release notes: %s", result->current_version,
           result->latest_version,
           (method == INSTALL_METHOD_GITHUB || method == INSTALL_METHOD_UNKNOWN) ? "Download: " : "Run: ", suggestion,
           result->release_url);
}
 
asciichat_error_t update_check_startup(update_check_result_t *result) {
  update_check_result_t local_result;
  update_check_result_t *target = result ? result : &local_result;
 
  // Try to load from cache first
  asciichat_error_t cache_err = update_check_load_cache(target);
  if (cache_err == ASCIICHAT_OK && update_check_is_cache_fresh(target)) {
    // Cache is fresh, use it
    log_debug("Using cached update check result (age: %.1f days)",
              (time(NULL) - target->last_check_time) / (double)SEC_PER_DAY);
    return ASCIICHAT_OK;
  }
 
  // Cache is stale or missing, perform fresh check
  log_debug("Performing automatic update check (cache %s)", cache_err == ASCIICHAT_OK ? "stale" : "missing");
  asciichat_error_t check_err = update_check_perform(target);
  if (check_err != ASCIICHAT_OK) {
    // Check failed, but don't fail startup
    log_debug("Automatic update check failed (continuing startup)");
    return check_err;
  }
 
  return ASCIICHAT_OK;
}