@indigoai-us/hq-cli 5.341.3 → 5.341.4

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [Unreleased]
 
+## [5.341.4] — 2026-10-03
+- Prevent daemon restarts from waiting on stale or already-owned Claude bridge sessions, and keep captured startup diagnostics useful without exposing authorization credentials.
+
 ## [5.341.3] — 2026-10-03
 - Preserve policy-trigger parity for Windows PATH resolution, filesystem paths, and frontmatter parsing.
 - Report unexpected company-resolve, plan-limit body and late owner-context failures that a bare catch used to hide. The report prints only with `--verbose` or `HQ_DEBUG` set.

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

@@ -69,6 +69,13 @@ export interface RemoteControlHostDeps {
     pollMs: number;
     signal: AbortSignal;
     log: (line: string) => void;
+    /** Claude's per-folder bridge pointer. Codex hosts leave this unset. */
+    bridgePointerPath?: string | null;
+    /** Process probes are injectable so ownership checks are deterministic in tests. */
+    pidAlive?: (pid: number) => boolean;
+    processCommandLine?: (pid: number) => string[] | null;
+    /** Process start identity, when the pointer carries one; injectable for tests. */
+    processStartTime?: (pid: number) => string | null;
 }
 export declare function runRemoteControlHost(deps: RemoteControlHostDeps): Promise<number>;
 //# sourceMappingURL=remote-control.d.ts.map

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

@@ -21,6 +21,7 @@
  * user's own tmux sessions.
  */
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 const TMUX_SOCKET = "hq-daemon";
 export const TMUX_SESSION = "remote-control";
