forge-delegate 1.0.8 → 1.0.10

package/README.md

@@ -173,13 +173,22 @@ Every delegation tool also accepts per-call `model`, `directory`, `agent`, `auto
 ## CLI
 
 ```text
+forge-delegate --version  Print the installed version
 forge-delegate setup      Register with Claude Code / Codex / opencode
 forge-delegate serve      Start the MCP server (used internally)
 forge-delegate config     get | set | path
-forge-delegate status     Show opencode logins and usage summary
+forge-delegate status     Show version, update status, opencode logins, usage
 forge-delegate stats      Show detailed usage statistics
 ```
 
+`status` also asks npm for the newest release (cached for 24 hours in
+`~/.forge-delegate/update-check.json`) and reports it when a newer version exists. Disable the
+check with `FORGE_NO_UPDATE_CHECK=1`. `get_delegate_config` returns the same version and
+`updateAvailable` fields, so an agent can answer "is this up to date?" without a CLI call.
+
+Updating an npx install is not automatic: npx keeps using its cached copy. Clear it with
+`rm -rf ~/.npm/_npx` and restart your agent, or install globally with `npm i -g forge-delegate`.
+
 ## Publishing (npm)
 
 The primary install is `npx -y forge-delegate setup`, so the package must be on npm. Checklist:

package/cli.mjs

@@ -5,7 +5,7 @@ import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { execSync } from "node:child_process";
-import { loadConfig, saveConfig, configPath, detectOpencode, loadOpencodeAuth } from "./lib.mjs";
+import { loadConfig, saveConfig, configPath, detectOpencode, loadOpencodeAuth, checkForUpdate, VERSION } from "./lib.mjs";
 
 const here = dirname(fileURLToPath(import.meta.url));
 
@@ -210,9 +210,17 @@ function configCmd(argv) {
 }
 
 async function status() {
+  const update = await checkForUpdate();
   const oc = await detectOpencode();
+  let versionNote;
+  if (update.disabled) versionNote = "  (update check disabled)";
+  else if (update.updateAvailable) versionNote = `  \u2192 ${update.latest} available`;
+  else if (update.error && !update.latest) versionNote = "  (update check unavailable)";
+  else if (update.error) versionNote = `  (latest known: ${update.latest}; check failed)`;
+  else versionNote = "  (up to date)";
+  console.log(`\nforge-delegate: ${VERSION}${versionNote}`);
   console.log(
-    `\nopencode: ${oc.found ? (oc.version?.raw ?? "unknown version") : "not found on PATH"}` +
+    `opencode: ${oc.found ? (oc.version?.raw ?? "unknown version") : "not found on PATH"}` +
       `${oc.found && !oc.supported ? "  (too old — requires v2 or newer)" : ""}`
   );
   let providers = [];
@@ -227,6 +235,11 @@ async function status() {
       console.log(`recorded delegations: ${lines} (see 'forge-delegate stats')`);
     }
   } catch {}
+  if (update.updateAvailable) {
+    console.log(`\nUpdate to ${update.latest}:`);
+    console.log("  npx install:  rm -rf ~/.npm/_npx   (then restart your agent)");
+    console.log("  global:       npm i -g forge-delegate");
+  }
 }
 
 function stats() {
@@ -268,6 +281,7 @@ function help() {
 forge-delegate — delegate coding work from Claude Code/Codex/opencode to other AI models
 
 Usage:
+  forge-delegate --version                     Print the installed version
   forge-delegate setup [--model provider/model] [--targets claude,codex,opencode]
                        [--scope user|project] [--project-dir <path>] [--no-skill]
                                              Interactive setup; flags optional (run bare to be prompted)
@@ -277,7 +291,7 @@ Usage:
   forge-delegate config set --model <m> [--agent <a>] [--variant <v>]
                           [--timeout <s>] [--dir <path>] [--autoApprove true|false]
   forge-delegate config path                  Print config file path
-  forge-delegate status                       Show opencode logins and usage summary
+  forge-delegate status                       Show version, update status, opencode logins, usage
   forge-delegate stats                        Show detailed usage statistics
 
 Models come from your opencode installation:
@@ -287,7 +301,8 @@ Models come from your opencode installation:
 }
 
 const cmd = process.argv[2] ?? "help";
-if (cmd === "setup") await setup();
+if (cmd === "--version" || cmd === "-v" || cmd === "version") console.log(VERSION);
+else if (cmd === "setup") await setup();
 else if (cmd === "serve") await import("./server.mjs");
 else if (cmd === "config") configCmd(process.argv.slice(3));
 else if (cmd === "status") await status();

package/lib.mjs

@@ -1,7 +1,11 @@
 import { execFile, spawn } from "node:child_process";
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+export const VERSION = JSON.parse(readFileSync(join(here, "package.json"), "utf8")).version;
 
 export const OPENCODE_TIMEOUT = Number(process.env.FORGE_OPENCODE_TIMEOUT ?? 900_000);
 
@@ -25,13 +29,103 @@ export function detectOpencode() {
   });
 }
 
+// The startup warning on stderr is easy for an MCP client to swallow, and a v1
+// binary does not fail loudly: `run` reads the v2 flags as a help request and
+// exits 0. Check once per process, then refuse to spawn instead of returning
+// "(no output)" and letting it look like the model had nothing to say.
+let opencodeGate;
+function requireOpencodeV2() {
+  opencodeGate ??= detectOpencode();
+  return opencodeGate.then((oc) => {
+    if (!oc.found)
+      throw new Error("opencode not found on PATH — install it from https://opencode.ai");
+    if (!oc.supported)
+      throw new Error(
+        `opencode ${oc.version?.raw ?? "(unknown version)"} is too old — forge-delegate requires opencode 2 or newer ` +
+          `(v2 removed the CLI flags it uses). Run: opencode upgrade`
+      );
+    return oc;
+  });
+}
+
 const CONFIG_DIR = join(homedir(), ".forge-delegate");
 const AUTH_PATH = join(homedir(), ".local/share/opencode/auth.json");
 const OPENCODE_CONFIG_PATH = join(homedir(), ".config/opencode/opencode.json");
 const CATALOG_CACHE = join(CONFIG_DIR, "models-dev.json");
 const CATALOG_TTL = 24 * 3600 * 1000;
+const UPDATE_CACHE = join(CONFIG_DIR, "update-check.json");
+const UPDATE_TTL = 24 * 3600 * 1000;
 const OLLAMA_BASE = process.env.OLLAMA_URL ?? "http://localhost:11434";
 
+function parseVersion(v) {
+  const m = String(v ?? "").match(/^(\d+)\.(\d+)\.(\d+)/);
+  return m ? [+m[1], +m[2], +m[3]] : null;
+}
+
+export function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) return 0;
+  for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pa[i] - pb[i];
+  return 0;
+}
+
+function readUpdateCache() {
+  try {
+    const cached = JSON.parse(readFileSync(UPDATE_CACHE, "utf8"));
+    if (cached?.latest && Number.isFinite(cached.checkedAt)) return cached;
+  } catch {}
+  return null;
+}
+
+// An installed copy cannot see the registry on its own, and npx happily reuses a
+// cached install forever — which is how this server ran 1.0.7 while 1.0.9 was
+// published. Check once a day, cache the answer, and never let a network failure
+// break the caller. Opt out with FORGE_NO_UPDATE_CHECK=1 (or NO_UPDATE_NOTIFIER=1).
+export async function checkForUpdate({ force = false, timeoutMs = 3000 } = {}) {
+  const cached = readUpdateCache();
+  if (!force && cached && Date.now() - cached.checkedAt < UPDATE_TTL) {
+    return {
+      current: VERSION,
+      latest: cached.latest,
+      updateAvailable: compareVersions(cached.latest, VERSION) > 0,
+      checkedAt: cached.checkedAt,
+    };
+  }
+
+  if (process.env.FORGE_NO_UPDATE_CHECK || process.env.NO_UPDATE_NOTIFIER) {
+    return { current: VERSION, latest: null, updateAvailable: false, checkedAt: null, disabled: true };
+  }
+
+  try {
+    const res = await fetch("https://registry.npmjs.org/forge-delegate/latest", {
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) throw new Error(`registry returned ${res.status}`);
+    const { version } = await res.json();
+    if (!parseVersion(version)) throw new Error("registry returned no version");
+    const checkedAt = Date.now();
+    try {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(UPDATE_CACHE, JSON.stringify({ latest: version, checkedAt }));
+    } catch {}
+    return {
+      current: VERSION,
+      latest: version,
+      updateAvailable: compareVersions(version, VERSION) > 0,
+      checkedAt,
+    };
+  } catch (e) {
+    return {
+      current: VERSION,
+      latest: cached?.latest ?? null,
+      updateAvailable: cached ? compareVersions(cached.latest, VERSION) > 0 : false,
+      checkedAt: cached?.checkedAt ?? null,
+      error: e.message,
+    };
+  }
+}
+
 function execFileText(cmd, args, opts = {}) {
   return new Promise((resolve, reject) => {
     execFile(cmd, args, { timeout: 15_000, maxBuffer: 4 * 1024 * 1024, ...opts }, (err, stdout) => {
@@ -191,6 +285,7 @@ export function parseEvents(stdout) {
 }
 
 export async function opencodeRun(model, prompt, opts = {}) {
+  await requireOpencodeV2();
   const started = Date.now();
   const variant = opts.variant ?? (await pickVariant(model));
   const timeoutMs = opts.timeoutMs ?? OPENCODE_TIMEOUT;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-delegate",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "MCP server that relays coding work to other AI models (DeepSeek, Gemini, OpenAI, Ollama) so Claude Code saves tokens",
   "type": "module",
   "bin": {

package/server.mjs

@@ -21,16 +21,17 @@ import {
   saveConfig,
   configPath,
   resolveConfig,
+  checkForUpdate,
+  VERSION,
 } from "./lib.mjs";
 
 const execFileAsync = promisify(execFile);
 const RUNS_DIR = join(homedir(), ".forge-delegate", "runs");
 const here = dirname(fileURLToPath(import.meta.url));
-const VERSION = JSON.parse(readFileSync(join(here, "package.json"), "utf8")).version;
 
-// The server auto-updates (npx re-resolves latest on each spawn) but the installed
-// skill is a file on disk that only `setup` rewrites — so a published skill change
-// goes unnoticed. Compare the two and say so, rather than running stale in silence.
+// The installed skill is a file on disk that only `setup` rewrites, so a published
+// skill change goes unnoticed. Compare the two and say so, rather than running
+// stale in silence.
 function skillStatus() {
   const src = join(here, "skills", "delegate-work", "SKILL.md");
   if (!existsSync(src)) return null;
@@ -286,15 +287,30 @@ server.tool(
 
 server.tool(
   "get_delegate_config",
-  "Read the current forge-delegate configuration: defaultModel, defaultAgent, defaultVariant, autoApprove, timeoutMs, defaultDirectory, and named profiles. Call this to see what will be used when a model/directory is omitted.",
+  "Read the current forge-delegate configuration: defaultModel, defaultAgent, defaultVariant, autoApprove, timeoutMs, defaultDirectory, and named profiles — plus the installed version and whether a newer release is published. Call this to see what will be used when a model/directory is omitted, or when the user asks whether forge-delegate is up to date.",
   {},
   async () => {
     const cfg = loadConfig();
+    const update = await checkForUpdate();
     const { profiles, ...rest } = cfg;
     const lines = Object.entries(rest).map(([k, v]) => `  ${k}: ${v ?? "(unset)"}`);
     const prof = Object.entries(profiles).map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`).join("\n") || "  (none)";
     const skill = SKILL_STATUS ? `\nskill (delegate-work): ${SKILL_STATUS.detail}${SKILL_STATUS.state === "ok" ? "" : " — run: npx -y forge-delegate setup"}` : "";
-    return { content: [{ type: "text", text: `config: ${configPath()}\n${lines.join("\n")}\nprofiles:\n${prof}${skill}` }] };
+    const updateLine = update.disabled
+      ? "updateAvailable: unknown (check disabled)"
+      : update.error && !update.latest
+        ? `updateAvailable: unknown (${update.error})`
+        : update.updateAvailable
+          ? `updateAvailable: true (latest ${update.latest}, running ${VERSION})`
+          : "updateAvailable: false";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `version: ${VERSION}\n${updateLine}\nconfig: ${configPath()}\n${lines.join("\n")}\nprofiles:\n${prof}${skill}`,
+        },
+      ],
+    };
   }
 );
 
@@ -323,3 +339,7 @@ server.tool(
 
 const transport = new StdioServerTransport();
 await server.connect(transport);
+
+// Warm the update cache after the handshake — a registry call must never delay
+// the MCP connection. get_delegate_config reads whatever this leaves behind.
+checkForUpdate().catch(() => {});