@indigoai-us/hq-cli 5.171.0 → 5.173.0

package/dist/lib/mesh/live/daemon/install.js

@@ -24,6 +24,7 @@ import { retireLegacyListen } from "./legacy-listen.js";
 import { readDaemonState } from "./state.js";
 import { activateLaunchd, launchdPlistProgramArguments, launchdProgramArgumentsDiffer, parseLaunchctlPrintArguments, } from "../../../service-manager/launchd.js";
 import { activateSystemd } from "../../../service-manager/systemd.js";
+import { nodeBinaryProblem, preferStableNodeBinary } from "../../../node-binary.js";
 /**
  * `schtasks /End` terminates the task's root process only. The daemon is
  * launched through `conhost.exe --headless`, so ending the task kills conhost
@@ -113,7 +114,7 @@ function migrateLegacyDaemonUnit(opts) {
         env: opts.env,
         hqRoot: verified,
         hqBinary: "/usr/bin/hq",
-        nodeBinary: process.execPath || "/usr/bin/node",
+        nodeBinary: process.execPath ? resolveNodeBinary(process.execPath, opts.env ?? process.env) : "/usr/bin/node",
     });
     try {
         paths.hqBinary = resolveHqBinary(process.argv, opts.env ?? process.env);
@@ -264,18 +265,25 @@ export function resolveRunningCliEntry(argv = process.argv) {
         throw new Error(`Cannot resolve hq binary: ${entry} is not a real path`);
     }
 }
-/** Absolute node binary (realpath of process.execPath). No PATH lookup. */
+/**
+ * Absolute node binary for a service unit: the realpath of process.execPath,
+ * then its upgrade-stable alias (/opt/homebrew/bin/node rather than
+ * /opt/homebrew/Cellar/node/<version>/bin/node) when one resolves to the same
+ * binary. No PATH lookup of `node` by name.
+ */
 export function resolveAbsoluteNodeBinary(execPath = process.execPath) {
     if (!execPath)
         throw new Error("Cannot resolve node binary: execPath is empty");
+    let real;
     try {
-        return fs.realpathSync(execPath);
+        real = fs.realpathSync(execPath);
     }
     catch {
         if (path.isAbsolute(execPath))
             return execPath;
         throw new Error(`Cannot resolve node binary: ${execPath} is not a real path`);
     }
+    return preferStableNodeBinary(real);
 }
 /** Resolve the hq binary the current shell uses (argv[1] or PATH). */
 export function resolveHqBinary(argv = process.argv, env = process.env) {
@@ -312,7 +320,14 @@ export function isNewerCliVersion(current, recorded) {
  */
 export function installDaemonIfStale(opts) {
     const recorded = readDaemonState(opts.paths.daemonDir)?.cliVersion;
-    if (!isNewerCliVersion(opts.currentVersion, recorded)) {
+    const platformForUnit = opts.platform ?? detectPlatform();
+    const installedNode = installedDaemonNodeBinary(opts.paths, platformForUnit, opts.readUnit);
+    // Only a rewrite that changes the node path helps: a unit whose node is gone
+    // or versioned, while this install resolves a different (stable) one.
+    const nodeProblem = installedNode && installedNode !== opts.paths.nodeBinary
+        ? (opts.nodeProblem ?? nodeBinaryProblem)(installedNode)
+        : null;
+    if (!isNewerCliVersion(opts.currentVersion, recorded) && !nodeProblem) {
         return {
             reinstalled: false,
             message: `daemon already records hq ${recorded}; not reinstalling`,
@@ -350,9 +365,42 @@ export function installDaemonIfStale(opts) {
         message: `${installed.message} Restarted with ${opts.paths.nodeBinary} ${opts.paths.hqBinary}.`,
     };
 }
+/**
+ * The node binary baked into the installed daemon unit (darwin plist or linux
+ * user unit), or null when there is no unit or it cannot be read. Used to
+ * reinstall a unit whose node was a versioned path an upgrade removed.
+ */
+export function installedDaemonNodeBinary(paths, platform, readUnit = (file) => {
+    try {
+        return fs.existsSync(file) ? fs.readFileSync(file, "utf8") : null;
+    }
+    catch {
+        return null;
+    }
+}) {
+    if (platform === "darwin") {
+        const text = readUnit(paths.plistPath);
+        if (!text)
+            return null;
+        const block = text.match(/<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/);
+        const first = block?.[1]?.match(/<string>([^<]*)<\/string>/);
+        return first?.[1] ?? null;
+    }
+    if (platform === "linux") {
+        const text = readUnit(paths.systemdUnitPath);
+        if (!text)
+            return null;
+        const m = text.match(/^ExecStart=('(?:[^']|'\\'')*'|\S+)/m);
+        if (!m)
+            return null;
+        const raw = m[1];
+        return raw.startsWith("'") ? raw.slice(1, -1).replace(/'\\''/g, "'") : raw;
+    }
+    return null;
+}
 export function resolveNodeBinary(execPath = process.execPath, env = process.env) {
     if (execPath && fs.existsSync(execPath))
-        return execPath;
+        return preferStableNodeBinary(execPath, { env });
     const pathEnv = env.PATH ?? "";
     for (const dir of pathEnv.split(path.delimiter)) {
         const candidate = path.join(dir, "node");

package/dist/lib/node-binary.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A node path that survives a node upgrade, for service units (LaunchAgents,
+ * systemd user units) that name node by absolute path.
+ *
+ * `process.execPath` is the resolved binary, e.g.
+ * /opt/homebrew/Cellar/node/26.0.0/bin/node. `brew upgrade node` deletes that
+ * directory, and every unit that baked it in stops launching (launchd cannot
+ * exec a missing program, so KeepAlive never brings the job back).
+ *
+ * The fix is to write the stable name the package manager keeps pointing at
+ * the current version (/opt/homebrew/bin/node, /opt/homebrew/opt/node/bin/node)
+ * instead of the versioned directory it points at today. A candidate is only
+ * used when it resolves to the SAME binary this process runs, so the unit
+ * keeps running the exact node it was installed with; a machine where no such
+ * alias exists (nvm without a `current` link, a hand-built node) keeps the
+ * execPath, as before.
+ */
+export interface NodeBinaryIo {
+    existsSync(p: string): boolean;
+    realpathSync(p: string): string;
+}
+/** True when `p` is a node binary inside a version-specific directory. */
+export declare function isVersionedNodePath(p: string): boolean;
+/**
+ * Stable names that may point at `execPath`, most specific first:
+ * the Homebrew prefix's bin/ and opt/<formula>/ links, a `current` link under
+ * nvm, then the usual global bins and every PATH entry.
+ */
+export declare function stableNodeCandidates(execPath: string, env?: NodeJS.ProcessEnv, home?: string): string[];
+/**
+ * The stable name for `execPath` when it sits in a versioned directory and an
+ * alias resolving to the same binary exists; otherwise `execPath` unchanged.
+ */
+export declare function preferStableNodeBinary(execPath: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    io?: NodeBinaryIo;
+}): string;
+/**
+ * Why a unit's node path needs rewriting, or null when it is fine:
+ * "missing" — the binary is gone (launchd can no longer start the job);
+ * "versioned" — it still exists but the next upgrade will remove it, and a
+ * stable alias for the same binary exists.
+ */
+export declare function nodeBinaryProblem(nodePath: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    io?: NodeBinaryIo;
+}): "missing" | "versioned" | null;
+//# sourceMappingURL=node-binary.d.ts.map

package/dist/lib/node-binary.js

@@ -0,0 +1,133 @@
+/**
+ * A node path that survives a node upgrade, for service units (LaunchAgents,
+ * systemd user units) that name node by absolute path.
+ *
+ * `process.execPath` is the resolved binary, e.g.
+ * /opt/homebrew/Cellar/node/26.0.0/bin/node. `brew upgrade node` deletes that
+ * directory, and every unit that baked it in stops launching (launchd cannot
+ * exec a missing program, so KeepAlive never brings the job back).
+ *
+ * The fix is to write the stable name the package manager keeps pointing at
+ * the current version (/opt/homebrew/bin/node, /opt/homebrew/opt/node/bin/node)
+ * instead of the versioned directory it points at today. A candidate is only
+ * used when it resolves to the SAME binary this process runs, so the unit
+ * keeps running the exact node it was installed with; a machine where no such
+ * alias exists (nvm without a `current` link, a hand-built node) keeps the
+ * execPath, as before.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const defaultIo = {
+    existsSync: (p) => fs.existsSync(p),
+    realpathSync: (p) => fs.realpathSync(p),
+};
+/**
+ * Install layouts whose node lives in a per-version directory that an upgrade
+ * or version switch removes or abandons.
+ */
+const VERSIONED_NODE_PATTERNS = [
+    // Homebrew: <prefix>/Cellar/node/26.0.0/bin/node, <prefix>/Cellar/node@22/22.9.0/bin/node
+    /\/Cellar\/node(?:@[^/]+)?\/[^/]+\/bin\/node$/,
+    // nvm
+    /\/\.nvm\/versions\/node\/[^/]+\/bin\/node$/,
+    // Volta
+    /\/\.volta\/tools\/image\/node\/[^/]+\/bin\/node$/,
+    // fnm (installed versions and the per-shell multishell links)
+    /\/fnm\/node-versions\/[^/]+\/installation\/bin\/node$/,
+    /\/fnm_multishells\/[^/]+\/bin\/node$/,
+    // asdf / mise
+    /\/\.asdf\/installs\/nodejs\/[^/]+\/bin\/node$/,
+    /\/mise\/installs\/node\/[^/]+\/bin\/node$/,
+    // n
+    /\/n\/versions\/node\/[^/]+\/bin\/node$/,
+];
+/** True when `p` is a node binary inside a version-specific directory. */
+export function isVersionedNodePath(p) {
+    const normalized = p.split(path.sep).join("/");
+    return VERSIONED_NODE_PATTERNS.some((re) => re.test(normalized));
+}
+/**
+ * Stable names that may point at `execPath`, most specific first:
+ * the Homebrew prefix's bin/ and opt/<formula>/ links, a `current` link under
+ * nvm, then the usual global bins and every PATH entry.
+ */
+export function stableNodeCandidates(execPath, env = process.env, home = os.homedir()) {
+    const normalized = execPath.split(path.sep).join("/");
+    const out = [];
+    const brew = /^(.*)\/Cellar\/(node(?:@[^/]+)?)\/[^/]+\/bin\/node$/.exec(normalized);
+    if (brew) {
+        const prefix = brew[1];
+        out.push(`${prefix}/bin/node`, `${prefix}/opt/${brew[2]}/bin/node`);
+    }
+    const nvmDir = env.NVM_DIR?.trim() || path.join(home, ".nvm");
+    if (/\/\.nvm\/versions\/node\//.test(normalized))
+        out.push(path.join(nvmDir, "current", "bin", "node"));
+    out.push("/opt/homebrew/bin/node", "/usr/local/bin/node", "/usr/bin/node");
+    for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+        if (dir && path.isAbsolute(dir))
+            out.push(path.join(dir, "node"));
+    }
+    return [...new Set(out)];
+}
+/**
+ * The stable name for `execPath` when it sits in a versioned directory and an
+ * alias resolving to the same binary exists; otherwise `execPath` unchanged.
+ */
+export function preferStableNodeBinary(execPath, opts = {}) {
+    if (!execPath || !isVersionedNodePath(execPath))
+        return execPath;
+    const io = opts.io ?? defaultIo;
+    let target;
+    try {
+        target = io.realpathSync(execPath);
+    }
+    catch {
+        // A versioned node that is already gone (a stale unit being repaired):
+        // there is no binary to match, so any working stable node is the answer.
+        return firstWorkingStableNode(execPath, opts, io) ?? execPath;
+    }
+    for (const candidate of stableNodeCandidates(execPath, opts.env ?? process.env, opts.home ?? os.homedir())) {
+        if (isVersionedNodePath(candidate))
+            continue;
+        try {
+            if (!io.existsSync(candidate))
+                continue;
+            if (io.realpathSync(candidate) === target)
+                return candidate;
+        }
+        catch {
+            /* dangling link — not a candidate */
+        }
+    }
+    return execPath;
+}
+function firstWorkingStableNode(execPath, opts, io) {
+    for (const candidate of stableNodeCandidates(execPath, opts.env ?? process.env, opts.home ?? os.homedir())) {
+        if (isVersionedNodePath(candidate))
+            continue;
+        try {
+            if (io.existsSync(candidate) && io.existsSync(io.realpathSync(candidate)))
+                return candidate;
+        }
+        catch {
+            /* dangling link */
+        }
+    }
+    return null;
+}
+/**
+ * Why a unit's node path needs rewriting, or null when it is fine:
+ * "missing" — the binary is gone (launchd can no longer start the job);
+ * "versioned" — it still exists but the next upgrade will remove it, and a
+ * stable alias for the same binary exists.
+ */
+export function nodeBinaryProblem(nodePath, opts = {}) {
+    const io = opts.io ?? defaultIo;
+    if (!nodePath)
+        return null;
+    if (!io.existsSync(nodePath))
+        return "missing";
+    return preferStableNodeBinary(nodePath, opts) !== nodePath ? "versioned" : null;
+}
+//# sourceMappingURL=node-binary.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.171.0",
+  "version": "5.173.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {