feat: add update notifications and one-click updates

bin/arguments.js

@@ -120,6 +120,7 @@ const usageExamples = [
     description: 'Review the open pull request for a branch.',
   },
   { command: 'codiff mr 75', description: 'Review GitLab merge request !75.' },
+  { command: 'codiff update', description: 'Update Codiff to the latest release.' },
   { command: 'codiff --plan plan.md', description: 'Edit a plan and wait for handoff.' },
   { command: 'codiff --plan plan.md --share', description: 'Share a Markdown plan.' },
   { command: 'codiff -w', description: 'Walk through local changes, or HEAD when clean.' },

bin/codiff-app

@@ -20,6 +20,80 @@ codiff_version() {
   sed -n 's/^  "version": "\([^"]*\)".*/\1/p' "$script_dir/../package.json"
 }
 
+# major.minor.patch integer compare; any other shape is "not newer".
+is_newer_version() {
+  case "$1$2" in *[!0-9.]*|'') return 1 ;; esac
+  case ".$1." in *..*) return 1 ;; esac
+  case ".$2." in *..*) return 1 ;; esac
+  old_ifs="$IFS"
+  IFS=.
+  # shellcheck disable=SC2086
+  set -- $1 -- $2
+  IFS="$old_ifs"
+  [ "$#" -eq 7 ] && [ "$4" = "--" ] || return 1
+  # sh integer tests overflow beyond int64; nothing that large is a release.
+  for version_component in "$1" "$2" "$3" "$5" "$6" "$7"; do
+    [ "${#version_component}" -le 9 ] || return 1
+  done
+  latest_major="$1" latest_minor="$2" latest_patch="$3"
+  current_major="$5" current_minor="$6" current_patch="$7"
+  if [ "$latest_major" -ne "$current_major" ]; then
+    [ "$latest_major" -gt "$current_major" ]
+    return $?
+  fi
+  if [ "$latest_minor" -ne "$current_minor" ]; then
+    [ "$latest_minor" -gt "$current_minor" ]
+    return $?
+  fi
+  [ "$latest_patch" -gt "$current_patch" ]
+}
+
+# Mirror of the Node notice's Date.parse gate, restricted to the ISO shape
+# the app writes: YYYY-MM-DDTHH:MM:SS with in-range components, optionally
+# followed by a .mmm fraction and Z. Anything else, including timezone
+# offsets Date.parse would accept, stays silent. Day-in-month overflow such
+# as February 30th passes, matching the Date.parse rollover behavior.
+is_iso_timestamp() {
+  case "$1" in
+    [0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-5][0-9]:[0-5][0-9]*) ;;
+    *) return 1 ;;
+  esac
+  iso_month="${1#????-}"
+  iso_month="${iso_month%%-*}"
+  iso_day="${1#????-??-}"
+  iso_day="${iso_day%%T*}"
+  iso_hour="${1#????-??-??T}"
+  iso_hour="${iso_hour%%:*}"
+  iso_tail="${1#????-??-??T??:??:??}"
+  case "$iso_month" in 0[1-9]|1[0-2]) ;; *) return 1 ;; esac
+  case "$iso_day" in 0[1-9]|[12][0-9]|3[01]) ;; *) return 1 ;; esac
+  case "$iso_hour" in [01][0-9]|2[0-3]) ;; *) return 1 ;; esac
+  case "$iso_tail" in ''|Z|.[0-9][0-9][0-9]|.[0-9][0-9][0-9]Z) ;; *) return 1 ;; esac
+}
+
+# Mirror of bin/update-notice.js for the wrapper-owned code paths: read the
+# state cached by the app's daily check and never touch the network. The
+# notice is best effort: a missing, unreadable, or corrupt cache must stay
+# silent and must never change the wrapped command's exit status.
+print_update_notice() {
+  [ -n "${HOME:-}" ] || return 0
+  state_file="$HOME/.codiff/update-state.json"
+  [ -f "$state_file" ] && [ -r "$state_file" ] || return 0
+  # tail -n 1 mirrors JSON duplicate-key last-wins resolution.
+  checked_at="$(sed -n 's/.*"lastCheckedAt"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$state_file" 2>/dev/null | tail -n 1)"
+  latest="$(sed -n 's/.*"latestVersion"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$state_file" 2>/dev/null | tail -n 1)"
+  dismissed="$(sed -n 's/.*"dismissedVersion"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$state_file" 2>/dev/null | tail -n 1)"
+  is_iso_timestamp "$checked_at" || return 0
+  [ -n "$latest" ] || return 0
+  [ "$latest" = "$dismissed" ] && return 0
+  current="$(codiff_version)"
+  is_newer_version "$latest" "$current" || return 0
+  # The backticks are literal command quoting, not a missed expansion.
+  # shellcheck disable=SC2016
+  printf 'A new version of Codiff is available (v%s -> v%s). Run `codiff update` to update.\n' \
+    "$current" "$latest" >&2
+}
+
 show_help() {
   version="$(codiff_version)"
   blue_bold="$(printf '\033[1;34m')"
@@ -30,6 +104,9 @@ show_help() {
   printf '\n'
   printf '%s\n' "${blue_bold}Usage:${reset} ${gray}codiff [options] [<ref> | <pr> | <url>] [path]${reset}"
   printf '\n'
+  printf '%s\n' "${blue_bold}Commands:${reset}"
+  printf '  %-38s%s%s%s\n' "update" "$gray" "Update Codiff to the latest release." "$reset"
+  printf '\n'
   printf '%s\n' "${blue_bold}Options:${reset}"
   printf '  %-38s%s%s%s\n' "--agent <codex|claude|opencode|pi>" "$gray" "Override the agent backend for this session." "$reset"
   printf '  %-38s%s%s%s\n' "--branch <ref>" "$gray" "Review the current branch against a target branch." "$reset"
@@ -65,22 +142,32 @@ show_help() {
   printf '  %-32s%s%s%s\n' "codiff --share HEAD" "$gray" "Share a walkthrough for a commit." "$reset"
 }
 
+resolve_runtime() {
+  runtime="${CODIFF_NODE_COMMAND:-}"
+  if [ -z "$runtime" ]; then
+    electron_exec="$(ls "$app_path/Contents/MacOS/" 2>/dev/null | head -n 1)"
+    if [ -n "$electron_exec" ]; then
+      runtime="$app_path/Contents/MacOS/$electron_exec"
+    fi
+  fi
+  if [ -z "$runtime" ] || [ ! -x "$runtime" ]; then
+    printf '%s\n' "codiff: could not find the bundled runtime for $1." >&2
+    exit 1
+  fi
+}
+
+# `codiff update` checks GitHub Releases and updates this install in place.
+if [ "$#" -eq 1 ] && [ "$1" = "update" ]; then
+  resolve_runtime update
+  ELECTRON_RUN_AS_NODE=1 exec "$runtime" "$script_dir/codiff.js" update
+fi
+
 # Flags the Node entry owns: it does the work and prints the result, so this
 # helper hands the whole command line over to the bundled runtime.
 for arg in "$@"; do
   case "$arg" in
     --share|--public|--completions|--completions=*)
-      runtime="${CODIFF_NODE_COMMAND:-}"
-      if [ -z "$runtime" ]; then
-        electron_exec="$(ls "$app_path/Contents/MacOS/" 2>/dev/null | head -n 1)"
-        if [ -n "$electron_exec" ]; then
-          runtime="$app_path/Contents/MacOS/$electron_exec"
-        fi
-      fi
-      if [ -z "$runtime" ] || [ ! -x "$runtime" ]; then
-        printf '%s\n' "codiff: could not find the bundled runtime for $arg." >&2
-        exit 1
-      fi
+      resolve_runtime "$arg"
       ELECTRON_RUN_AS_NODE=1 exec "$runtime" "$script_dir/codiff.js" "$@"
       ;;
   esac
@@ -259,6 +346,7 @@ for arg in "$@"; do
       ;;
     --version|-v)
       printf 'codiff v%s\n' "$(codiff_version)"
