@indigoai-us/hq-cli 5.167.0 → 5.169.0

package/dist/lib/daemon/install.js

@@ -21,10 +21,22 @@ import { activateLaunchd, deactivateLaunchd, launchdPlistPath, renderLaunchdPlis
 import { activateSystemd, deactivateSystemd, renderSystemdUserUnit, systemdUnitPath, } from "../service-manager/systemd.js";
 import { escapeXml, shellQuote } from "../service-manager/types.js";
 import { readPidLock } from "../mesh/live/daemon/pid-lock.js";
+import { userToolDirs } from "./tools.js";
 export const DAEMON_LAUNCHD_LABEL = "ai.getindigo.hq-daemon";
 export const DAEMON_SYSTEMD_UNIT = "hq-daemon.service";
 export const DAEMON_WINDOWS_TASK = "ai.getindigo.hq-daemon";
 export const SYSTEM_UNIT_DIR = "/etc/systemd/system";
+export const ROOT_REFUSAL = "hq daemon runs its services as the machine's login user, never as root.";
+/**
+ * Why the daemon must not run here as root, or null when it may. Agent kits
+ * are the one exception: they run in containers where root is often the only
+ * account.
+ */
+export function daemonRootRefusal(isRoot, machineType) {
+    if (!isRoot || machineType === "agent-kit")
+        return null;
+    return `${ROOT_REFUSAL} Run it as that user instead of root.`;
+}
 /** Boxes run the daemon as a system unit; everything else per user. */
 export function installScopeFor(machineType) {
     return machineType === "outpost" || machineType === "agent-box" ? "system" : "user";
@@ -55,7 +67,9 @@ function renderSystemdSystemUnit(host, user, userHome) {
     const env = {
         ...host.env,
         HOME: userHome,
-        PATH: host.env?.PATH ?? "/usr/local/bin:/usr/bin:/bin",
+        // The login user's own tools come first, so the daemon runs (and can
+        // update) their Claude, Codex and Grok rather than root's copies in /usr.
+        PATH: [...userToolDirs(userHome), host.env?.PATH ?? "/usr/local/bin:/usr/bin:/bin"].join(":"),
     };
     const envLines = Object.entries(env)
         .sort(([a], [b]) => a.localeCompare(b))
@@ -163,8 +177,10 @@ export function planDaemonUnit(host, options) {
     if (host.platform === "linux") {
         if (options.scope === "system") {
             if (!options.runAsUser) {
-                throw new Error("A system install needs the box's login user. Provisioning writes it to /etc/hq/machine-type (user=<name>).");
+                throw new Error("A system install needs the box's login user: pass --user <name>, or provisioning writes it to /etc/hq/machine-type (user=<name>).");
             }
+            if (options.runAsUser === "root")
+                throw new Error(ROOT_REFUSAL);
             if (!options.runAsHome)
                 throw new Error(`Could not find the home directory of ${options.runAsUser}.`);
             return {

package/dist/lib/daemon/legacy.js

@@ -19,9 +19,14 @@ const SYSTEM_UNITS = [
     ["hq-agent-inbox.service", "inbox"],
     ["hq-agent-qmd-index.timer", "search-index"],
     ["outpost-jobs-reconcile.timer", "jobs-reconcile"],
+    // The runners' watchdogs restart the old runners, so they are taken over with them.
     ["outpost-runner.service", "remote-control"],
-    ["outpost-codex-runner.service", "remote-control"],
+    ["outpost-runner-watchdog.timer", "remote-control"],
+    ["outpost-rc-watchdog.timer", "remote-control"],
+    ["outpost-codex-runner.service", "codex-remote-control"],
+    ["outpost-codex-watchdog.timer", "codex-remote-control"],
     ["hq-cli-update.timer", "updater"],
+    ["outpost-codex-update.timer", "updater"],
 ];
 const KIND_LABEL = {
     launchd: "LaunchAgent",

package/dist/lib/daemon/machine-type.d.ts

@@ -6,6 +6,7 @@
  *   1. `--machine-type` flag
  *   2. the type saved in ~/.hq/daemon/config.json by an earlier install
  *   3. /etc/hq/machine-type, written by box provisioning (may name a login user)
+ *   3b. an outpost runner unit (outposts provisioned before the marker)
  *   4. agent-kit machine credentials present → agent-kit
  *   5. running in a container → agent-kit
  *   6. macOS or Windows → desktop
@@ -14,7 +15,9 @@
 export declare const MACHINE_TYPES: readonly ["desktop", "self-hosted", "outpost", "agent-box", "agent-kit"];
 export type MachineType = (typeof MACHINE_TYPES)[number];
 export declare const MACHINE_TYPE_MARKER_PATH = "/etc/hq/machine-type";
-export type MachineTypeSource = "flag" | "config" | "marker" | "agent-kit-creds" | "container" | "platform";
+export type MachineTypeSource = "flag" | "config" | "marker" | "outpost-units" | "agent-kit-creds" | "container" | "platform";
+/** The Claude runner unit outpost provisioning installs; its `User=` is the box's login user. */
+export declare const OUTPOST_RUNNER_UNIT = "/etc/systemd/system/outpost-runner.service";
 export interface MachineTypeResult {
     type: MachineType;
     source: MachineTypeSource;

package/dist/lib/daemon/machine-type.js

@@ -6,6 +6,7 @@
  *   1. `--machine-type` flag
  *   2. the type saved in ~/.hq/daemon/config.json by an earlier install
  *   3. /etc/hq/machine-type, written by box provisioning (may name a login user)
+ *   3b. an outpost runner unit (outposts provisioned before the marker)
  *   4. agent-kit machine credentials present → agent-kit
  *   5. running in a container → agent-kit
  *   6. macOS or Windows → desktop
@@ -15,6 +16,8 @@ import * as path from "node:path";
 import { AGENT_DIR_ENV, MACHINE_CREDS_NAME, agentRootDir } from "../agent-kit/paths.js";
 export const MACHINE_TYPES = ["desktop", "self-hosted", "outpost", "agent-box", "agent-kit"];
 export const MACHINE_TYPE_MARKER_PATH = "/etc/hq/machine-type";
+/** The Claude runner unit outpost provisioning installs; its `User=` is the box's login user. */
+export const OUTPOST_RUNNER_UNIT = "/etc/systemd/system/outpost-runner.service";
 export function isMachineType(value) {
     return typeof value === "string" && MACHINE_TYPES.includes(value);
 }
@@ -46,7 +49,8 @@ export function parseMachineTypeMarker(text) {
         return null;
     if (user !== undefined && !ACCOUNT_NAME.test(user))
         return null;
-    return user ? { type, user } : { type };
+    // The daemon never runs as root, so root is never taken as the login user.
+    return user && user !== "root" ? { type, user } : { type };
 }
 function platformName(platform) {
     if (platform === "darwin")
@@ -72,12 +76,29 @@ function readMarker(deps, warnings) {
         return null;
     }
 }
-/** Box types run as the login user the provisioning marker names, however the type itself was chosen. */
+/** The login user the outpost runner unit runs as, or undefined (never root). */
+function outpostRunnerUser(deps) {
+    if (!deps.existsSync(OUTPOST_RUNNER_UNIT))
+        return undefined;
+    let text;
+    try {
+        text = deps.readFileSync(OUTPOST_RUNNER_UNIT);
+    }
+    catch {
+        return undefined;
+    }
+    const user = /^\s*User\s*=\s*(\S+)\s*$/m.exec(text)?.[1];
+    return user && user !== "root" && ACCOUNT_NAME.test(user) ? user : undefined;
+}
+/**
+ * Box types run as the login user the provisioning marker names, or else the
+ * user the outpost runner unit runs as, however the type itself was chosen.
+ */
 function withMarkerUser(result, deps) {
     if (result.type !== "outpost" && result.type !== "agent-box")
         return result;
     const warnings = [];
-    const user = readMarker(deps, warnings)?.user;
+    const user = readMarker(deps, warnings)?.user ?? outpostRunnerUser(deps);
     return withWarnings(user ? { ...result, runAsUser: user } : result, warnings);
 }
 /**
@@ -106,12 +127,11 @@ export function detectMachineType(flag, deps) {
     const warnings = [];
     const marker = readMarker(deps, warnings);
     if (marker) {
-        return {
-            type: marker.type,
-            source: "marker",
-            detail: `from ${MACHINE_TYPE_MARKER_PATH}`,
-            ...(marker.user ? { runAsUser: marker.user } : {}),
-        };
+        return withMarkerUser({ type: marker.type, source: "marker", detail: `from ${MACHINE_TYPE_MARKER_PATH}` }, deps);
+    }
+    // Outposts provisioned before the marker existed still have their runner unit.
+    if (deps.platform === "linux" && deps.existsSync(OUTPOST_RUNNER_UNIT)) {
+        return withWarnings(withMarkerUser({ type: "outpost", source: "outpost-units", detail: `outpost runner at ${OUTPOST_RUNNER_UNIT}` }, deps), warnings);
     }
     const kitCreds = hostAgentCredsPath(deps.home, deps.env);
     if (deps.existsSync(kitCreds)) {

package/dist/lib/daemon/migrate.js

@@ -165,8 +165,8 @@ function moveBack(unit, to) {
         return;
     moveFile(unit.movedTo, to);
 }
-const SYSTEM_UNIT_NAME = /^[A-Za-z0-9@._-]+\.service$/;
-/** A system record entry may only put a .service file back into the system unit folder, from the root-owned store. */
+const SYSTEM_UNIT_NAME = /^[A-Za-z0-9@._-]+\.(service|timer)$/;
+/** A system record entry may only put a .service or .timer file back into the system unit folder, from the root-owned store. */
 function checkSystemEntry(unit, deps) {
     const expectedPath = path.join(deps.systemUnitDir, unit.name);
     const expectedSaved = path.join(deps.systemAdoptedDir, savedName(unit));

package/dist/lib/daemon/remote-control.d.ts

@@ -1,13 +1,19 @@
 /**
- * The `remote-control` service host (`hq daemon service remote-control`).
+ * The remote-control service hosts (`hq daemon service remote-control` and
+ * `codex-remote-control`).
  *
- * Like the outpost runner, `claude remote-control` runs inside a detached tmux
- * session so Claude has a terminal. This host process starts the session and
- * watches it; the daemon supervises the host:
+ * Like the outpost runners, the command (`claude remote-control`, or the box's
+ * Codex runner) runs inside a detached tmux session so it has a terminal. This
+ * host process starts the session and watches it; the daemon supervises the
+ * host:
  *
  * - the session ends -> the host exits 1 and the daemon restarts it with
  *   backoff (replacing the runner's `while true` loop and its watchdogs);
- * - the daemon stops the host -> the host kills the session and exits 0.
+ * - the daemon stops the host -> the host kills the session and exits 0;
+ * - the tool's binary changes on disk (the updater installed a new version) ->
+ *   once the session has been quiet for 10 minutes, or after 2 hours at the
+ *   latest, the host kills the session and exits 0, and the daemon starts it
+ *   again on the new version.
  *
  * The tmux server is a private socket (`-L hq-daemon`), so it never touches a
  * user's own tmux sessions.
@@ -15,16 +21,33 @@
 import type { RunCommand } from "../service-manager/launchd.js";
 export declare const TMUX_SOCKET = "hq-daemon";
 export declare const TMUX_SESSION = "remote-control";
+export declare const CODEX_TMUX_SESSION = "codex-remote-control";
 export declare function remoteControlArgs(opts: {
     name: string;
     permissionMode?: string;
 }): string[];
+/**
+ * The session name a box's own runner script passes to `claude remote-control`
+ * (`--name outpost-1-2`), so taking the runner over keeps the name people see.
+ */
+export declare function runnerSessionName(script: string): string | null;
+/** A tool updated on disk restarts its session once quiet this long... */
+export declare const IDLE_BEFORE_RESTART_MS: number;
+/** ...or after this long, however busy the session is. */
+export declare const MAX_RESTART_WAIT_MS: number;
 export interface RemoteControlHostDeps {
     tmux: string;
-    claude: string;
-    hqRoot: string;
-    name: string;
-    permissionMode?: string;
+    /** tmux session name on the daemon's private socket. */
+    session: string;
+    /** Folder the command starts in (the HQ folder). */
+    cwd: string;
+    /** The command to keep running, binary first. */
+    argv: string[];
+    /** Name used in log lines ("claude remote-control"). */
+    label: string;
+    /** Identity of the tool's binary on disk; a change means it was updated. Null when it cannot be read. */
+    binaryFingerprint: () => string | null;
+    now: () => number;
     run: RunCommand;
     sleep: (ms: number) => Promise<void>;
     pollMs: number;

package/dist/lib/daemon/remote-control.js

@@ -1,46 +1,90 @@
 /**
- * The `remote-control` service host (`hq daemon service remote-control`).
+ * The remote-control service hosts (`hq daemon service remote-control` and
+ * `codex-remote-control`).
  *
- * Like the outpost runner, `claude remote-control` runs inside a detached tmux
- * session so Claude has a terminal. This host process starts the session and
- * watches it; the daemon supervises the host:
+ * Like the outpost runners, the command (`claude remote-control`, or the box's
+ * Codex runner) runs inside a detached tmux session so it has a terminal. This
+ * host process starts the session and watches it; the daemon supervises the
+ * host:
  *
  * - the session ends -> the host exits 1 and the daemon restarts it with
  *   backoff (replacing the runner's `while true` loop and its watchdogs);
- * - the daemon stops the host -> the host kills the session and exits 0.
+ * - the daemon stops the host -> the host kills the session and exits 0;
+ * - the tool's binary changes on disk (the updater installed a new version) ->
+ *   once the session has been quiet for 10 minutes, or after 2 hours at the
+ *   latest, the host kills the session and exits 0, and the daemon starts it
+ *   again on the new version.
  *
  * The tmux server is a private socket (`-L hq-daemon`), so it never touches a
  * user's own tmux sessions.
  */
 export const TMUX_SOCKET = "hq-daemon";
 export const TMUX_SESSION = "remote-control";
+export const CODEX_TMUX_SESSION = "codex-remote-control";
 export function remoteControlArgs(opts) {
     const args = ["remote-control", "--name", opts.name, "--spawn=same-dir"];
     if (opts.permissionMode)
         args.push("--permission-mode", opts.permissionMode);
     return args;
 }
+/**
+ * The session name a box's own runner script passes to `claude remote-control`
+ * (`--name outpost-1-2`), so taking the runner over keeps the name people see.
+ */
+export function runnerSessionName(script) {
+    const m = /remote-control\b[^\n]*?--name[= ]+"?([^\s"]+)"?/.exec(script);
+    return m ? m[1] : null;
+}
+/** A tool updated on disk restarts its session once quiet this long... */
+export const IDLE_BEFORE_RESTART_MS = 10 * 60_000;
+/** ...or after this long, however busy the session is. */
+export const MAX_RESTART_WAIT_MS = 2 * 60 * 60_000;
 export async function runRemoteControlHost(deps) {
     const tmux = (...args) => deps.run(deps.tmux, ["-L", TMUX_SOCKET, ...args]);
-    const killSession = () => tmux("kill-session", "-t", TMUX_SESSION);
+    const killSession = () => tmux("kill-session", "-t", deps.session);
+    /** When the session last printed anything, in ms; null when tmux cannot say. */
+    const lastActivity = () => {
+        const r = tmux("display-message", "-p", "-t", deps.session, "#{window_activity}");
+        const secs = r.status === 0 ? Number.parseInt(r.stdout.trim(), 10) : Number.NaN;
+        return Number.isFinite(secs) ? secs * 1000 : null;
+    };
     // A session left by an earlier host (for example after a crash) is replaced.
     killSession();
-    const started = tmux("new-session", "-d", "-s", TMUX_SESSION, "-x", "200", "-y", "50", "-c", deps.hqRoot, deps.claude, ...remoteControlArgs({ name: deps.name, permissionMode: deps.permissionMode }));
+    const started = tmux("new-session", "-d", "-s", deps.session, "-x", "200", "-y", "50", "-c", deps.cwd, ...deps.argv);
     if (started.status !== 0) {
         deps.log(`could not start the tmux session: ${started.stderr.trim() || `tmux exited ${started.status}`}`);
         return 1;
     }
-    deps.log(`claude remote-control started as "${deps.name}" in ${deps.hqRoot}`);
+    deps.log(`${deps.label} started in ${deps.cwd}`);
+    const startedWith = deps.binaryFingerprint();
+    let updatedAt = null;
     for (;;) {
         if (deps.signal.aborted) {
             killSession();
-            deps.log("stopped remote control");
+            deps.log(`stopped ${deps.label}`);
             return 0;
         }
-        if (tmux("has-session", "-t", TMUX_SESSION).status !== 0) {
-            deps.log("the remote-control session ended");
+        if (tmux("has-session", "-t", deps.session).status !== 0) {
+            deps.log(`the ${deps.label} session ended`);
             return 1;
         }
+        const now = deps.now();
+        if (updatedAt === null) {
+            const current = deps.binaryFingerprint();
+            if (startedWith !== null && current !== null && current !== startedWith) {
+                updatedAt = now;
+                deps.log(`${deps.label}: the tool was updated; restarting onto it once the session is quiet (within 2 hours)`);
+            }
+        }
+        if (updatedAt !== null) {
+            const activity = lastActivity();
+            const quiet = activity !== null && now - activity >= IDLE_BEFORE_RESTART_MS;
+            if (quiet || now - updatedAt >= MAX_RESTART_WAIT_MS) {
+                killSession();
+                deps.log(`${deps.label}: restarting onto the updated tool${quiet ? "" : " (the session stayed busy for 2 hours)"}`);
+                return 0;
+            }
+        }
         await deps.sleep(deps.pollMs);
     }
 }

package/dist/lib/daemon/run.d.ts

@@ -25,6 +25,12 @@ export declare function windowsTaskExists(taskName: string): boolean;
 export declare function probeLegacyUnits(platform: NodeJS.Platform, home: string): LegacyUnit[];
 /** Absolute path of `name` on PATH, or null. */
 export declare function findOnPath(name: string, env?: NodeJS.ProcessEnv): string | null;
+/**
+ * A tool the login user installed (~/.local/bin, ~/.npm-global/bin,
+ * ~/.grok/bin) before anything on PATH, so a box runs and updates the user's
+ * own copy instead of one root installed under /usr.
+ */
+export declare function findUserBinary(name: string, env: NodeJS.ProcessEnv, home: string): string | null;
 /** This CLI is a global package install the updater can replace (not a dev checkout or a project dependency). */
 export declare function cliSelfUpdatable(): boolean;
 /** The HQ desktop app process is running here (it runs its own sync). */

package/dist/lib/daemon/run.js

@@ -15,14 +15,17 @@ import { isLocalDependencyInstall, resolveRunningInstall } from "../../utils/ver
 import { agentKitPaths } from "../agent-kit/paths.js";
 import { readBotConfig } from "../bot/config.js";
 import { botsRoot } from "../bot/paths.js";
-import { enabledServices, planUnits } from "./catalog.js";
+import { CLAUDE_RUNNER_SCRIPT, CODEX_RUNNER_SCRIPT, enabledServices, planUnits } from "./catalog.js";
 import { readDaemonConfig } from "./config.js";
 import { findLegacyUnits, legacyOwnerLookup } from "./legacy.js";
 import { acquireDaemonLock, releaseDaemonLock } from "./lock.js";
+import { daemonRootRefusal } from "./install.js";
 import { detectMachineType } from "./machine-type.js";
 import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from "./paths.js";
 import { takeControlRequests } from "./requests.js";
+import { runnerSessionName } from "./remote-control.js";
 import { STOP_ESCALATION_MS, createSupervisor } from "./supervisor.js";
+import { userToolDirs } from "./tools.js";
 export const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
 /** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
 export const RESTART_EXIT_CODE = 75;
@@ -79,6 +82,35 @@ export function findOnPath(name, env = process.env) {
     }
     return null;
 }
+/**
+ * A tool the login user installed (~/.local/bin, ~/.npm-global/bin,
+ * ~/.grok/bin) before anything on PATH, so a box runs and updates the user's
+ * own copy instead of one root installed under /usr.
+ */
+export function findUserBinary(name, env, home) {
+    if (process.platform !== "win32") {
+        for (const dir of userToolDirs(home)) {
+            const candidate = path.join(dir, name);
+            try {
+                fs.accessSync(candidate, fs.constants.X_OK);
+                if (fs.statSync(candidate).isFile())
+                    return candidate;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    return findOnPath(name, env);
+}
+function readIfExists(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
 /** This CLI is a global package install the updater can replace (not a dev checkout or a project dependency). */
 export function cliSelfUpdatable() {
     const install = resolveRunningInstall();
@@ -191,6 +223,12 @@ export async function runDaemon(opts) {
     const machineType = detected.type;
     for (const w of detected.warnings ?? [])
         log("warn", w);
+    const refusal = daemonRootRefusal(typeof process.getuid === "function" && process.getuid() === 0, machineType);
+    if (refusal) {
+        log("error", refusal);
+        releaseDaemonLock(paths.lockPath);
+        return 1;
+    }
     log("info", `starting hq daemon (pid ${process.pid}) as ${machineType} (${detected.detail})`);
     const syncRunnerPath = resolveSyncRunnerPath();
     if (!syncRunnerPath)
@@ -223,7 +261,10 @@ export async function runDaemon(opts) {
             legacyOwner: legacyOwnerLookup(legacy),
             cliSelfUpdatable: updatable,
             jobsReconcileScript: jobsReconcileScript(hqRoot),
-            claudePath: findOnPath("claude", env),
+            claudePath: findUserBinary("claude", env, home),
+            codexPath: findUserBinary("codex", env, home),
+            codexRunnerScript: platform === "linux" && fs.existsSync(CODEX_RUNNER_SCRIPT) ? CODEX_RUNNER_SCRIPT : null,
+            remoteControlName: runnerSessionName(readIfExists(CLAUDE_RUNNER_SCRIPT) ?? ""),
             tmuxPath: findOnPath("tmux", env),
             hostName,
         });

package/dist/lib/daemon/tools.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The AI CLIs the daemon keeps current (Claude, Codex, Grok): where the login
+ * user's copy is, which version it is, and how to update it.
+ *
+ * Boxes can carry two copies of a tool: one root installed under /usr during
+ * provisioning, and the login user's own under ~/.npm-global or ~/.local. The
+ * daemon runs as the login user, so it always prefers that user's copy (which
+ * it can update) and never updates a copy it cannot write.
+ */
+export declare const TOOL_NAMES: readonly ["claude", "codex", "grok"];
+export type ToolName = (typeof TOOL_NAMES)[number];
+export interface ToolProbeDeps {
+    home: string;
+    /** Defaults to this process's platform. */
+    platform?: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    exists: (p: string) => boolean;
+    realpath: (p: string) => string;
+    /** Whether this user can write the directory. */
+    writable: (dir: string) => boolean;
+    /** `<bin> --version`. */
+    version: (bin: string) => {
+        status: number | null;
+        stdout: string;
+    };
+}
+export interface ToolInstall {
+    /** The command as found (for example ~/.npm-global/bin/claude). */
+    path: string;
+    /** Where that resolves to on disk. */
+    realPath: string;
+    version: string | null;
+    /** False for a copy this user cannot update (for example root's under /usr). */
+    writable: boolean;
+}
+/** The login user's own install folders, searched before PATH. */
+export declare function userToolDirs(home: string): string[];
+export declare function findUserTool(name: ToolName, deps: ToolProbeDeps): string | null;
+export declare function parseToolVersion(output: string): string | null;
+export declare function locateTool(name: ToolName, deps: ToolProbeDeps): ToolInstall | null;
+export interface ToolUpdateCommand {
+    file: string;
+    args: string[];
+    env: Record<string, string>;
+}
+/**
+ * An npm install is updated through npm, into the prefix it was found in (the
+ * npm on PATH may be configured for another one); anything else through the
+ * CLI's own `update`.
+ */
+export declare function toolUpdateCommand(name: ToolName, install: Pick<ToolInstall, "path" | "realPath">, platform?: NodeJS.Platform): ToolUpdateCommand;
+//# sourceMappingURL=tools.d.ts.map

package/dist/lib/daemon/tools.js

@@ -0,0 +1,95 @@
+/**
+ * The AI CLIs the daemon keeps current (Claude, Codex, Grok): where the login
+ * user's copy is, which version it is, and how to update it.
+ *
+ * Boxes can carry two copies of a tool: one root installed under /usr during
+ * provisioning, and the login user's own under ~/.npm-global or ~/.local. The
+ * daemon runs as the login user, so it always prefers that user's copy (which
+ * it can update) and never updates a copy it cannot write.
+ */
+import * as path from "node:path";
+export const TOOL_NAMES = ["claude", "codex", "grok"];
+/** npm package for tools that can be installed with npm. */
+const NPM_PACKAGES = {
+    claude: "@anthropic-ai/claude-code",
+    codex: "@openai/codex",
+    grok: "@vibe-kit/grok-cli",
+};
+/** Environment each tool's own `update` command needs to run unattended. */
+const UPDATE_ENV = {
+    codex: { CODEX_NON_INTERACTIVE: "1" },
+};
+/** The login user's own install folders, searched before PATH. */
+export function userToolDirs(home) {
+    return [
+        path.posix.join(home, ".local", "bin"),
+        path.posix.join(home, ".npm-global", "bin"),
+        path.posix.join(home, ".grok", "bin"),
+    ];
+}
+export function findUserTool(name, deps) {
+    const windows = (deps.platform ?? process.platform) === "win32";
+    if (!windows) {
+        for (const dir of userToolDirs(deps.home)) {
+            const candidate = path.posix.join(dir, name);
+            if (deps.exists(candidate))
+                return candidate;
+        }
+    }
+    const p = windows ? path.win32 : path.posix;
+    // Windows installs are claude.exe, codex.cmd and so on.
+    const exts = windows ? (deps.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+    for (const dir of (deps.env.PATH ?? "").split(p.delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const candidate = p.join(dir, `${name}${ext.toLowerCase()}`);
+            if (deps.exists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+export function parseToolVersion(output) {
+    const m = /\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?)\b/.exec(output);
+    return m ? m[1] : null;
+}
+export function locateTool(name, deps) {
+    const found = findUserTool(name, deps);
+    if (!found)
+        return null;
+    const realPath = deps.realpath(found);
+    const r = deps.version(found);
+    return {
+        path: found,
+        realPath,
+        version: r.status === 0 ? parseToolVersion(r.stdout) : null,
+        writable: deps.writable(path.dirname(realPath)),
+    };
+}
+/**
+ * The npm global prefix an install lives in: `<prefix>/lib/node_modules/<pkg>`
+ * on Unix, `<prefix>\\node_modules\\<pkg>` on Windows. Null when the real path
+ * is not inside that package.
+ */
+function npmPrefixOf(realPath, pkg, platform) {
+    const windows = platform === "win32";
+    const p = windows ? path.win32 : path.posix;
+    const marker = windows ? `${p.sep}node_modules${p.sep}${pkg.split("/").join(p.sep)}${p.sep}` : `/lib/node_modules/${pkg}/`;
+    const at = realPath.indexOf(marker);
+    return at > 0 ? realPath.slice(0, at) : null;
+}
+/**
+ * An npm install is updated through npm, into the prefix it was found in (the
+ * npm on PATH may be configured for another one); anything else through the
+ * CLI's own `update`.
+ */
+export function toolUpdateCommand(name, install, platform = process.platform) {
+    const pkg = NPM_PACKAGES[name];
+    const prefix = pkg ? npmPrefixOf(install.realPath, pkg, platform) : null;
+    if (pkg && prefix) {
+        return { file: "npm", args: ["install", "-g", "--prefix", prefix, `${pkg}@latest`], env: {} };
+    }
+    return { file: install.path, args: ["update"], env: { ...(UPDATE_ENV[name] ?? {}) } };
+}
+//# sourceMappingURL=tools.js.map

package/dist/lib/daemon/updater.d.ts

@@ -3,37 +3,45 @@
  * replaces the boxes' `hq-cli-update.timer` and `*-codex-update.timer`:
  *
  * 1. Update the hq CLI through the shared self-update path (same install
- *    routing, lock and convergence check as every other CLI update).
- * 2. Update Codex when it is installed as a global npm package and behind.
+ *    routing, lock and convergence check as every other CLI update), when it
+ *    is a global install this process may replace.
+ * 2. Update the Claude, Codex and Grok CLIs the login user installed, each
+ *    through its own update route. A copy this user cannot write (root's
+ *    under /usr) is reported and left alone.
  * 3. After a CLI update, ask the daemon to restart itself so the supervisor and
- *    every service run the new version.
+ *    every service run the new version. The remote-control hosts notice an
+ *    updated Claude or Codex on disk themselves and restart once idle.
  */
 import type { SelfUpdateOutcome } from "../../utils/self-update.js";
-export declare const CODEX_PACKAGE = "@openai/codex";
-export interface CodexUpdater {
-    /** Version of the global npm install, or null when Codex is not installed that way. */
-    installedVersion: () => string | null;
-    latestVersion: () => string | null;
-    install: () => {
+import { type ToolInstall, type ToolName } from "./tools.js";
+export type { ToolInstall } from "./tools.js";
+export interface ToolUpdater {
+    name: ToolName;
+    locate: () => ToolInstall | null;
+    update: (install: ToolInstall) => {
         ok: boolean;
         detail?: string;
     };
 }
 export interface UpdaterDeps {
-    updateCli: () => Promise<Pick<SelfUpdateOutcome, "action" | "latest">>;
-    codex: CodexUpdater;
+    /** Null when this CLI is not a global install the updater may replace. */
+    updateCli: (() => Promise<Pick<SelfUpdateOutcome, "action" | "latest">>) | null;
+    tools: readonly ToolUpdater[];
     requestDaemonRestart: () => void;
     log: (line: string) => void;
 }
-export declare function runDaemonUpdater(deps: UpdaterDeps): Promise<{
+export interface UpdaterResult {
     ok: boolean;
-}>;
+    /** Tools whose version changed in this run. */
+    updated: ToolName[];
+}
+export declare function runDaemonUpdater(deps: UpdaterDeps): Promise<UpdaterResult>;
 /**
  * The variables for the updater's own CLI update. Every supervised service
  * gets HQ_NO_UPDATE_CHECK=1 so it never updates itself; the updater is the one
  * process that must, so it drops that opt-out.
  */
 export declare function updaterEnv(vars: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-/** Codex through the global npm install, the way the boxes install it. */
-export declare function npmCodexUpdater(): CodexUpdater;
+/** The real updater for one tool, run as this (the login) user. */
+export declare function hostToolUpdater(name: ToolName, env: NodeJS.ProcessEnv, home: string): ToolUpdater;
 //# sourceMappingURL=updater.d.ts.map