tlc-claude-code 2.2.1 → 2.4.0

package/bin/setup-autoupdate.js

@@ -1,30 +1,230 @@
 /**
  * TLC Auto-Update Setup
- * Creates scheduled jobs to keep Claude Code and Codex CLI updated daily.
+ *
+ * Generates a self-contained bash script that keeps Claude, Codex, and Gemini
+ * CLIs updated daily. The script detects each CLI's install method (Homebrew,
+ * npm global, standalone binary) at runtime and uses the correct update command.
+ * macOS: scheduled via launchd (runs missed jobs after wake).
+ * Linux: scheduled via cron.
+ * No Node.js dependency at runtime — pure bash.
  */
 
 import os from 'os';
 import path from 'path';
 
-const LAUNCH_AGENT_LABEL = 'com.tlc.autoupdate';
-const LAUNCH_AGENT_PLIST = `${os.homedir()}/Library/LaunchAgents/${LAUNCH_AGENT_LABEL}.plist`;
-const TLC_DIR = `${os.homedir()}/.tlc`;
-const SCRIPT_PATH = `${TLC_DIR}/autoupdate.sh`;
-const LOG_PATH = `${TLC_DIR}/logs/autoupdate.log`;
+const TLC_DIR = path.join(os.homedir(), '.tlc');
+const SCRIPT_PATH = path.join(TLC_DIR, 'autoupdate.sh');
+const CRON_MARKER = '# tlc-autoupdate';
 const TIMESTAMP_FILE = '.last-update';
