@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/commands/core-repo-run-registry-native.js

@@ -0,0 +1,357 @@
+/** Native, dependency-light port of repo-run-registry.sh. */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
+export const REPO_RUN_REGISTRY_ASSET = "core/scripts/repo-run-registry.sh";
+function jsonOutput(code, value, format = "pretty") {
+    return { code, stdout: value === undefined ? "" : serializeJqJson(value, format), stderr: "" };
+}
+function iso(d) { return d.toISOString().replace(/\.\d{3}Z$/, "Z"); }
+function jqOr(value, fallback) { return value === null || value === undefined || value === false ? fallback : value; }
+function parseNaturalDateEpoch(value) {
+    const result = spawnSync("date", ["-u", "-d", value, "+%s"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    if (result.status !== 0)
+        return 0;
+    const parsed = Number(result.stdout.trim());
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function epoch(value, parseDate) {
+    if (typeof value !== "string")
+        return 0;
+    const isoMatch = value.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/);
+    if (isoMatch) {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed))
+            return Math.floor(parsed / 1000);
+    }
+    return parseDate(value);
+}
+function pathAbs(value, cwd, f) {
+    if (value.startsWith("/"))
+        return value;
+    const parent = path.dirname(value);
+    try {
+        f.statSync(path.resolve(cwd, parent));
+        return path.join(path.resolve(cwd, parent), path.basename(value));
+    }
+    catch {
+        return value;
+    }
+}
+function parseStaleMinutes(root, f) {
+    const personal = path.join(root, "personal/settings/orchestrator.yaml");
+    const core = path.join(root, "core/settings/orchestrator.yaml");
+    const config = f.existsSync(personal) ? personal : core;
+    try {
+        const lines = f.readFileSync(config, "utf8").split(/\r?\n/);
+        let inRepo = false;
+        for (const line of lines) {
+            if (/^repo_coordination\s*:\s*(?:#.*)?$/.test(line)) {
+                inRepo = true;
+                continue;
+            }
+            if (inRepo && /^\S/.test(line))
+                inRepo = false;
+            if (inRepo) {
+                const match = line.match(/^\s+stale_heartbeat_minutes\s*:\s*([^#\s]+)(?:\s+#.*)?$/);
+                if (match) {
+                    const value = match[1].replace(/^(['"])(.*?)\1$/, "$2");
+                    if (value === "null" || value === "~")
+                        return 15;
+                    const n = Number(value);
+                    return Number.isFinite(n) ? n : 15;
+                }
+            }
+        }
+    }
+    catch { /* shell falls back to 15 when yq or the config is unavailable */ }
+    return 15;
+}
+function defaultSleep(ms) { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); }
+export function runRepoRunRegistry(args, deps) {
+    const f = deps.fs ?? fs, env = deps.env ?? process.env, now = deps.now ?? (() => new Date());
+    const pid = deps.pid ?? process.pid, sleep = deps.sleep ?? defaultSleep;
+    const root = deps.root || env.HQ_ROOT || process.cwd();
+    const regDir = path.join(root, "workspace/orchestrator"), regFile = path.join(regDir, "active-runs.json"), lockDir = `${regFile}.lock`;
+    const output = (code = 0, stdout = "", stderr = "") => ({ code, stdout, stderr });
+    const die = (message) => output(1, "", `ERROR: ${message}\n`);
+    const readState = () => {
+        try {
+            const parsed = JSON.parse(f.readFileSync(regFile, "utf8"));
+            return parsed && typeof parsed === "object" ? parsed : { version: 1, runs: [] };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { version: 1, runs: [] };
+            return null;
+        }
+    };
+    const ensureReg = () => {
+        f.mkdirSync(regDir, { recursive: true });
+        if (!f.existsSync(regFile))
+            f.writeFileSync(regFile, '{"version":1,"runs":[]}\n');
+    };
+    const writeState = (state) => {
+        const tmp = `${regFile}.tmp.${pid}`;
+        f.writeFileSync(tmp, serializeJqJson(state, "pretty"));
+        f.renameSync(tmp, regFile);
+    };
+    const writeEmptyState = () => {
+        const tmp = `${regFile}.tmp.${pid}`;
+        f.writeFileSync(tmp, "");
+        f.renameSync(tmp, regFile);
+    };
+    const lock = () => {
+        try {
+            f.mkdirSync(regDir, { recursive: true });
+        }
+        catch { /* shell ignores parent mkdir failure here */ }
+        for (let tries = 1;; tries += 1) {
+            try {
+                f.mkdirSync(lockDir);
+                return true;
+            }
+            catch {
+                if (tries >= 50) {
+                    if (f.existsSync(lockDir)) {
+                        let mtimeMs = 0;
+                        try {
+                            mtimeMs = f.statSync(lockDir).mtimeMs;
+                        }
+                        catch { /* shell falls back to epoch zero when stat fails */ }
+                        const age = Math.floor(now().getTime() / 1000) - Math.floor(mtimeMs / 1000);
+                        if (age > 60) {
+                            f.rmSync(lockDir, { recursive: true, force: true });
+                            continue;
+                        }
+                    }
+                    return false;
+                }
+                sleep(100);
+            }
+        }
+        return false;
+    };
+    const unlock = () => { try {
+        f.rmSync(lockDir, { recursive: true, force: true });
+    }
+    catch { /* shell ignores unlock failure */ } };
+    const alive = (raw) => {
+        if (raw === "" || raw === null || raw === undefined || raw === false || raw === "null")
+            return false;
+        const value = Number(raw);
+        if (!Number.isFinite(value))
+            return false;
+        try {
+            return deps.isPidAlive ? deps.isPidAlive(value) : (process.kill(value, 0), true);
+        }
+        catch {
+            return false;
+        }
+    };
+    const parseDate = deps.parseDateEpoch ?? parseNaturalDateEpoch;
+    const staleMinutes = parseStaleMinutes(root, f);
+    const prune = () => {
+        ensureReg();
+        const state = readState();
+        if (state === null) {
+            writeEmptyState();
+            return 0;
+        }
+        const runs = Array.isArray(state.runs) ? state.runs : [];
+        const cutoff = Math.floor(now().getTime() / 1000) - staleMinutes * 60;
+        const kept = runs.filter((entry) => alive(entry?.pid) && epoch(jqOr(entry?.heartbeat_at, jqOr(entry?.started_at, "")), parseDate) >= cutoff);
+        state.runs = kept;
+        writeState(state);
+        return runs.length - kept.length;
+    };
+    const withPrune = () => {
+        if (!lock())
+            return;
+        try {
+            prune();
+        }
+        catch { /* _prune_stale_locked suppresses pruning errors */ }
+        finally {
+            unlock();
+        }
+    };
+    const owningRepo = (raw) => {
+        let target = pathAbs(raw, deps.cwd, f);
+        while (target && !f.existsSync(target)) {
+            const parent = path.dirname(target);
+            if (parent === target)
+                return "";
+            target = parent;
+        }
+        let dir = target;
+        try {
+            if (f.statSync(dir).isFile())
+                dir = path.dirname(dir);
+        }
+        catch { /* keep resolved path */ }
+        while (dir !== "/" && dir) {
+            if (f.existsSync(path.join(dir, ".git")))
+                return dir;
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return "";
+    };
+    const valueAfter = (list, key) => { const index = list.indexOf(key); return index >= 0 ? (list[index + 1] ?? "") : ""; };
+    const sub = args[0] ?? "";
+    if (!sub)
+        return die("usage: repo-run-registry.sh <subcommand> [args...]");
+    const rest = args.slice(1);
+    const useShellFallback = () => {
+        if (!deps.runShellFallback)
+            return undefined;
+        if (f.existsSync(regFile)) {
+            try {
+                const state = JSON.parse(f.readFileSync(regFile, "utf8"));
+                if (!state || typeof state !== "object" || !Array.isArray(state.runs))
+                    return deps.runShellFallback(args);
+                if ((sub === "owner-of" || sub === "check") && state.runs.some((run) => typeof run?.scope === "string" && run.scope.startsWith("worktree:"))) {
+                    return deps.runShellFallback(args);
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    return deps.runShellFallback(args);
+            }
+        }
+        if (sub === "register") {
+            const valueFlags = ["--run-id", "--pid", "--session-id", "--command", "--project", "--repo", "--scope", "--host"];
+            if (rest.length > 0 && valueFlags.includes(rest.at(-1)))
+                return deps.runShellFallback(args);
+            const rawPid = valueAfter(rest, "--pid");
+            if (rawPid && (!Number.isFinite(Number(rawPid)) || !/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(rawPid))) {
+                return deps.runShellFallback(args);
+            }
+        }
+        return undefined;
+    };
+    const fallbackResult = useShellFallback();
+    if (fallbackResult)
+        return fallbackResult;
+    try {
+        if (sub === "register") {
+            let runId = valueAfter(rest, "--run-id"), runPid = valueAfter(rest, "--pid"), sessionId = valueAfter(rest, "--session-id"), command = valueAfter(rest, "--command"), project = valueAfter(rest, "--project"), repo = valueAfter(rest, "--repo"), scope = valueAfter(rest, "--scope"), host = valueAfter(rest, "--host");
+            if (!runPid || !command || !repo || !scope)
+                return die("register requires --pid --command --repo --scope");
+            repo = pathAbs(repo, deps.cwd, f);
+            if (!runId)
+                runId = `${command.replaceAll("/", "-")}-${Math.floor(now().getTime() / 1000)}-${project || "none"}-${runPid}`;
+            if (!host)
+                host = (deps.hostname ?? (() => os.hostname().split(".")[0] ?? "unknown"))();
+            if (!lock())
+                return die("registry lock timeout");
+            try {
+                ensureReg();
+                const pruned = prune();
+                const state = readState(), timestamp = iso(now());
+                if (state === null)
+                    return output(0, `${runId}\n`, "");
+                state.runs = (Array.isArray(state.runs) ? state.runs : []).filter((run) => run?.run_id !== runId);
+                state.runs.push({ run_id: runId, pid: Number(runPid), session_id: sessionId, command, project, repo_path: repo, scope, host, started_at: timestamp, heartbeat_at: timestamp });
+                writeState(state);
+                if (pruned > 0)
+                    return output(0, `${runId}\n`, `[repo-run-registry] pruned ${pruned} stale entries\n`);
+            }
+            finally {
+                unlock();
+            }
+            return output(0, `${runId}\n`, "");
+        }
+        if (sub === "deregister") {
+            const runId = valueAfter(rest, "--run-id");
+            if (!runId)
+                return die("deregister requires --run-id");
+            if (!lock())
+                return die("registry lock timeout");
+            try {
+                ensureReg();
+                const state = readState();
+                state.runs = (Array.isArray(state.runs) ? state.runs : []).filter((run) => run?.run_id !== runId);
+                writeState(state);
+            }
+            finally {
+                unlock();
+            }
+            return output();
+        }
+        if (sub === "heartbeat") {
+            const runId = valueAfter(rest, "--run-id");
+            if (!runId)
+                return die("heartbeat requires --run-id");
+            if (!lock())
+                return die("registry lock timeout");
+            try {
+                ensureReg();
+                const state = readState(), timestamp = iso(now());
+                state.runs = (Array.isArray(state.runs) ? state.runs : []).map((run) => run?.run_id === runId ? { ...run, heartbeat_at: timestamp } : run);
+                writeState(state);
+            }
+            finally {
+                unlock();
+            }
+            return output();
+        }
+        if (sub === "list") {
+            ensureReg();
+            withPrune();
+            const state = readState();
+            return state === null ? output() : jsonOutput(0, Array.isArray(state.runs) ? state.runs : []);
+        }
+        if (sub === "clean-stale") {
+            if (!lock())
+                return die("registry lock timeout");
+            try {
+                const count = prune();
+                return output(0, "", count > 0 ? `[repo-run-registry] pruned ${count} stale entries\n` : "");
+            }
+            finally {
+                unlock();
+            }
+        }
+        if (sub === "owner-of" || sub === "check") {
+            const target = valueAfter(rest, sub === "owner-of" ? "--path" : "--target");
+            if (!target)
+                return die(`${sub} requires --${sub === "owner-of" ? "path" : "target"}`);
+            if (sub === "check") {
+                ensureReg();
+                withPrune();
+            }
+            const repo = owningRepo(target);
+            if (!repo)
+                return sub === "owner-of" ? output(0, "\n", "") : output();
+            if (sub === "owner-of") {
+                ensureReg();
+                withPrune();
+            }
+            const state = readState();
+            if (state === null)
+                return output();
+            const absoluteTarget = pathAbs(target, deps.cwd, f), myPid = valueAfter(rest, "--pid") || "0", mySession = valueAfter(rest, "--session-id") || "__none__";
+            const runs = Array.isArray(state.runs) ? state.runs : [];
+            const covers = (run) => (run?.scope === "repo" && run?.repo_path === repo) || (typeof run?.scope === "string" && run.scope.startsWith("worktree:") && absoluteTarget.startsWith(run.scope.slice("worktree:".length)));
+            if (sub === "owner-of")
+                return jsonOutput(0, runs.filter(covers));
+            const owners = runs.filter((run) => covers(run) && String(run?.pid) !== myPid && run?.session_id !== mySession);
+            if (!owners.length)
+                return output();
+            const lines = owners.map((run) => `run_id=${run?.run_id} pid=${run?.pid} command=${run?.command} project=${run?.project} scope=${run?.scope} repo=${run?.repo_path} started=${run?.started_at} heartbeat=${run?.heartbeat_at}`).join("\n") + "\n";
+            return output(2, "", lines);
+        }
+        return die(`unknown subcommand: ${sub}`);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return output(1, "", `${detail}\n`);
+    }
+}
+//# sourceMappingURL=core-repo-run-registry-native.js.map

package/dist/commands/core-resolve-company-command.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+/** Commander registration stays in the full graph; the native resolver is fast-path safe. */
+export declare function registerCoreResolveCompanyNativeCommand(core: Command): void;
+//# sourceMappingURL=core-resolve-company-command.d.ts.map

package/dist/commands/core-resolve-company-command.js

@@ -0,0 +1,42 @@
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { runBundledScript } from "../utils/run-bundled-script.js";
+import { describeCoreCommand } from "./core-command-catalog.js";
+import { coreNativeUtilitiesEnabled } from "./core-native-utilities-flag.js";
+import { RESOLVE_COMPANY_ASSET, resolveCompany } from "./core-resolve-company-native.js";
+/** Commander registration stays in the full graph; the native resolver is fast-path safe. */
+export function registerCoreResolveCompanyNativeCommand(core) {
+    const command = core.command("resolve-company")
+        .description("Resolve the active company for skills and routing")
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .helpOption(false)
+        .argument("[args...]")
+        .action(async (args = [], _options, cmd) => {
+        const operands = cmd.args.length > 0 ? cmd.args : args;
+        if (!await coreNativeUtilitiesEnabled()) {
+            const root = resolveLiveRoot({ hqRoot: core.opts().hqRoot });
+            const { code } = runBundledScript({
+                asset: RESOLVE_COMPANY_ASSET,
+                args: operands,
+                cwd: root,
+                hqRoot: root,
+            });
+            if (code !== 0)
+                process.exit(code);
+            return;
+        }
+        const root = resolveLiveRoot({ hqRoot: core.opts().hqRoot });
+        const result = await resolveCompany(operands, {
+            cwd: process.cwd(),
+            hqRoot: root,
+            stdinIsTty: process.stdin.isTTY === true,
+        });
+        process.stdout.write(result.stdout);
+        if (result.stderr.length)
+            process.stderr.write(result.stderr);
+        if (result.code !== 0)
+            process.exit(result.code);
+    });
+    describeCoreCommand(command, { execution: "native", asset: RESOLVE_COMPANY_ASSET, root: "live" });
+}
+//# sourceMappingURL=core-resolve-company-command.js.map

package/dist/commands/core-resolve-company-native.d.ts

@@ -0,0 +1,28 @@
+import * as fs from "node:fs";
+export declare const RESOLVE_COMPANY_ASSET = "core/scripts/resolve-company.sh";
+export declare const RESOLVE_COMPANY_HELP: string;
+export type ResolveCompanyResult = {
+    code: number;
+    stdout: Buffer;
+    stderr: Buffer;
+};
+type HqResult = {
+    code: number;
+    stdout: string;
+};
+type ResolveCompanyFs = Pick<typeof fs, "readFileSync" | "statSync" | "accessSync">;
+export type ResolveCompanyDependencies = {
+    cwd: string;
+    hqRoot?: string;
+    env?: NodeJS.ProcessEnv;
+    fs?: ResolveCompanyFs;
+    stdin?: string;
+    stdinIsTty?: boolean;
+    spawnHq?: (args: string[], env: NodeJS.ProcessEnv, timeoutMs: number, cwd?: string) => Promise<HqResult>;
+    pid?: number;
+    random?: () => number;
+};
+export declare function resolveCompany(args: readonly string[], dependencies: ResolveCompanyDependencies): Promise<ResolveCompanyResult>;
+export declare function runResolveCompanyFast(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined, _commandName?: string, _hqRootArg?: string, stdinReader?: () => Promise<string>): Promise<number>;
+export {};
+//# sourceMappingURL=core-resolve-company-native.d.ts.map