@indigoai-us/hq-cli 5.322.0 → 5.324.0

package/dist/lib/daemon/session-registry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * In-memory session registry hosted by hqd (hq-anywhere US-008). Keyed by
+ * runtime + session id; nothing is persisted, so a daemon restart starts empty
+ * and sessions re-open on their next hook.
+ */
+export interface HqdSession {
+    runtime: string;
+    sessionId: string;
+    cwd: string;
+    company: string | null;
+    startedAt: string;
+}
+export declare function sessionKey(runtime: string, sessionId: string): string;
+export declare class SessionRegistry {
+    private readonly now;
+    private readonly sessions;
+    constructor(now?: () => Date);
+    /** Open or refresh a session. Re-opening keeps the original startedAt. */
+    open(input: {
+        runtime: string;
+        sessionId: string;
+        cwd: string;
+        company: string | null;
+    }): HqdSession;
+    get(runtime: string, sessionId: string): HqdSession | null;
+    close(runtime: string, sessionId: string): boolean;
+    list(): HqdSession[];
+    get size(): number;
+}
+//# sourceMappingURL=session-registry.d.ts.map

package/dist/lib/daemon/session-registry.js

@@ -0,0 +1,42 @@
+/**
+ * In-memory session registry hosted by hqd (hq-anywhere US-008). Keyed by
+ * runtime + session id; nothing is persisted, so a daemon restart starts empty
+ * and sessions re-open on their next hook.
+ */
+export function sessionKey(runtime, sessionId) {
+    return `${runtime}\u0000${sessionId}`;
+}
+export class SessionRegistry {
+    now;
+    sessions = new Map();
+    constructor(now = () => new Date()) {
+        this.now = now;
+    }
+    /** Open or refresh a session. Re-opening keeps the original startedAt. */
+    open(input) {
+        const key = sessionKey(input.runtime, input.sessionId);
+        const prior = this.sessions.get(key);
+        const session = {
+            runtime: input.runtime,
+            sessionId: input.sessionId,
+            cwd: input.cwd,
+            company: input.company,
+            startedAt: prior?.startedAt ?? this.now().toISOString(),
+        };
+        this.sessions.set(key, session);
+        return session;
+    }
+    get(runtime, sessionId) {
+        return this.sessions.get(sessionKey(runtime, sessionId)) ?? null;
+    }
+    close(runtime, sessionId) {
+        return this.sessions.delete(sessionKey(runtime, sessionId));
+    }
+    list() {
+        return [...this.sessions.values()];
+    }
+    get size() {
+        return this.sessions.size;
+    }
+}
+//# sourceMappingURL=session-registry.js.map

package/dist/lib/doctor/checks/anywhere.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `hq doctor` anywhere family (hq-anywhere US-012).
+ *
+ * Checks the pieces that let a session in any repo pick up HQ: the ~/.hq/root
+ * pointer, the repo registry, the hqd daemon service and socket, version
+ * convergence between hqd and the installed hq-cli, the heartbeat, the Claude
+ * and Codex MCP registrations, and the hq-* skill links. Every line is PASS,
+ * WARN or FAIL with a remediation command. When anywhere was never installed
+ * on this machine the family reports a single NA line.
+ */
+import type { CheckContext, CheckFamily, CheckResult } from "../types.js";
+export declare const ANYWHERE_FAMILY_ID = "anywhere";
+export declare const REMEDIATION: {
+    readonly installClaude: "hq install --global --runtime claude";
+    readonly installCodex: "hq install --global --runtime codex";
+    readonly daemonInstall: "hq daemon install";
+    readonly daemonRestart: "hq daemon restart --daemon";
+    readonly link: "hq link <repo-dir> <company>";
+};
+export interface DaemonServiceState {
+    installed: boolean;
+    loaded: boolean;
+    detail: string;
+}
+export interface AnywhereDeps {
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    /** Version hqd reports; rejects when the socket is unreachable. */
+    ping?: () => Promise<string>;
+    /** The hq-cli version installed on this machine. Default: this CLI's version. */
+    cliVersion?: string;
+    serviceState?: () => DaemonServiceState;
+    now?: () => Date;
+}
+export declare function createAnywhereFamily(deps?: AnywhereDeps): CheckFamily;
+export declare const anywhereFamily: CheckFamily;
+export declare function runAnywhereChecks(_context: CheckContext, deps?: AnywhereDeps): Promise<CheckResult[]>;
+//# sourceMappingURL=anywhere.d.ts.map

package/dist/lib/doctor/checks/anywhere.js

