feat(updates): implement custom update checker with caching

Add new update checker module that replaces update-notifier dependency. The implementation includes:
- Background update checks with 24-hour cache
- NPM registry version comparison
- Environment variable controls
- Synchronous status check for TUI

Author: moazbuilds

src/cli/tui/shared/context/update-notifier.tsx

@@ -1,9 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import { createSignal, onMount } from "solid-js"
-import updateNotifier from "update-notifier"
 import { createSimpleContext } from "./helper"
-import { createRequire } from "node:module"
-import { resolvePackageJson } from "../../../../shared/runtime/root.js"
+import { status } from "../../../../shared/updates/index.js"
 
 export const { use: useUpdateNotifier, provider: UpdateNotifierProvider } = createSimpleContext({
   name: "UpdateNotifier",
@@ -13,25 +11,10 @@ export const { use: useUpdateNotifier, provider: UpdateNotifierProvider } = crea
     const [latestVersion, setLatestVersion] = createSignal("")
 
     onMount(() => {
-      // Check for updates (respects NO_UPDATE_NOTIFIER and CI environments)
-      if (!process.env.NO_UPDATE_NOTIFIER && !process.env.CODEMACHINE_NO_UPDATE_CHECK) {
-        try {
-          const require = createRequire(import.meta.url)
-          const packageJsonPath = resolvePackageJson(import.meta.url, "update notifier context")
-          const pkg = require(packageJsonPath) as { version: string; name: string }
-
-          const notifier = updateNotifier({
-            pkg,
-            updateCheckInterval: 1000 * 60 * 60 * 24, // Check once per day
-          })
-
-          if (notifier.update) {
-            setUpdateAvailable(true)
-            setLatestVersion(notifier.update.latest)
-          }
-        } catch {
-          // Silently fail if update check errors (offline, network issues, etc.)
-        }
+      const cache = status()
+      if (cache && cache.available && cache.latest) {
+        setUpdateAvailable(true)
+        setLatestVersion(cache.latest)
       }
       setReady(true)
     })

src/runtime/cli-setup.ts

@@ -76,6 +76,11 @@ const DEFAULT_SPEC_PATH = '.codemachine/inputs/specifications.md';
  * Note: .codemachine folder initialization is handled by workflow run, not here
  */
 async function initializeInBackground(cwd: string): Promise<void> {
+  // Check for updates (writes to ~/.codemachine/resources/updates.json)
+  appDebug('[Init] Checking for updates');
+  const { check } = await import('../shared/updates/index.js');
+  check().catch(err => appDebug('[Init] Update check error: %s', err));
+
   const cmRoot = path.join(cwd, '.codemachine');
 
   // Only bootstrap if .codemachine doesn't exist

src/shared/updates/checker.ts

@@ -0,0 +1,125 @@
+import { homedir } from "os"
+import { join } from "path"
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs"
+import { createRequire } from "node:module"
+import { resolvePackageJson } from "../runtime/root.js"
+import { appDebug } from "../logging/logger.js"
+import type { UpdateCache } from "./types.js"
+
+function debug(message: string, ...args: unknown[]) {
+  appDebug(`[UpdateChecker] ${message}`, ...args)
+}
+
+const CACHE_DIR = join(homedir(), ".codemachine", "resources")
+const CACHE_PATH = join(CACHE_DIR, "updates.json")
+const CHECK_INTERVAL = 1000 * 60 * 60 * 24 // 24 hours
+
+function getPackageInfo(): { name: string; version: string } {
+  const require = createRequire(import.meta.url)
+  const packageJsonPath = resolvePackageJson(import.meta.url, "update checker")
+  return require(packageJsonPath) as { name: string; version: string }
+}
+
+function readCache(): UpdateCache | null {
+  try {
+    if (!existsSync(CACHE_PATH)) {
+      debug("Cache file does not exist")
+      return null
+    }
+    const data = readFileSync(CACHE_PATH, "utf-8")
+    const cache = JSON.parse(data) as UpdateCache
+    debug("Read cache:", cache)
+    return cache
+  } catch (error) {
+    debug("Failed to read cache:", error)
+    return null
+  }
+}
+
+function writeCache(cache: UpdateCache): void {
+  try {
+    mkdirSync(CACHE_DIR, { recursive: true })
+    writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2))
+    debug("Wrote cache:", cache)
+  } catch (error) {
+    debug("Failed to write cache:", error)
+  }
+}
+
+async function fetchLatestVersion(packageName: string): Promise<string | null> {
+  try {
+    debug("Fetching latest version for:", packageName)
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(10000),
+    })
+    if (!response.ok) {
+      debug("Registry response not ok:", response.status)
+      return null
+    }
+    const data = (await response.json()) as { version: string }
+    debug("Latest version:", data.version)
+    return data.version
+  } catch (error) {
+    debug("Failed to fetch latest version:", error)
+    return null
+  }
+}
+
+function compareVersions(current: string, latest: string): boolean {
+  const currentParts = current.split(".").map(Number)
+  const latestParts = latest.split(".").map(Number)
+
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const c = currentParts[i] || 0
+    const l = latestParts[i] || 0
+    if (l > c) return true
+    if (l < c) return false
+  }
+  return false
+}
+
+/**
+ * Check for updates. Spawns background check if cache is stale.
+ * Safe to call on every CLI startup - returns immediately if cache is fresh.
+ */
+export async function check(): Promise<void> {
+  debug("check() called")
+
+  if (process.env.NO_UPDATE_NOTIFIER || process.env.CODEMACHINE_NO_UPDATE_CHECK) {
+    debug("Update check disabled by environment variable")
+    return
+  }
+
+  const cache = readCache()
+  const now = Date.now()
+
+  if (cache && now - cache.checked < CHECK_INTERVAL) {
+    debug("Cache is fresh, skipping check")
+    return
+  }
+
+  debug("Cache is stale or missing, performing check")
+
+  const pkg = getPackageInfo()
+  const latest = await fetchLatestVersion(pkg.name)
+
+  const newCache: UpdateCache = {
+    current: pkg.version,
+    latest,
+    available: latest ? compareVersions(pkg.version, latest) : false,
+    checked: now,
+  }
+
+  writeCache(newCache)
+  debug("Check complete:", newCache)
+}
+
+/**
+ * Get cached update status. Returns null if no cache exists.
+ * This is synchronous and safe to call from TUI render.
+ */
+export function status(): UpdateCache | null {
+  debug("status() called")
+  return readCache()
+}

src/shared/updates/index.ts

@@ -0,0 +1,2 @@
+export { check, status } from "./checker.js"
+export type { UpdateCache } from "./types.js"

src/shared/updates/types.ts

@@ -0,0 +1,6 @@
+export interface UpdateCache {
+  current: string
+  latest: string | null
+  available: boolean
+  checked: number
+}