commandmate 0.29.1 → 0.29.2

package/dist/server/src/lib/updates/agent-updater.js

@@ -0,0 +1,373 @@
+"use strict";
+/**
+ * Running an agent CLI's own updater, in a process that is not an agent pane
+ * (Issue #2069).
+ *
+ * ## The failure this replaces
+ *
+ * codex's "Update now" is not an in-place upgrade. Measured against upstream
+ * `codex-rs/cli/src/main.rs`: the codex process **exits**, its parent runs the
+ * install in the foreground, prints `Update ran successfully! Please restart
+ * Codex.` and stops. Nothing restarts codex. Run inside a CommandMate pane that
+ * means the pane's foreground program is gone and the pane falls back to a bare
+ * shell — the state #2070 taught the detector to recognise, and which the user
+ * then has to clean up by hand.
+ *
+ * So the update runs **here**: a child of the server (or of the CLI), with its
+ * own stdio, wholly outside tmux. A pane that is mid-turn keeps its session; the
+ * binary underneath it changes, and restarting that pane is a separate,
+ * explicit act (the restart button, or `kill-session`).
+ *
+ * `tests/unit/api/agents-update-2069.test.ts` holds that structurally: it fails
+ * the moment this route's module graph reaches tmux or a CLI tool's session
+ * API at all. "Not in the pane" is the Issue's central claim, so it is asserted
+ * rather than asserted-in-a-comment.
+ *
+ * ## The OTHER update path, and why it does not make this one redundant (#2068)
+ *
+ * codex's dialog can still appear inside a pane — a codex the user updated by
+ * hand, an `Update now` they pressed themselves — and #2068 owns what
+ * CommandMate answers there and how the pane is repaired afterwards (it re-sends
+ * the launch command to the same pane). The two are complements, not
+ * duplicates:
+ *
+ *  - the pane path is **reactive**: it only exists because codex asked, and it
+ *    costs the session (the pane drops to a shell and has to be restarted);
+ *  - this path is **initiated by the user from CommandMate** and costs no
+ *    session at all.
+ *
+ * The consequence for THIS module is the lock below: after #2068 there are
+ * three ways to reach one `npm install -g @openai/codex`, and only a lock that
+ * every one of them takes is a lock.
+ *
+ * ## Two strategies, and how the choice is made
+ *
+ * codex 0.149.0 added a `codex update` subcommand that works out how the binary
+ * was installed (npm, Homebrew, the standalone installer) and updates it the
+ * same way. That is strictly better than assuming npm, so it is preferred — but
+ * only when the installed build actually has it. A `codex update` typed at
+ * 0.148 is an unknown-subcommand error, so below
+ * {@link CODEX_NATIVE_UPDATE_MIN_VERSION} the plan falls back to
+ * `npm install -g @openai/codex@latest`, which is what codex's own pre-0.149
+ * updater ran.
+ *
+ * ### Why the fallback pins `@latest` and codex's own command does not
+ *
+ * codex spells it `npm install -g @openai/codex`. That resolves through npm's
+ * default dist-tag, which is `latest` **unless** the user has set one
+ * (`npm config set tag`, or a `tag=` line in `.npmrc`) — in which case the two
+ * spellings install different versions. The explicit `@latest` here is the
+ * fixed-argv rule applied to the version as well as to the words: what this
+ * module runs must not depend on a config value neither CommandMate nor the
+ * user is looking at while pressing the button. On a machine with no such
+ * setting — which is nearly all of them — the two commands are identical.
+ *
+ * ## The execution rules (this Issue's 実装内容 4, and DR4-010)
+ *
+ * - **`execFile` with an argv array, never a shell string.** There is no
+ *   `sh -c`, no interpolation, and nothing derived from an HTTP request reaches
+ *   the command: the tool id is validated against {@link UPDATABLE_AGENT_TOOLS}
+ *   and then *discarded* — the argv is a literal in this file, selected by that
+ *   id. Same shape as `/api/app/update`'s fixed argv (#1198 §5).
+ * - **The command is resolved to an absolute path first**, through
+ *   {@link resolveAbsoluteExecutable}, and the plan fails rather than handing a
+ *   relative or bare name to `execFile`. A repo-local `node_modules/.bin/codex`
+ *   on `PATH` must not be able to decide what "update codex" runs.
+ *
+ *   `findExecutableOnPath` alone is **not** enough for that, which is why this
+ *   module wraps it: it joins each `PATH` entry with the name and returns the
+ *   first hit, so a `PATH` carrying a RELATIVE entry (`PATH=.:/usr/bin`, a
+ *   `node_modules/.bin` written without a leading slash) yields a relative
+ *   command — `./codex` — and `execFile` would resolve that against the child's
+ *   cwd. The `isAbsolute` check is the half that makes the sentence above true.
+ * - **`PATH` still comes from the shell that started the server**, because that
+ *   is the PATH the user's codex is actually on; the environment is passed
+ *   through {@link sanitizeEnvForChildProcess} so the updater cannot read
+ *   CommandMate's auth token, DB path, or the launching agent's correlation
+ *   variables (#1996).
+ *
+ * @module lib/updates/agent-updater
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_UPDATE_MAX_BUFFER_BYTES = exports.AGENT_UPDATE_TIMEOUT_MS = exports.CODEX_NATIVE_UPDATE_MIN_VERSION = exports.CODEX_NPM_PACKAGE = exports.UPDATABLE_AGENT_TOOLS = void 0;
+exports.isUpdatableAgentTool = isUpdatableAgentTool;
+exports.resolveAgentUpdatePlan = resolveAgentUpdatePlan;
+exports.acquireAgentUpdateLock = acquireAgentUpdateLock;
+exports.releaseAgentUpdateLock = releaseAgentUpdateLock;
+exports.isAgentUpdateInProgress = isAgentUpdateInProgress;
+exports.runAgentUpdate = runAgentUpdate;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const copilot_executable_1 = require("../cli-tools/copilot-executable");
+const env_sanitizer_1 = require("../security/env-sanitizer");
+const version_probes_1 = require("../detection/version-probes");
+/**
+ * Tools this module can update.
+ *
+ * One entry today, and the array — rather than an `if (tool === 'codex')` — is
+ * the point: it is the allow-list the route validates against, so adding a tool
+ * is adding a row here plus its plan below, and never a new place where a
+ * request string reaches a command.
+ */
+exports.UPDATABLE_AGENT_TOOLS = ['codex'];
+/** Narrow arbitrary input — a request body, an argv operand — to a known tool. */
+function isUpdatableAgentTool(value) {
+    return typeof value === 'string' && exports.UPDATABLE_AGENT_TOOLS.includes(value);
+}
+/** The package `npm install -g` would fetch when codex cannot update itself. */
+exports.CODEX_NPM_PACKAGE = '@openai/codex';
+/**
+ * First codex release with a `codex update` subcommand.
+ *
+ * Below this the subcommand does not exist and invoking it is an error, so the
+ * plan takes the npm route instead. Measured on 0.149.1, whose `codex update
+ * --help` reads "Update Codex to the latest version".
+ */
+exports.CODEX_NATIVE_UPDATE_MIN_VERSION = '0.149.0';
+/**
+ * How long one update may run.
+ *
+ * An install pulls a release over the network, so this is minutes rather than
+ * the five seconds a `--version` probe gets. It is a ceiling on a hang, not a
+ * budget: the ordinary run finishes far inside it.
+ */
+exports.AGENT_UPDATE_TIMEOUT_MS = 10 * 60 * 1000;
+/** Cap on captured output. npm is chatty; a runaway installer is not parsed. */
+exports.AGENT_UPDATE_MAX_BUFFER_BYTES = 4 * 1024 * 1024;
+/** Default probe: the same `codex --version` row the detector's table uses. */
+async function probeCodexVersion() {
+    return (0, version_probes_1.runDetectorVersionProbe)({ kind: 'execFile', command: 'codex', args: ['--version'] });
+}
+/**
+ * Resolve `name` on `PATH` to an **absolute** path, or null.
+ *
+ * The `isAbsolute` half is not belt-and-braces. `findExecutableOnPath` splits
+ * `PATH` and returns `join(entry, name)` for the first entry that holds an
+ * executable file; a relative `PATH` entry therefore yields a relative command,
+ * which `execFile` resolves against the child's cwd rather than against
+ * anything this process decided. A `PATH` of `.:/usr/local/bin` in the shell
+ * that started the server would let whichever directory the child happens to
+ * run in supply the binary that "update codex" executes.
+ *
+ * Refusing is the right failure: the caller reports "there is nothing to update
+ * with" and nothing is spawned, which is the same answer a machine with no
+ * codex and no npm gets.
+ *
+ * @param name - Executable name to look up, e.g. `codex`.
+ * @param resolveExecutable - Injected lookup (tests); defaults to PATH.
+ * @returns An absolute path, or null when it is missing OR not absolute.
+ */
+function resolveAbsoluteExecutable(name, resolveExecutable) {
+    const resolved = resolveExecutable(name);
+    if (!resolved)
+        return null;
+    return (0, path_1.isAbsolute)(resolved) ? resolved : null;
+}
+/**
+ * Decide what "update codex" runs on THIS machine, without running anything.
+ *
+ * Separated from {@link runAgentUpdate} so both the API route and the CLI can
+ * show the user the exact argv before it executes, and so a test can assert the
+ * strategy choice without a child process.
+ *
+ * @param tool - Tool id, validated here rather than trusted.
+ * @param deps - Injection seams; production defaults read the real machine.
+ */
+async function resolveAgentUpdatePlan(tool, deps = {}) {
+    if (!isUpdatableAgentTool(tool)) {
+        return {
+            ok: false,
+            code: 'unsupported-tool',
+            message: `No update flow for '${String(tool)}'. Updatable tools: ${exports.UPDATABLE_AGENT_TOOLS.join(', ')}.`,
+        };
+    }
+    const resolveExecutable = deps.resolveExecutable ?? copilot_executable_1.findExecutableOnPath;
+    const probeVersion = deps.probeInstalledVersion ?? probeCodexVersion;
+    const codexPath = resolveAbsoluteExecutable('codex', resolveExecutable);
+    const installed = codexPath ? await probeVersion(tool) : null;
+    // The native subcommand needs both: an executable to run it, and a build old
+    // enough that `update` is not a typo to it.
+    if (codexPath &&
+        installed !== null &&
+        (0, version_probes_1.compareCliVersions)(installed, exports.CODEX_NATIVE_UPDATE_MIN_VERSION) >= 0) {
+        return {
+            ok: true,
+            plan: {
+                tool,
+                strategy: 'native',
+                command: codexPath,
+                args: ['update'],
+                display: 'codex update',
+                installed,
+                reason: 'native-subcommand',
+            },
+        };
+    }
+    const npmPath = resolveAbsoluteExecutable('npm', resolveExecutable);
+    if (!npmPath) {
+        return {
+            ok: false,
+            code: 'no-executable',
+            message: codexPath === null
+                ? 'Neither codex nor npm resolves to an absolute path on PATH, so there is nothing to update with.'
+                : 'This codex is too old for `codex update`, and npm does not resolve to an absolute path on PATH.',
+        };
+    }
+    return {
+        ok: true,
+        plan: {
+            tool,
+            strategy: 'npm',
+            command: npmPath,
+            args: ['install', '-g', `${exports.CODEX_NPM_PACKAGE}@latest`],
+            display: `npm install -g ${exports.CODEX_NPM_PACKAGE}@latest`,
+            installed,
+            reason: codexPath === null ? 'not-installed' : 'no-native-subcommand',
+        },
+    };
+}
+/**
+ * Tools whose update is running in THIS process.
+ *
+ * ## What it guards, now that there are three ways in
+ *
+ * After #2068 there are three routes to one `npm install -g @openai/codex` on
+ * one machine, and only the first two are this process's:
+ *
+ *  1. `POST /api/agents/update` — the More screen's and the agent pane's button;
+ *  2. `commandmate agents update <tool>` — the CLI, which may be a SECOND
+ *     process (a terminal beside a running server);
+ *  3. codex's own in-pane `Update now`, which #2068 answers according to
+ *     `CM_CODEX_UPDATE_DIALOG`.
+ *
+ * The lock is taken inside {@link runAgentUpdate} rather than by each caller,
+ * so (1) and (2) are covered by construction and a fourth caller is covered by
+ * calling the function. #2068 wires (3) by taking
+ * {@link acquireAgentUpdateLock} itself — which is why these three functions
+ * stay exported from `lib/updates` even though nothing inside this module needs
+ * them to be.
+ *
+ * ## Why in-process rather than a lock file
+ *
+ * Two npm installs of the same global package racing each other is a
+ * double-click, not a second machine, and (2) crossing process boundaries is a
+ * real gap this deliberately does not close: a cross-process lock would also
+ * have to be reconciled with the user running `codex update` in their own
+ * terminal, which is legitimate and must not be blocked, and there is no way to
+ * tell those two apart from the outside. npm's own global install is the last
+ * line either way.
+ */
+const updatesInFlight = new Set();
+/**
+ * Take the in-flight marker for `tool`, or report that one is already held.
+ *
+ * Callers that run the update do NOT need this — {@link runAgentUpdate} takes
+ * it. It is exported for the one caller that cannot go through that function:
+ * #2068's in-pane update path, where codex itself is the thing running the
+ * install and CommandMate only answers a dialog.
+ */
+function acquireAgentUpdateLock(tool) {
+    if (updatesInFlight.has(tool))
+        return false;
+    updatesInFlight.add(tool);
+    return true;
+}
+/** Release the marker. Safe to call when none is held. */
+function releaseAgentUpdateLock(tool) {
+    updatesInFlight.delete(tool);
+}
+/**
+ * Whether an update for `tool` is running in this process.
+ *
+ * A pre-check, never the control: the authoritative acquisition is inside
+ * {@link runAgentUpdate}. The route reads this to choose its status code
+ * BEFORE it starts streaming, because once a 200 and a stream have been
+ * returned there is no way to answer 409 any more.
+ */
+function isAgentUpdateInProgress(tool) {
+    return updatesInFlight.has(tool);
+}
+/**
+ * Run a resolved plan, streaming its output.
+ *
+ * `execFile` — not `exec`, not `spawn` with `shell: true` — so the argv array is
+ * handed to the OS as an array. Its returned `ChildProcess` still exposes
+ * `stdout` / `stderr` as streams, which is what makes "argv array" and "stream
+ * the output" the same choice rather than a trade: the callback's buffered copy
+ * is ignored and the listeners below are the real output path.
+ *
+ * **Takes the in-flight lock itself**, synchronously, before it returns its
+ * promise — so every caller is serialised by calling this function rather than
+ * by remembering to. See {@link acquireAgentUpdateLock} for the three paths
+ * that reach one global install and why one of them cannot use this door.
+ *
+ * Never rejects. An updater that fails is a result to render, not an exception
+ * to unwind through a route handler; a refusal (`code: 'in_progress'`) is a
+ * result too, and spawns nothing.
+ *
+ * @param plan - From {@link resolveAgentUpdatePlan}. Its argv is used verbatim.
+ * @param options - Streaming callback and timeout.
+ */
+function runAgentUpdate(plan, options = {}) {
+    const { onChunk } = options;
+    const timeout = options.timeoutMs ?? exports.AGENT_UPDATE_TIMEOUT_MS;
+    // Synchronous, and before the promise is constructed: a caller that checked
+    // `isAgentUpdateInProgress` and then called this has no interleaving point in
+    // between, so the pre-check and the acquisition cannot disagree.
+    if (!acquireAgentUpdateLock(plan.tool)) {
+        return Promise.resolve({
+            ok: false,
+            exitCode: null,
+            signal: null,
+            code: 'in_progress',
+            error: `An update for ${plan.tool} is already running.`,
+        });
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            releaseAgentUpdateLock(plan.tool);
+            resolve(result);
+        };
+        let child;
+        try {
+            child = (0, child_process_1.execFile)(plan.command, [...plan.args], {
+                timeout,
+                maxBuffer: exports.AGENT_UPDATE_MAX_BUFFER_BYTES,
+                env: (0, env_sanitizer_1.sanitizeEnvForChildProcess)(),
+            }, (error) => {
+                if (!error) {
+                    settle({ ok: true, exitCode: 0, signal: null });
+                    return;
+                }
+                const failure = error;
+                settle({
+                    ok: false,
+                    exitCode: typeof failure.code === 'number' ? failure.code : null,
+                    signal: failure.signal ?? null,
+                    error: failure.message,
+                });
+            });
+        }
+        catch (error) {
+            // execFile throws synchronously only for a malformed invocation; a
+            // missing binary arrives through the callback as ENOENT.
+            settle({
+                ok: false,
+                exitCode: null,
+                signal: null,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
+        if (onChunk) {
+            child.stdout?.setEncoding('utf-8');
+            child.stderr?.setEncoding('utf-8');
+            child.stdout?.on('data', (text) => onChunk({ stream: 'stdout', text }));
+            child.stderr?.on('data', (text) => onChunk({ stream: 'stderr', text }));
+        }
+    });
+}

package/dist/server/src/lib/updates/agent-versions.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * "Which agent CLIs are installed, and is codex behind?" (Issue #2069)
+ *
+ * One row per tool for the two update surfaces — the More screen's card and the
+ * agent pane's — and the split in what a row carries is deliberate:
+ *
+ *  - **every tool reports `installed` only.** That is this Issue's 実装内容 2:
+ *    the probe table already exists, it answers without a network, and
+ *    "installed 1.0.80" is the whole truth CommandMate has about a copilot.
+ *  - **codex additionally reports `latestVersion` / `updateAvailable`**, because
+ *    codex is the one tool that writes its own release check to disk. See
+ *    `./codex-version`.
+ *
+ * Nothing here queries a registry. A row that says `updateAvailable: false` is
+ * saying "nothing on this machine claims otherwise", never "I checked online".
+ *
+ * ## Why not `getDetectorFreshness()`
+ *
+ * It answers a different question (are the *detector's rules* stale?) and — the
+ * reason that matters here — it caches for the life of the process. This module
+ * is read immediately after an update completes, so a permanent memo would show
+ * the old version forever and make the acceptance criterion 「完了後に
+ * `codex --version` が上がる」 unobservable from the UI. So the probes are run
+ * through the same `runDetectorVersionProbe` (same absolute-path resolution,
+ * same sanitized env, same timeout) behind a **TTL** instead, on the reasoning
+ * `config/installed-agents-cache` already wrote down: the user's loop is
+ * "install something, come back, look again".
+ *
+ * @module lib/updates/agent-versions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_VERSIONS_CACHE_TTL_MS = void 0;
+exports.getAgentVersions = getAgentVersions;
+exports.clearAgentVersionsCache = clearAgentVersionsCache;
+const version_probes_1 = require("../detection/version-probes");
+const codex_version_1 = require("./codex-version");
+const agent_updater_1 = require("./agent-updater");
+/**
+ * How long one fan-out of `--version` probes is reused.
+ *
+ * Same 30s as `config/installed-agents-cache`, and for the same reason: opening
+ * a screen twice in a row costs one fan-out, while a version that changed under
+ * the server shows up without a restart. An update finishing calls
+ * {@link clearAgentVersionsCache} rather than waiting this out.
+ */
+exports.AGENT_VERSIONS_CACHE_TTL_MS = 30_000;
+let cache = null;
+let inFlight = null;
+/** Probe one tool and build its row. codex gets the extra half. */
+async function buildRow(tool) {
+    const installed = await (0, version_probes_1.runDetectorVersionProbe)(version_probes_1.DETECTOR_VERSION_PROBES[tool]);
+    const updatable = (0, agent_updater_1.isUpdatableAgentTool)(tool);
+    if (tool !== 'codex') {
+        return {
+            tool,
+            installed,
+            latestVersion: null,
+            dismissedVersion: null,
+            updateAvailable: false,
+            dismissedInCodex: false,
+            updatable,
+            source: null,
+        };
+    }
+    const status = (0, codex_version_1.evaluateCodexUpdate)(installed, (0, codex_version_1.readCodexVersionFile)());
+    return {
+        tool,
+        installed: status.installed,
+        latestVersion: status.latestVersion,
+        dismissedVersion: status.dismissedVersion,
+        updateAvailable: status.updateAvailable,
+        dismissedInCodex: status.dismissedInCodex,
+        updatable,
+        source: status.source,
+    };
+}
+async function computeRows() {
+    const tools = Object.keys(version_probes_1.DETECTOR_VERSION_PROBES).sort();
+    return Promise.all(tools.map(buildRow));
+}
+/**
+ * When a fan-out started at `startedAt` should stop being reused.
+ *
+ * Takes the caller's clock rather than reading `Date.now()` again, and that is
+ * the whole point of the helper: an injected `now` that is honoured on the READ
+ * side but ignored on the WRITE side makes every TTL assertion vacuous — the
+ * cache is stamped with a real epoch, a test's `now: 2_000` is smaller than it
+ * whatever the TTL is, and `AGENT_VERSIONS_CACHE_TTL_MS = 0` still passes.
+ */
+function expiryFrom(startedAt) {
+    return startedAt + exports.AGENT_VERSIONS_CACHE_TTL_MS;
+}
+/**
+ * Every tool's version row, cached for {@link AGENT_VERSIONS_CACHE_TTL_MS}.
+ *
+ * Single-flight: two concurrent callers share one fan-out rather than doubling
+ * the child processes.
+ *
+ * @param options.force - Skip the cache and re-probe. What the UI passes right
+ *   after an update, so the new version is visible without a 30s wait.
+ * @param options.now - Injectable clock, used for BOTH the expiry comparison
+ *   and the expiry that is written. Honouring it on only one side would leave
+ *   the TTL untestable — see {@link expiryFrom}.
+ */
+async function getAgentVersions(options = {}) {
+    const now = options.now ?? Date.now();
+    if (options.force) {
+        cache = null;
+    }
+    else if (cache && cache.expiresAt > now) {
+        return cache.rows;
+    }
+    if (inFlight)
+        return inFlight;
+    inFlight = (async () => {
+        try {
+            const rows = await computeRows();
+            cache = { rows, expiresAt: expiryFrom(now) };
+            return rows;
+        }
+        catch {
+            // A probe fan-out that throws must not fail the surface that asked: the
+            // versions are an annotation, and an empty list renders as "unknown".
+            cache = { rows: [], expiresAt: expiryFrom(now) };
+            return [];
+        }
+        finally {
+            inFlight = null;
+        }
+    })();
+    return inFlight;
+}
+/** Drop the cached probe. Tests, and every surface that just ran an update. */
+function clearAgentVersionsCache() {
+    cache = null;
+    inFlight = null;
+}