@@ -0,0 +1,182 @@
+/**
+ * `hq doctor` anywhere family (hq-anywhere US-012).
+ *
+ * Checks the pieces that let a session in any repo pick up HQ: the ~/.hq/root
+ * pointer, the repo registry, the hqd daemon service and socket, version
+ * convergence between hqd and the installed hq-cli, the heartbeat, the Claude
+ * and Codex MCP registrations, and the hq-* skill links. Every line is PASS,
+ * WARN or FAIL with a remediation command. When anywhere was never installed
+ * on this machine the family reports a single NA line.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { CLI_VERSION } from "../../../cli-version.js";
+import { computeMcpStatus } from "../../../commands/mcp-status.js";
+import { HQ_MCP_SERVER_NAME, SKILL_LINK_PREFIX, claudeTargets } from "../../install/claude-targets.js";
+import { codexTargets } from "../../install/codex-targets.js";
+import { pingHqdVersion } from "../../daemon/convergence.js";
+import { daemonPresenceLabel, heartbeatFile, readHeartbeat } from "../../daemon/heartbeat.js";
+import { DAEMON_LAUNCHD_LABEL, DAEMON_SYSTEMD_UNIT, DAEMON_WINDOWS_TASK } from "../../daemon/install.js";
+import { hqdSocketPath } from "../../daemon/protocol.js";
+import { readRegistry, registryDir, registryFile } from "../../registry/registry.js";
+export const ANYWHERE_FAMILY_ID = "anywhere";
+export const REMEDIATION = {
+    installClaude: "hq install --global --runtime claude",
+    installCodex: "hq install --global --runtime codex",
+    daemonInstall: "hq daemon install",
+    daemonRestart: "hq daemon restart --daemon",
+    link: "hq link <repo-dir> <company>",
+};
+export function createAnywhereFamily(deps = {}) {
+    return { id: ANYWHERE_FAMILY_ID, title: "HQ anywhere runtime", run: (context) => runAnywhereChecks(context, deps) };
+}
+export const anywhereFamily = createAnywhereFamily();
+function result(status, checkId, message, remediation, target) {
+    return { status, checkId: `anywhere.${checkId}`, message, ...(remediation ? { remediation } : {}), ...(target ? { target } : {}) };
+}
+export async function runAnywhereChecks(_context, deps = {}) {
+    const home = deps.home ?? os.homedir();
+    const env = deps.env ?? process.env;
+    const claude = claudeTargets(home);
+    const codex = codexTargets(home);
+    const installed = [claude.hqPointer, claude.stateFile, codex.stateFile].some((p) => fs.existsSync(p));
+    if (!installed) {
+        return [result("NA", "installed", "HQ anywhere is not installed on this machine", REMEDIATION.installClaude)];
+    }
+    const out = [];
+    out.push(checkPointer(claude.hqPointer));
+    out.push(checkRegistry(registryFile(registryDir(home, env))));
+    const service = (deps.serviceState ?? (() => defaultServiceState(home)))();
+    if (!service.installed)
+        out.push(result("FAIL", "daemon-installed", `daemon service is not installed (${service.detail})`, REMEDIATION.daemonInstall));
+    else if (!service.loaded)
+        out.push(result("FAIL", "daemon-installed", `daemon service is installed but not loaded (${service.detail})`, REMEDIATION.daemonRestart));
+    else
+        out.push(result("PASS", "daemon-installed", `daemon service is installed and loaded (${service.detail})`));
+    const socketPath = hqdSocketPath(home, env);
+    const ping = deps.ping ?? (() => pingHqdVersion(socketPath, 2_000));
+    let running = null;
+    try {
+        running = await ping();
+        out.push(result("PASS", "socket", `hqd answered on ${socketPath}`, undefined, socketPath));
+    }
+    catch (err) {
+        out.push(result("FAIL", "socket", `hqd is not reachable: ${err instanceof Error ? err.message : String(err)}`, REMEDIATION.daemonInstall, socketPath));
+    }
+    const cliVersion = deps.cliVersion ?? CLI_VERSION;
+    if (running === null)
+        out.push(result("FAIL", "version", `cannot compare versions: hqd did not answer (hq-cli is ${cliVersion})`, REMEDIATION.daemonInstall));
+    else if (running !== cliVersion)
+        out.push(result("FAIL", "version", `hqd runs ${running} but hq-cli ${cliVersion} is installed`, REMEDIATION.daemonRestart));
+    else
+        out.push(result("PASS", "version", `hqd and hq-cli both run ${cliVersion}`));
+    out.push(checkHeartbeat(heartbeatFile(home, env), (deps.now ?? (() => new Date()))()));
+    const mcp = computeMcpStatus({ home });
+    const server = mcp.servers.find((s) => s.server === HQ_MCP_SERVER_NAME);
+    out.push(checkRegistration("claude", server?.claude, mcp.runtimes.claude, REMEDIATION.installClaude));
+    out.push(checkRegistration("codex", server?.codex, mcp.runtimes.codex, REMEDIATION.installCodex));
+    out.push(checkSkillLinks("claude", claude.skillsDir, REMEDIATION.installClaude));
+    if (mcp.runtimes.codex.installed)
+        out.push(checkSkillLinks("codex", codex.skillsDir, REMEDIATION.installCodex));
+    return out;
+}
+function checkPointer(file) {
+    let root;
+    try {
+        root = fs.readFileSync(file, "utf8").trim();
+    }
+    catch {
+        return result("FAIL", "pointer", `${file} is missing`, REMEDIATION.installClaude, file);
+    }
+    const valid = root && path.isAbsolute(root) && [".claude", "core"].every((m) => fs.existsSync(path.join(root, m)));
+    if (!valid)
+        return result("FAIL", "pointer", `${file} points at ${root || "(empty)"}, which is not an HQ root`, REMEDIATION.installClaude, file);
+    return result("PASS", "pointer", `${file} points at ${root}`, undefined, file);
+}
+function checkRegistry(file) {
+    if (!fs.existsSync(file))
+        return result("WARN", "registry", `${file} does not exist yet; no repos are linked`, REMEDIATION.link, file);
+    try {
+        const registry = readRegistry(file);
+        const count = Object.keys(registry.entries).length;
+        return result("PASS", "registry", `${file} is readable (${count} entries)`, undefined, file);
+    }
+    catch (err) {
+        return result("FAIL", "registry", `${file} is unreadable: ${err.message}`, `mv ${file} ${file}.bad && ${REMEDIATION.installClaude}`, file);
+    }
+}
+function checkHeartbeat(file, now) {
+    let state;
+    try {
+        state = readHeartbeat(file);
+    }
+    catch (err) {
+        return result("FAIL", "heartbeat", `heartbeat record is unreadable: ${err.message}`, REMEDIATION.daemonRestart, file);
+    }
+    if (!state)
+        return result("WARN", "heartbeat", "no hqd heartbeat recorded yet", REMEDIATION.daemonRestart, file);
+    if (daemonPresenceLabel(state, now) !== "daemon live")
+        return result("WARN", "heartbeat", `daemon stale: last heartbeat at ${state.at}`, REMEDIATION.daemonRestart, file);
+    return result("PASS", "heartbeat", `last heartbeat at ${state.at} (hqd ${state.version}, ${state.sessions} sessions)`, undefined, file);
+}
+function checkRegistration(runtimeName, status, runtimeState, fix) {
+    const id = `${runtimeName}-registration`;
+    if (!runtimeState.installed)
+        return result("WARN", id, `${runtimeName} is not installed, so hq is not registered there`, fix);
+    if (!runtimeState.parses)
+        return result("FAIL", id, `${runtimeName} MCP config cannot be parsed`, fix);
+    if (!status || status.presence === "absent" || status.presence === "not-installed")
+        return result("WARN", id, `the hq MCP server is not registered in ${runtimeName}`, fix);
+    if (status.presence === "unparseable")
+        return result("FAIL", id, `${runtimeName} MCP config cannot be parsed`, fix);
+    if (!status.healthy)
+        return result("FAIL", id, `${runtimeName} hq MCP entry does not use absolute paths that exist (${status.target ?? ""})`, fix);
+    return result("PASS", id, `hq MCP server registered in ${runtimeName} with absolute paths`);
+}
+function checkSkillLinks(runtime, dir, fix) {
+    const id = `${runtime}-skills`;
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((n) => n.startsWith(SKILL_LINK_PREFIX));
+    }
+    catch {
+        return result("WARN", id, `${dir} does not exist`, fix, dir);
+    }
+    const links = names.filter((n) => fs.lstatSync(path.join(dir, n)).isSymbolicLink());
+    if (links.length === 0)
+        return result("WARN", id, `no hq-* skill links in ${dir}`, fix, dir);
+    const broken = links.filter((n) => !fs.existsSync(path.join(dir, n)));
+    if (broken.length > 0)
+        return result("FAIL", id, `${broken.length} broken skill links in ${dir}: ${broken.slice(0, 5).join(", ")}`, fix, dir);
+    return result("PASS", id, `${links.length} hq-* skill links in ${dir} resolve`, undefined, dir);
+}
+function defaultServiceState(home) {
+    if (process.platform === "darwin") {
+        const plist = path.join(home, "Library", "LaunchAgents", `${DAEMON_LAUNCHD_LABEL}.plist`);
+        if (!fs.existsSync(plist))
+            return { installed: false, loaded: false, detail: `no ${plist}` };
+        const uid = process.getuid?.() ?? 0;
+        const probe = spawnSync("launchctl", ["print", `gui/${uid}/${DAEMON_LAUNCHD_LABEL}`], { encoding: "utf8", timeout: 5_000 });
+        return { installed: true, loaded: probe.status === 0, detail: `launchd ${DAEMON_LAUNCHD_LABEL}` };
+    }
+    if (process.platform === "linux") {
+        const unit = path.join(home, ".config", "systemd", "user", DAEMON_SYSTEMD_UNIT);
+        const systemUnit = path.join("/etc/systemd/system", DAEMON_SYSTEMD_UNIT);
+        if (!fs.existsSync(unit) && !fs.existsSync(systemUnit))
+            return { installed: false, loaded: false, detail: `no ${DAEMON_SYSTEMD_UNIT}` };
+        const systemScope = fs.existsSync(systemUnit);
+        const probe = spawnSync("systemctl", [...(systemScope ? [] : ["--user"]), "is-active", DAEMON_SYSTEMD_UNIT], { encoding: "utf8", timeout: 5_000 });
+        return { installed: true, loaded: probe.status === 0, detail: `systemd ${systemScope ? "system" : "user"} ${DAEMON_SYSTEMD_UNIT}` };
+    }
+    if (process.platform === "win32") {
+        const probe = spawnSync("schtasks.exe", ["/Query", "/TN", DAEMON_WINDOWS_TASK, "/FO", "CSV", "/NH"], { encoding: "utf8", timeout: 5_000 });
+        if (probe.status !== 0)
+            return { installed: false, loaded: false, detail: `no Scheduled Task ${DAEMON_WINDOWS_TASK}` };
+        const loaded = /,\s*"?Running"?\s*$/i.test(probe.stdout.trim());
+        return { installed: true, loaded, detail: `Scheduled Task ${DAEMON_WINDOWS_TASK}${loaded ? " is running" : " is not running"}` };
+    }
+    return { installed: false, loaded: false, detail: `${process.platform}: service probe not available` };
+}
+//# sourceMappingURL=anywhere.js.map

package/dist/lib/doctor/registry.js

@@ -23,9 +23,11 @@ import { integrationsFamily } from "./checks/integrations.js";
 import { syncHealthFamily } from "./checks/sync-health.js";
 import { workContextFamily } from "./checks/work-context.js";
 import { botsFamily } from "./checks/bots.js";
+import { anywhereFamily } from "./checks/anywhere.js";
 import { scaffoldCliFloorFamily } from "./checks/scaffold-cli-floor.js";
 import { fixtureCoverageFamily } from "./fixtures/discover.js";
 import { checkClaudeWiring } from "./checks/claude-wiring.js";
+import { anywhereRuntimeEnabled } from "../../commands/anywhere-runtime-flag.js";
 /**
  * An ordered, id-keyed set of check families. Registration order is preserved
  * (Map iteration order), and re-registering an id replaces the family in place
@@ -262,6 +264,10 @@ export function createDefaultRegistry() {
     // Local bots: inbox/heartbeat reachability and a LaunchAgent whose hq
     // path survived an HQ toolchain move. Local-only reads.
     registry.register(botsFamily);
+    // HQ anywhere (US-012): pointer, registry, hqd service/socket/version,
+    // heartbeat, MCP registrations and skill links. NA when not installed.
+    if (anywhereRuntimeEnabled())
+        registry.register(anywhereFamily);
     return registry;
 }
 //# sourceMappingURL=registry.js.map

package/dist/lib/first-sync-next-step.d.ts

@@ -12,7 +12,15 @@ export declare function shouldConfirmFirstWorkBearingSync(input: {
     alreadyCompleted: boolean;
     workBearing: boolean;
 }): boolean;
-export declare function isWorkBearingSyncResult(result: Record<string, unknown>): boolean;
+interface WorkBearingSyncResult {
+    aborted?: unknown;
+    filesUploaded?: unknown;
+    filesDownloaded?: unknown;
+    sessionLogUploadedCount?: unknown;
+    filesDeleted?: unknown;
+    tombstonedCount?: unknown;
+}
+export declare function isWorkBearingSyncResult(result: WorkBearingSyncResult): boolean;
 export declare function isHumanInteractiveCliSession(input: {
     stdoutIsTTY: boolean;
     argv: readonly string[];
@@ -31,4 +39,5 @@ export declare function maybeShowFirstSyncNextStep(): boolean;
 export declare function recordFirstWorkBearingSync(result: Record<string, unknown>): boolean;
 /** Drain outcomes once so each shown/followed event is sent at most once per run. */
 export declare function takeFirstSyncStepOutcomes(): FirstSyncStepOutcome[];
+export {};
 //# sourceMappingURL=first-sync-next-step.d.ts.map