+const LAUNCHD_PLIST = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.tlc.autoupdate.plist');
+const UPDATE_AVAILABLE_FILE = '.update-available';
+
+/** @type {string} npm package name for TLC */
+export const TLC_PACKAGE = 'tlc-claude-code';
+
+/**
+ * Package names per install method for each supported CLI.
+ * @type {Record<string, { npm: string, brew: string, selfUpdate: string|null }>}
+ */
+export const CLI_PACKAGES = {
+  claude: {
+    npm: '@anthropic-ai/claude-code',
+    brew: 'claude-code',
+    selfUpdate: 'claude update',
+  },
+  codex: {
+    npm: '@openai/codex',
+    brew: 'codex',
+    selfUpdate: null,
+  },
+  gemini: {
+    npm: '@google/gemini-cli',
+    brew: 'gemini-cli',
+    selfUpdate: null,
+  },
+};
+
+/**
+ * Generates a self-contained bash script that detects install methods at
+ * runtime and updates all three CLIs. Designed to run from cron with a
+ * minimal environment.
+ * @returns {string} Complete bash script content.
+ */
+export function generateUpdateScript() {
+  return `#!/usr/bin/env bash
+set -euo pipefail
+
+# ── PATH setup (cron has minimal PATH) ──────────────────────────────
+# Homebrew paths
+if [ -d "/opt/homebrew/bin" ]; then
+  export PATH="/opt/homebrew/bin:\$PATH"
+fi
+if [ -d "/usr/local/bin" ]; then
+  export PATH="/usr/local/bin:\$PATH"
+fi
+# Version managers (nvm, volta, asdf)
+[ -s "\$HOME/.nvm/nvm.sh" ] && . "\$HOME/.nvm/nvm.sh" 2>/dev/null
+[ -d "\$HOME/.volta/bin" ] && export PATH="\$HOME/.volta/bin:\$PATH"
+[ -d "\$HOME/.asdf/shims" ] && export PATH="\$HOME/.asdf/shims:\$PATH"
+# npm global bin (fallback for non-managed installs)
+NPM_BIN="\$(npm config get prefix 2>/dev/null)/bin" || true
+if [ -d "\$NPM_BIN" ]; then
+  export PATH="\$NPM_BIN:\$PATH"
+fi
+
+# ── Directories ─────────────────────────────────────────────────────
+TLC_DIR="\$HOME/.tlc"
+LOG_DIR="\$TLC_DIR/logs"
+LOG_FILE="\$LOG_DIR/autoupdate.log"
+TIMESTAMP_FILE="\$TLC_DIR/.last-update"
+
+mkdir -p "\$LOG_DIR"
+
+log() {
+  echo "\$(date -u +%Y-%m-%dT%H:%M:%SZ) \$1" >> "\$LOG_FILE"
+}
+
+# ── Install method detection ────────────────────────────────────────
+# Returns: "brew", "npm", "standalone", or "" (not installed)
+detect_install_method() {
+  local cli_name="\$1"
+  local brew_pkg="\$2"
+  local npm_pkg="\$3"
+
+  if ! command -v "\$cli_name" &>/dev/null; then
+    echo ""
+    return
+  fi
+
+  # Check Homebrew first
+  if command -v brew &>/dev/null && brew list --formula 2>/dev/null | grep -q "^\${brew_pkg}\$"; then
+    echo "brew"
+    return
+  fi
+
+  # Check npm global
+  if command -v npm &>/dev/null && npm list -g "\$npm_pkg" --depth=0 2>/dev/null | grep -q "\$npm_pkg"; then
+    echo "npm"
+    return
+  fi
+
+  echo "standalone"
+}
+
+# ── Update dispatcher ───────────────────────────────────────────────
+update_cli() {
+  local cli_name="\$1"
+  local method="\$2"
+  local brew_pkg="\$3"
+  local npm_pkg="\$4"
+  local self_update="\${5:-}"
+
+  case "\$method" in
+    brew)
+      log "Updating \$cli_name via brew upgrade \$brew_pkg"
+      brew upgrade "\$brew_pkg" >> "\$LOG_FILE" 2>&1 || log "\$cli_name brew upgrade failed"
+      ;;
+    npm)
+      log "Updating \$cli_name via npm update -g \$npm_pkg"
+      npm update -g "\$npm_pkg" >> "\$LOG_FILE" 2>&1 || log "\$cli_name npm update failed"
+      ;;
+    standalone)
+      if [ -n "\$self_update" ]; then
+        log "Updating \$cli_name via \$self_update"
+        \$self_update >> "\$LOG_FILE" 2>&1 || log "\$cli_name self-update failed"
+      else
+        log "Skipping \$cli_name — standalone install with no self-update command"
+      fi
+      ;;
+    *)
+      log "Skipping \$cli_name — not installed"
+      ;;
+  esac
+}
+
+# ── Main ────────────────────────────────────────────────────────────
+log "Starting TLC auto-update"
+
+# Claude Code
+if command -v claude &>/dev/null; then
+  CLAUDE_METHOD=\$(detect_install_method "claude" "claude-code" "@anthropic-ai/claude-code")
+  update_cli "claude" "\$CLAUDE_METHOD" "claude-code" "@anthropic-ai/claude-code" "claude update"
+fi
+
+# Codex CLI
+if command -v codex &>/dev/null; then
+  CODEX_METHOD=\$(detect_install_method "codex" "codex" "@openai/codex")
+  update_cli "codex" "\$CODEX_METHOD" "codex" "@openai/codex"
+fi
+
+# Gemini CLI
+if command -v gemini &>/dev/null; then
+  GEMINI_METHOD=\$(detect_install_method "gemini" "gemini-cli" "@google/gemini-cli")
+  update_cli "gemini" "\$GEMINI_METHOD" "gemini-cli" "@google/gemini-cli"
+fi
+
+# TLC itself
+if command -v npm &>/dev/null; then
+  log "Updating TLC (tlc-claude-code) via npm"
+  npm update -g tlc-claude-code >> "\$LOG_FILE" 2>&1 || log "TLC npm update failed"
+
+  # Re-read installed version AFTER update to get current state
+  INSTALLED=\$(npm list -g tlc-claude-code --depth=0 --json 2>/dev/null | grep -o '"version": *"[^"]*"' | head -1 | grep -o '[0-9][^"]*') || true
+  LATEST=\$(npm show tlc-claude-code version 2>/dev/null) || true
+  UPDATE_FILE="\$TLC_DIR/.update-available"
+  if [ -n "\$LATEST" ] && [ -n "\$INSTALLED" ] && [ "\$LATEST" != "\$INSTALLED" ]; then
+    # POSIX-compatible version compare (no sort -V which is GNU-only)
+    ver_gt() {
+      local IFS=.
+      local i a=(\$1) b=(\$2)
+      for ((i=0; i<\${#a[@]}; i++)); do
+        [ "\${a[i]:-0}" -gt "\${b[i]:-0}" ] && return 0
+        [ "\${a[i]:-0}" -lt "\${b[i]:-0}" ] && return 1
+      done
+      return 1
+    }
+    if ver_gt "\$LATEST" "\$INSTALLED"; then
+      printf 'current=%s\\nlatest=%s\\ncommand=npm update -g tlc-claude-code\\n' "\$INSTALLED" "\$LATEST" > "\$UPDATE_FILE"
+      log "TLC update available: \$INSTALLED → \$LATEST"
+    else
+      rm -f "\$UPDATE_FILE"
+    fi
+  else
+    rm -f "\$UPDATE_FILE"
+  fi
+fi
+
+# Write completion timestamp
+date -u +%Y-%m-%dT%H:%M:%SZ > "\$TIMESTAMP_FILE"
+
+log "TLC auto-update complete"
+`;
+}
+
+/**
+ * Generates a crontab entry string for daily auto-update at 4am.
+ * Includes a marker comment so we can identify and remove it later.
+ * @param {string} scriptPath - Absolute path to the update shell script.
+ * @returns {string} A single crontab line with trailing marker.
+ */
+export function generateCronEntry(scriptPath) {
+  return `0 4 * * * ${scriptPath} ${CRON_MARKER}`;
+}
 
 /**
- * Generates a macOS LaunchAgent plist XML string for daily auto-update.
+ * Generates a macOS LaunchAgent plist for daily auto-update.
+ * launchd runs missed jobs after wake, unlike cron which skips them.
  * @param {string} scriptPath - Absolute path to the update shell script.
  * @returns {string} XML plist content.
  */
 export function generateLaunchdPlist(scriptPath) {
+  const logPath = path.join(TLC_DIR, 'logs', 'autoupdate.log');
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>${LAUNCH_AGENT_LABEL}</string>
+  <string>com.tlc.autoupdate</string>
   <key>ProgramArguments</key>
   <array>
     <string>/bin/bash</string>
@@ -35,136 +235,111 @@ export function generateLaunchdPlist(scriptPath) {
   <key>RunAtLoad</key>
   <false/>
   <key>StandardOutPath</key>
-  <string>${LOG_PATH}</string>
+  <string>${logPath}</string>
   <key>StandardErrorPath</key>
-  <string>${LOG_PATH}</string>
+  <string>${logPath}</string>
 </dict>
 </plist>
 `;
 }
 
 /**
- * Generates a crontab entry string for daily auto-update at 4am.
- * @param {string} scriptPath - Absolute path to the update shell script.
- * @returns {string} A single crontab line.
- */
-export function generateCronEntry(scriptPath) {
-  return `0 4 * * * ${scriptPath}`;
-}
-
-/**
- * Generates a bash update script that runs `claude update` and
- * `npm update -g @openai/codex`, logs output, and writes a timestamp.
- * @returns {string} Bash script content.
- */
-export function generateUpdateScript() {
-  return `#!/usr/bin/env bash
-set -euo pipefail
-
-TLC_DIR="$HOME/.tlc"
-LOG_DIR="$TLC_DIR/logs"
-LOG_FILE="$LOG_DIR/autoupdate.log"
-TIMESTAMP_FILE="$TLC_DIR/.last-update"
-
-mkdir -p "$LOG_DIR"
-
-echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) Starting TLC auto-update" >> "$LOG_FILE"
-
-# Update Claude Code
-if command -v claude &>/dev/null; then
-  echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) Running: claude update" >> "$LOG_FILE"
-  claude update >> "$LOG_FILE" 2>&1 || echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) claude update failed" >> "$LOG_FILE"
-fi
-
-# Update Codex CLI
-echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) Running: npm update -g @openai/codex" >> "$LOG_FILE"
-npm update -g @openai/codex >> "$LOG_FILE" 2>&1 || echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) npm update failed" >> "$LOG_FILE"
-
-# Write timestamp
-date -u +%Y-%m-%dT%H:%M:%SZ > "$TIMESTAMP_FILE"
-
-echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) TLC auto-update complete" >> "$LOG_FILE"
-`;
-}
-
-/**
- * Enables auto-update scheduled job for the current platform.
+ * Writes the update script and installs the platform scheduler.
+ * macOS: launchd (runs missed jobs after wake)
+ * Linux: cron
  * @param {object} opts
  * @param {string} opts.platform - 'darwin' or 'linux'
  * @param {object} opts.fs - fs module (injected for testability)
- * @param {Function} [opts.execSync] - child_process.execSync (injected for testability)
- * @returns {{ type: string, scriptPath: string, jobPath?: string }}
+ * @param {Function} [opts.execSync] - child_process.execSync (required for Linux)
+ * @returns {{ type: 'launchd'|'cron', scriptPath: string, plistPath?: string }}
  */
 export function enable({ platform, fs, execSync }) {
-  // Ensure TLC directories exist
   fs.mkdirSync(TLC_DIR, { recursive: true });
-  fs.mkdirSync(`${TLC_DIR}/logs`, { recursive: true });
+  fs.mkdirSync(path.join(TLC_DIR, 'logs'), { recursive: true });
 
-  // Write the update script
   const scriptContent = generateUpdateScript();
   fs.writeFileSync(SCRIPT_PATH, scriptContent, 'utf8');
   fs.chmodSync(SCRIPT_PATH, 0o755);
 
   if (platform === 'darwin') {
-    const launchAgentDir = path.dirname(LAUNCH_AGENT_PLIST);
-    fs.mkdirSync(launchAgentDir, { recursive: true });
+    const plistDir = path.dirname(LAUNCHD_PLIST);
+    fs.mkdirSync(plistDir, { recursive: true });
     const plist = generateLaunchdPlist(SCRIPT_PATH);
-    fs.writeFileSync(LAUNCH_AGENT_PLIST, plist, 'utf8');
-    return { type: 'launchd', scriptPath: SCRIPT_PATH, jobPath: LAUNCH_AGENT_PLIST };
+    fs.writeFileSync(LAUNCHD_PLIST, plist, 'utf8');
+    return { type: 'launchd', scriptPath: SCRIPT_PATH, plistPath: LAUNCHD_PLIST };
   }
 
-  // Linux — use cron
-  const entry = generateCronEntry(SCRIPT_PATH);
+  // Linux: cron
   let existing = '';
   try {
     existing = execSync('crontab -l 2>/dev/null || true', { encoding: 'utf8' });
-  } catch (_) {
+  } catch {
     existing = '';
   }
-  const newCrontab = existing.trimEnd() + (existing.trim() ? '\n' : '') + entry + '\n';
-  // Write via heredoc to preserve newlines correctly
-  execSync(`crontab - <<'CRONTAB_EOF'\n${newCrontab}CRONTAB_EOF`);
+
+  if (existing.includes(CRON_MARKER)) {
+    return { type: 'cron', scriptPath: SCRIPT_PATH };
+  }
+
+  // Strip legacy unmarked TLC autoupdate entries (match our specific path)
+  const cleaned = existing
+    .split('\n')
+    .filter(line => !line.includes(SCRIPT_PATH))
+    .join('\n');
+
+  const entry = generateCronEntry(SCRIPT_PATH);
+  const newCrontab = cleaned.trimEnd() + (cleaned.trim() ? '\n' : '') + entry + '\n';
+  execSync('crontab -', { input: newCrontab, encoding: 'utf8' });
 
   return { type: 'cron', scriptPath: SCRIPT_PATH };
 }
 
 /**
- * Disables the auto-update scheduled job.
+ * Disables the auto-update scheduler.
+ * macOS: removes launchd plist
+ * Linux: removes cron entry
  * @param {object} opts
  * @param {string} opts.platform - 'darwin' or 'linux'
- * @param {object} opts.fs - fs module (injected for testability)
- * @param {Function} [opts.execSync] - child_process.execSync (injected for testability)
+ * @param {object} [opts.fs] - fs module (required for macOS)
+ * @param {Function} [opts.execSync] - child_process.execSync (required for Linux)
  * @returns {{ removed: boolean }}
  */
 export function disable({ platform, fs, execSync }) {
   if (platform === 'darwin') {
-    if (fs.existsSync(LAUNCH_AGENT_PLIST)) {
-      fs.unlinkSync(LAUNCH_AGENT_PLIST);
+    if (fs && fs.existsSync(LAUNCHD_PLIST)) {
+      fs.unlinkSync(LAUNCHD_PLIST);
       return { removed: true };
     }
     return { removed: false };
   }
 
-  // Linux — strip TLC cron entry
+  // Linux: cron
   let existing = '';
   try {
     existing = execSync('crontab -l 2>/dev/null || true', { encoding: 'utf8' });
-  } catch (_) {
-    existing = '';
+  } catch {
+    return { removed: false };
   }
+
+  const hasMarked = existing.includes(CRON_MARKER);
+  const hasLegacy = !hasMarked && existing.includes(SCRIPT_PATH);
+
+  if (!hasMarked && !hasLegacy) {
+    return { removed: false };
+  }
+
   const filtered = existing
     .split('\n')
-    .filter(line => !line.includes(TLC_DIR) && !line.includes('autoupdate'))
+    .filter(line => !line.includes(CRON_MARKER) && !line.includes(SCRIPT_PATH))
     .join('\n');
-  const changed = filtered.trim() !== existing.trim();
-  if (changed) {
-    try {
-      const cleanCrontab = filtered.trim() + '\n';
-      execSync(`crontab - <<'CRONTAB_EOF'\n${cleanCrontab}CRONTAB_EOF`);
-    } catch (_) {
-      // best effort
-    }
+
+  const cleanCrontab = filtered.trim() ? filtered.trim() + '\n' : '';
+  if (cleanCrontab) {
+    execSync('crontab -', { input: cleanCrontab, encoding: 'utf8' });
+  } else {
+    execSync('crontab -r 2>/dev/null || true');
   }
+
   return { removed: true };
 }
 
@@ -204,3 +379,57 @@ export function isStale(timestamp) {
   const age = Date.now() - new Date(timestamp).getTime();
   return age > 24 * 60 * 60 * 1000;
 }
+
+/**
+ * Compares installed TLC version against latest on npm.
+ * Writes a notification file if an update is available, removes it if up to date.
+ * Designed to be called from the SessionStart hook for instant feedback.
+ * @param {object} opts
+ * @param {Function} opts.execSync - child_process.execSync
+ * @param {string} opts.installedVersion - current TLC version
+ * @param {object} [opts.fs] - fs module (for writing notification file)
+ * @param {string} [opts.dir] - directory for the notification file
+ * @returns {{ current: string, latest: string } | null}
+ */
+export function checkForUpdate({ execSync, installedVersion, fs, dir }) {
+  let latest;
+  try {
+    latest = execSync(`npm show ${TLC_PACKAGE} version 2>/dev/null`, { encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+
+  if (!latest || latest === installedVersion) {
+    // Up to date — remove stale notification if present
+    if (fs && dir) {
+      const notifPath = path.join(dir, UPDATE_AVAILABLE_FILE);
+      if (fs.existsSync && fs.existsSync(notifPath)) {
+        fs.unlinkSync(notifPath);
+      }
+    }
+    return null;
+  }
+
+  // Simple semver compare: split and compare major.minor.patch
+  const parse = (v) => v.split('.').map(Number);
+  const [cMaj, cMin, cPat] = parse(installedVersion);
+  const [lMaj, lMin, lPat] = parse(latest);
+  const isNewer = lMaj > cMaj || (lMaj === cMaj && lMin > cMin) || (lMaj === cMaj && lMin === cMin && lPat > cPat);
+
+  if (!isNewer) {
+    return null;
+  }
+
+  // Write notification file for SessionStart hook to display
+  if (fs && dir) {
+    fs.mkdirSync(dir, { recursive: true });
+    const msg = [
+      `current=${installedVersion}`,
+      `latest=${latest}`,
+      `command=npm update -g ${TLC_PACKAGE}`,
+    ].join('\n');
+    fs.writeFileSync(path.join(dir, UPDATE_AVAILABLE_FILE), msg, 'utf8');
+  }
+
+  return { current: installedVersion, latest };
+}