@@ -101,6 +102,106 @@ export function serviceTool(name, given, find) {
 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;
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function commandLine(pid, run) {
+    try {
+        if (process.platform === "linux") {
+            return fs.readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean);
+        }
+        const result = run("ps", ["-p", String(pid), "-o", "command="]);
+        return result.status === 0 ? result.stdout.trim().split(/\s+/).filter(Boolean) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultBridgePointerPath(cwd) {
+    const project = path.resolve(cwd).replace(/[^A-Za-z0-9]/g, "-");
+    return path.join(os.homedir(), ".claude", "projects", project, "bridge-pointer.json");
+}
+function processStartTime(pid, log) {
+    if (process.platform !== "linux")
+        return null;
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const close = stat.lastIndexOf(")");
+        if (close < 0) {
+            log("could not parse Linux process start time");
+            return null;
+        }
+        // The remaining fields start at field 3; starttime is field 22 (index 19).
+        const startTime = stat.slice(close + 1).trim().split(/\s+/)[19];
+        if (startTime === undefined)
+            log("Linux process stat did not include a start time");
+        return startTime ?? null;
+    }
+    catch {
+        log("could not read Linux process start time");
+        return null;
+    }
+}
+function foreignClaudeOwner(deps) {
+    if (deps.session !== TMUX_SESSION)
+        return null;
+    const pointerPath = deps.bridgePointerPath === undefined ? defaultBridgePointerPath(deps.cwd) : deps.bridgePointerPath;
+    if (!pointerPath)
+        return null;
+    let pointer;
+    try {
+        pointer = JSON.parse(fs.readFileSync(pointerPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    const pid = pointer.pid;
+    if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid)
+        return null;
+    const numericPid = pid;
+    if (!(deps.pidAlive ?? processAlive)(numericPid))
+        return null;
+    const args = (deps.processCommandLine ?? ((processId) => commandLine(processId, deps.run)))(numericPid);
+    if (!args)
+        return null;
+    const claudeIndex = args.findIndex((arg) => path.basename(arg) === "claude");
+    if (claudeIndex < 0)
+        return null;
+    const pointerStart = typeof pointer.procStart === "string" || typeof pointer.procStart === "number"
+        ? String(pointer.procStart)
+        : null;
+    if (pointerStart !== null) {
+        const liveStart = deps.processStartTime
+            ? deps.processStartTime(numericPid)
+            : processStartTime(numericPid, deps.log);
+        if (liveStart !== null && liveStart !== pointerStart)
+            return null;
+    }
+    if (pointer.source !== "repl" && !args.slice(claudeIndex + 1).includes("remote-control"))
+        return null;
+    return numericPid;
+}
+function safePaneTail(output) {
+    const rows = output.split(/\r?\n/);
+    while (rows.length > 0 && rows.at(-1)?.trim() === "")
+        rows.pop();
+    return rows
+        .slice(-20)
+        .map((line) => line
+        .replace(/https?:\/\/\S+/gi, "[redacted URL]")
+        .replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi, "[redacted session id]")
+        .replace(/\b(authorization\s*[:=]\s*(?:(?:basic|bearer)\s+)?)[^\r\n]+/gi, "$1[redacted]")
+        .replace(/\b(session[ _-]?id|token|api[ _-]?key|secret)\s*[:=]\s*\S+/gi, "$1=[redacted]")
+        .replace(/\b[A-Za-z0-9_-]{32,}\b/g, "[redacted token]")
+        .slice(0, 400))
+        .join("\n");
+}
 export async function runRemoteControlHost(deps) {
     const tmux = (...args) => deps.run(deps.tmux, ["-L", TMUX_SOCKET, ...args]);
     const killSession = () => tmux("kill-session", "-t", deps.session);
@@ -110,10 +211,34 @@ export async function runRemoteControlHost(deps) {
         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.
+    // Remove this daemon's leftover private session before checking the process
+    // pointer, so its previous command is not mistaken for a foreign owner.
     killSession();
-    const started = tmux("new-session", "-d", "-s", deps.session, "-x", "200", "-y", "50", "-c", deps.cwd, ...deps.argv);
+    let waitingFor = null;
+    for (;;) {
+        if (deps.signal.aborted)
+            return 0;
+        const owner = foreignClaudeOwner(deps);
+        if (owner === null)
+            break;
+        if (waitingFor !== owner) {
+            deps.log(`${deps.cwd} is already served by claude remote-control pid ${owner} (not started by this daemon); waiting`);
+            waitingFor = owner;
+        }
+        await deps.sleep(deps.pollMs);
+    }
+    // Start the replacement only after no live foreign Claude owner remains.
+    const created = tmux("new-session", "-d", "-s", deps.session, "-x", "200", "-y", "50", "-c", deps.cwd);
+    if (created.status !== 0) {
+        deps.log(`could not create the tmux session: ${created.stderr.trim() || `tmux exited ${created.status}`}`);
+        return 1;
+    }
+    const retained = tmux("set-window-option", "-t", deps.session, "remain-on-exit", "on");
+    const started = retained.status === 0
+        ? tmux("respawn-pane", "-k", "-t", deps.session, ...deps.argv)
+        : retained;
     if (started.status !== 0) {
+        killSession();
         deps.log(`could not start the tmux session: ${started.stderr.trim() || `tmux exited ${started.status}`}`);
         return 1;
     }
@@ -130,6 +255,14 @@ export async function runRemoteControlHost(deps) {
             deps.log(`the ${deps.label} session ended`);
             return 1;
         }
+        const paneDead = tmux("display-message", "-p", "-t", deps.session, "#{pane_dead}");
+        if (paneDead.status === 0 && paneDead.stdout.trim() === "1") {
+            const pane = tmux("capture-pane", "-p", "-S", "-20", "-t", deps.session);
+            const tail = pane.status === 0 ? safePaneTail(pane.stdout) : "";
+            deps.log(`the ${deps.label} session ended${tail ? `\n${tail}` : ""}`);
+            killSession();
+            return 1;
+        }
         const now = deps.now();
         if (updatedAt === null) {
             const current = deps.binaryFingerprint();

package/package.json

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