+      print_update_notice
       exit 0
       ;;
     --walkthrough-guide)
@@ -487,6 +575,8 @@ open_codiff() {
   open -n "$app_path" --args "$@"
 }
 
+print_update_notice
+
 if [ -n "$plan_file_path" ]; then
   if [ -z "$plan_result_file_path" ]; then
     plan_result_directory="$(mktemp -d "${TMPDIR:-/tmp}/codiff-plan-result.XXXXXX")"

bin/codiff.js

@@ -17,6 +17,8 @@ import {
 } from './arguments.js';
 import { completionShells, generateCompletionScript } from './completions.js';
 import { waitForPlanResult } from './plan-result.js';
+import { runUpdateCommand } from './update-command.js';
+import { getUpdateNotice } from './update-notice.js';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const require = createRequire(import.meta.url);
@@ -105,7 +107,30 @@ const buildWalkthroughGuide = () => {
   return `${guide}\n\n\`\`\`json\n${JSON.stringify(narrativeWalkthroughSchema, null, 2)}\n\`\`\`\n`;
 };
 
+const runCodiffUpdate = () => {
+  const appBundleMatch = process.platform === 'darwin' ? root.match(/^(.*\.app)\//) : null;
+  return runUpdateCommand({
+    currentVersion: packageJson.version,
+    isSourceCheckout: existsSync(resolve(root, '.git')),
+    log: (line) => process.stdout.write(`${line}\n`),
+    openApp: appBundleMatch
+      ? () => {
+          spawn('open', ['-n', appBundleMatch[1], '--args', '--apply-update'], {
+            detached: true,
+            stdio: 'ignore',
+          }).unref();
+        }
+      : null,
+  });
+};
+
 const run = async () => {
+  const rawArguments = process.argv.slice(2);
+  if (rawArguments.length === 1 && rawArguments[0] === 'update') {
+    process.exitCode = await runCodiffUpdate();
+    return;
+  }
+
   const parsedArguments = parseArguments(process.argv.slice(2));
 
   if (parsedArguments.help) {
@@ -115,6 +140,10 @@ const run = async () => {
 
   if (parsedArguments.version) {
     process.stdout.write(`codiff v${packageJson.version}\n`);
+    const notice = getUpdateNotice({ currentVersion: packageJson.version });
+    if (notice) {
+      process.stderr.write(`${notice}\n`);
+    }
     return;
   }
 
@@ -296,6 +325,11 @@ const run = async () => {
   delete childEnv.ELECTRON_RUN_AS_NODE;
   delete childEnv.ELECTRON_NO_ATTACH_CONSOLE;
 
+  const updateNotice = getUpdateNotice({ currentVersion: packageJson.version });
+  if (updateNotice) {
+    process.stderr.write(`${updateNotice}\n`);
+  }
+
   const { default: electron } = await import('electron');
 
   const child = spawn(electron, [root], {

bin/update-command.js

@@ -0,0 +1,88 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const {
+  fetchLatestRelease,
+  isNewerVersion,
+  releasePageUrl,
+} = require('../electron/update-check.cjs');
+
+/**
+ * Decide what `codiff update` should do for this install.
+ *
+ * Homebrew-owned installs are not special-cased: the cask is marked
+ * auto_updates, so the app updating itself in place is the supported path and
+ * stays ahead of a tap that may lag behind the newest release.
+ *
+ * @param {{
+ *   currentVersion: string;
+ *   isSourceCheckout: boolean;
+ *   latestVersion: string;
+ * }} options
+ * @returns {{ kind: 'up-to-date' } | { kind: 'open-app' | 'source-checkout'; version: string }}
+ */
+export function resolveUpdateAction({ currentVersion, isSourceCheckout, latestVersion }) {
+  if (!isNewerVersion(latestVersion, currentVersion)) {
+    return { kind: 'up-to-date' };
+  }
+
+  return isSourceCheckout
+    ? { kind: 'source-checkout', version: latestVersion }
+    : { kind: 'open-app', version: latestVersion };
+}
+
+/**
+ * Check GitHub Releases and perform the platform-appropriate update.
+ *
+ * @param {{
+ *   currentVersion: string;
+ *   isSourceCheckout: boolean;
+ *   log: (line: string) => void;
+ *   openApp: (() => void) | null;
+ *   releaseUrl?: string;
+ * }} options
+ * @returns {Promise<number>}
+ */
+export async function runUpdateCommand({
+  currentVersion,
+  isSourceCheckout,
+  log,
+  openApp,
+  releaseUrl,
+}) {
+  let latestVersion;
+  try {
+    latestVersion = (await fetchLatestRelease(releaseUrl)).version;
+  } catch (error) {
+    log(
+      `codiff: could not check for updates: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+    return 1;
+  }
+
+  const action = resolveUpdateAction({ currentVersion, isSourceCheckout, latestVersion });
+
+  switch (action.kind) {
+    case 'up-to-date':
+      log(`codiff v${currentVersion} is up to date.`);
+      return 0;
+    case 'source-checkout':
+      log(
+        `Codiff v${action.version} is available, but this is a source checkout. Run git pull and rebuild instead.`,
+      );
+      return 0;
+    case 'open-app':
+      if (openApp) {
+        log(`Opening Codiff to install v${action.version}…`);
+        openApp();
+        return 0;
+      }
+
+      log(
+        `Codiff v${action.version} is available. Download it from ${releasePageUrl(action.version)} or open the app and use the update banner.`,
+      );
+      return 1;
+  }
+}

bin/update-notice.js

@@ -0,0 +1,18 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { getAvailableUpdate, readUpdateState } = require('../electron/update-check.cjs');
+
+/**
+ * Build a one-line update notice from the state cached by the app's daily
+ * check. Never performs network requests so CLI startup stays instant.
+ *
+ * @param {{ configDir?: string; currentVersion: string }} options
+ * @returns {string | null}
+ */
+export function getUpdateNotice({ configDir, currentVersion }) {
+  const update = getAvailableUpdate(readUpdateState(configDir), currentVersion);
+  return update
+    ? `A new version of Codiff is available (v${currentVersion} -> v${update.version}). Run \`codiff update\` to update.`
+    : null;
+}

config/defaults.json

@@ -1,6 +1,7 @@
 {
   "settings": {
     "agentBackend": "codex",
+    "checkForUpdates": true,
     "claudeModel": "claude-sonnet-4-6",
     "codeFontFamily": "",
     "codeFontSize": 13,