@indigoai-us/hq-cli 5.273.0-alpha.0 → 5.273.0

package/dist/lib/daemon/run.js

@@ -16,7 +16,7 @@ import { agentKitPaths } from "../agent-kit/paths.js";
 import { readBotConfig } from "../bot/config.js";
 import { botsRoot } from "../bot/paths.js";
 import { CLAUDE_RUNNER_SCRIPT, CODEX_RUNNER_SCRIPT, enabledServices, planUnits } from "./catalog.js";
-import { effectiveSyncOwner, readDaemonConfig } from "./config.js";
+import { readDaemonConfig } from "./config.js";
 import { findLegacyUnits, legacyOwnerLookup } from "./legacy.js";
 import { readLegacySyncEnv } from "./legacy-sync-env.js";
 import { acquireDaemonLock, releaseDaemonLock } from "./lock.js";
@@ -26,7 +26,6 @@ import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from
 import { takeControlRequests } from "./requests.js";
 import { currentHqCloud, hqCloudRunners } from "./hq-cloud.js";
 import { runnerSessionName } from "./remote-control.js";
-import { listSyncRunnerProcesses, readWatchRunnerOwnerStatus, syncHeartbeatTimeoutMs, syncRunnerNodeOptions, watchRunnerOwnerStatusPath, } from "./sync-runner.js";
 import { STOP_ESCALATION_MS, createSupervisor } from "./supervisor.js";
 import { userToolDirs } from "./tools.js";
 export const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
@@ -214,10 +213,7 @@ function makeLogger(paths, foreground) {
  * an on-failure unit down. The daemon's updater handles CLI updates.
  */
 export function unitProcessEnv(base, unit) {
-    const env = { ...base, ...unit.env, HQ_DAEMON_UNIT: unit.id, HQ_NO_UPDATE_CHECK: "1" };
-    if (unit.service === "sync")
-        env.NODE_OPTIONS = syncRunnerNodeOptions(env);
-    return env;
+    return { ...base, ...unit.env, HQ_DAEMON_UNIT: unit.id, HQ_NO_UPDATE_CHECK: "1" };
 }
 export async function runDaemon(opts) {
     const env = opts.env ?? process.env;
@@ -262,11 +258,10 @@ export async function runDaemon(opts) {
         return legacyCache.units;
     };
     let warnedMissingPin = null;
-    const daemonSyncRunnerPids = new Set();
     const plan = () => {
         const config = readDaemonConfig(paths.configPath);
         const legacy = legacyUnits();
-        const configured = config.hqRoot ?? (env.HQ_ROOT?.trim() || undefined);
+        const configured = config.hqRoot ?? env.HQ_ROOT?.trim() ?? undefined;
         const hqRoot = configured && fs.existsSync(configured) ? configured : undefined;
         // Re-picked every reconcile, so a newer hq-cloud from the updater is used as soon as it lands.
         const hqCloud = currentHqCloud(paths.root);
@@ -278,33 +273,7 @@ export async function runDaemon(opts) {
             }
         }
         const runners = hqCloud ? hqCloudRunners(hqCloud.root) : { syncRunner: null, heartbeat: null, sessionHost: null };
-        const services = enabledServices(machineType, config);
-        const isSignedIn = signedIn(env, home, log);
-        const syncOwner = effectiveSyncOwner(config, machineType);
-        let syncRunnerProcesses = [];
-        let syncRunnerOwnerPid = null;
-        if (machineType === "desktop" &&
-            syncOwner === "daemon" &&
-            services.includes("sync") &&
-            !config.syncPaused &&
-            hqRoot &&
-            isSignedIn) {
-            const processList = listSyncRunnerProcesses(platform);
-            if (!processList.ok) {
-                syncRunnerProcesses = null;
-                log("warn", `${processList.error}; sync will wait before taking ownership`);
-            }
-            else {
-                syncRunnerProcesses = processList.processes;
-                try {
-                    syncRunnerOwnerPid = readWatchRunnerOwnerStatus(watchRunnerOwnerStatusPath(hqRoot, home, env))?.pid ?? null;
-                }
-                catch (error) {
-                    log("warn", `could not verify the sync watch-owner status: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        return planUnits(services, {
+        return planUnits(enabledServices(machineType, config), {
             machineType,
             platform,
             home,
@@ -313,20 +282,14 @@ export async function runDaemon(opts) {
             heartbeatRunnerPath: runners.heartbeat,
             sessionHostRunnerPath: runners.sessionHost,
             legacySyncEnv: readLegacySyncEnv(platform),
-            signedIn: isSignedIn,
+            signedIn: signedIn(env, home, log),
             kitConfigured: fs.existsSync(agentKitPaths(home, env).kitConfigPath),
-            syncPaused: config.syncPaused === true,
-            syncOwner,
             desktopAppManagesSync: desktopAppManagesSync({
                 machineType,
                 host: opts.host,
                 legacy,
                 appRunning: () => desktopAppRunning(platform),
             }),
-            syncRunnerProcesses,
-            syncRunnerOwnerPid,
-            daemonSyncRunnerPids,
-            syncHeartbeatTimeoutMs: syncHeartbeatTimeoutMs(env),
             bots: listLocalBots(),
             legacyOwner: legacyOwnerLookup(legacy),
             cliSelfUpdatable: updatable,
@@ -348,27 +311,20 @@ export async function runDaemon(opts) {
             : command.type === "node"
                 ? [opts.nodeBinary, [command.script, ...command.args]]
                 : [command.file, command.args];
-        const logPath = paths.unitLogPath(unit.id);
-        const logFd = openPrivateAppend(logPath);
-        const logStream = fs.createWriteStream(logPath, { fd: logFd, autoClose: true });
-        logStream.on("error", (err) => log("error", `could not write ${unit.id} log ${logPath}: ${err.message}`));
-        const cwd = unit.env.HQ_ROOT && fs.existsSync(unit.env.HQ_ROOT) ? unit.env.HQ_ROOT : home;
-        const child = spawn(file, args, {
-            cwd,
-            env: unitProcessEnv(env, unit),
-            stdio: ["ignore", "pipe", "pipe"],
-            windowsHide: true,
-        });
-        if (unit.service === "sync" && child.pid !== undefined)
-            daemonSyncRunnerPids.add(child.pid);
-        child.stdout?.pipe(logStream, { end: false });
-        child.stderr?.pipe(logStream, { end: false });
-        child.on("close", () => {
-            if (child.pid !== undefined)
-                daemonSyncRunnerPids.delete(child.pid);
-            logStream.end();
-        });
-        return child;
+        const fd = openPrivateAppend(paths.unitLogPath(unit.id));
+        try {
+            const cwd = unit.env.HQ_ROOT && fs.existsSync(unit.env.HQ_ROOT) ? unit.env.HQ_ROOT : home;
+            const child = spawn(file, args, {
+                cwd,
+                env: unitProcessEnv(env, unit),
+                stdio: ["ignore", fd, fd],
+                windowsHide: true,
+            });
+            return child;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
     };
     // Set once the shutdown path exists below; a restart request before then is dropped.
     let restartDaemon = () => { };
@@ -390,21 +346,6 @@ export async function runDaemon(opts) {
         restartDaemon: () => restartDaemon(),
         writeState: (state) => writeJsonAtomic(paths.statePath, state),
         log,
-        syncOwnerBlockReason: () => {
-            const config = readDaemonConfig(paths.configPath);
-            const hqRoot = config.hqRoot ?? env.HQ_ROOT?.trim();
-            if (!hqRoot)
-                return undefined;
-            const statusPath = watchRunnerOwnerStatusPath(hqRoot, home, env);
-            try {
-                const owner = readWatchRunnerOwnerStatus(statusPath);
-                return owner ? `sync owned by ${owner.owner} pid ${owner.pid}` : undefined;
-            }
-            catch (err) {
-                log("error", `could not read sync owner status at ${statusPath}: ${err instanceof Error ? err.message : String(err)}`);
-                return undefined;
-            }
-        },
     });
     return await new Promise((resolve) => {
         let stopping = false;

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

@@ -20,16 +20,12 @@
 import type { UnitPlan } from "./catalog.js";
 import type { MachineType } from "./machine-type.js";
 import type { ControlRequest } from "./requests.js";
-import { syncPassResult } from "./sync-runner.js";
 export declare const BACKOFF_BASE_MS = 1000;
 export declare const BACKOFF_MAX_MS = 60000;
 export declare const HEALTHY_RUN_MS = 60000;
 export declare const STOP_ESCALATION_MS = 10000;
 export interface SupervisedChild {
     pid?: number;
-    stdout?: {
-        on(event: "data" | "end", handler: (chunk?: Buffer | string) => void): unknown;
-    };
     on(event: "exit", handler: (code: number | null, signal: string | null) => void): unknown;
     on(event: "error", handler: (err: Error) => void): unknown;
     kill(signal?: NodeJS.Signals | number): boolean;
@@ -53,8 +49,6 @@ export interface UnitState {
     lastRunAt?: number;
     nextRunAt?: number;
     lastResult?: "ok" | "failed";
-    lastHeartbeatAt?: string;
-    lastPassResult?: ReturnType<typeof syncPassResult>;
 }
 /** An app that runs the daemon as its own child process instead of an OS unit. */
 export type HostApp = "desktop";
@@ -85,8 +79,6 @@ export interface SupervisorDeps {
     clearTimeout?: (handle: unknown) => void;
     reconcileMs?: number;
     requestPollMs?: number;
-    /** Read hq-cloud's lease status after it exits with the lease-conflict code. */
-    syncOwnerBlockReason?: () => string | undefined;
 }
 export interface Supervisor {
     start(): void;

package/dist/lib/daemon/supervisor.js

@@ -17,8 +17,6 @@
  *
  * Processes, time, and state output are injected; `run.ts` wires the real ones.
  */
-import { StringDecoder } from "node:string_decoder";
-import { SYNC_RUNNER_LEASE_CONFLICT_EXIT, SYNC_RUNNER_LEASE_RETRY_MS, parseSyncRunnerProtocolLine, syncPassResult, } from "./sync-runner.js";
 export const BACKOFF_BASE_MS = 1_000;
 export const BACKOFF_MAX_MS = 60_000;
 export const HEALTHY_RUN_MS = 60_000;
@@ -27,15 +25,7 @@ export function backoffMs(attempt) {
     return Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** Math.max(0, attempt));
 }
 function planKey(plan) {
-    return JSON.stringify([
-        plan.kind,
-        plan.restart,
-        plan.intervalSec,
-        plan.initialDelaySec,
-        plan.heartbeatTimeoutMs,
-        plan.command,
-        plan.env,
-    ]);
+    return JSON.stringify([plan.kind, plan.restart, plan.intervalSec, plan.initialDelaySec, plan.command, plan.env]);
 }
 function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
@@ -78,11 +68,6 @@ export function createSupervisor(deps) {
             clearT(slot.timer);
         slot.timer = undefined;
     };
-    const clearHeartbeatTimer = (slot) => {
-        if (slot.heartbeatTimer !== undefined)
-            clearT(slot.heartbeatTimer);
-        slot.heartbeatTimer = undefined;
-    };
     const setBlocked = (slot) => {
         const block = slot.plan.blocked;
         slot.state.status = block.state;
@@ -93,7 +78,6 @@ export function createSupervisor(deps) {
     /** Stop the slot's child (if any), then run `then` once it has exited. */
     const terminate = (slot, then) => {
         clearTimer(slot);
-        clearHeartbeatTimer(slot);
         const child = slot.child;
         if (!child) {
             then?.();
@@ -138,69 +122,6 @@ export function createSupervisor(deps) {
     const watch = (slot, child) => {
         live.add(child);
         let ended = false;
-        const timeoutMs = slot.plan.heartbeatTimeoutMs;
-        const decoder = timeoutMs ? new StringDecoder("utf8") : null;
-        let stdoutRemainder = "";
-        let lastHeartbeatPersistedAt = now() - 15_000;
-        const armHeartbeatWatchdog = () => {
-            if (!timeoutMs)
-                return;
-            clearHeartbeatTimer(slot);
-            slot.heartbeatTimer = setT(() => {
-                slot.heartbeatTimer = undefined;
-                if (stopped || slot.child !== child || slot.expectingExit)
-                    return;
-                deps.log("warn", `${slot.plan.id} emitted no sync protocol heartbeat for ${timeoutMs}ms; restarting it`);
-                terminate(slot, () => scheduleRestart(slot));
-                emit();
-            }, timeoutMs);
-        };
-        const acceptProtocolLine = (line) => {
-            let event;
-            try {
-                event = parseSyncRunnerProtocolLine(line);
-            }
-            catch (err) {
-                deps.log("error", `${slot.plan.id} emitted invalid sync protocol output (${Buffer.byteLength(line)} bytes): ${errorMessage(err)}`);
-                return;
-            }
-            if (!event)
-                return;
-            const at = now();
-            slot.state.lastHeartbeatAt = new Date(at).toISOString();
-            const pass = syncPassResult(event, slot.state.lastHeartbeatAt);
-            if (pass)
-                slot.state.lastPassResult = pass;
-            armHeartbeatWatchdog();
-            if (pass || at - lastHeartbeatPersistedAt >= 15_000) {
-                lastHeartbeatPersistedAt = at;
-                emit();
-            }
-        };
-        if (decoder && child.stdout) {
-            child.stdout.on("data", (chunk) => {
-                if (chunk === undefined)
-                    return;
-                stdoutRemainder += decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                let newline = stdoutRemainder.indexOf("\n");
-                while (newline >= 0) {
-                    acceptProtocolLine(stdoutRemainder.slice(0, newline).trim());
-                    stdoutRemainder = stdoutRemainder.slice(newline + 1);
-                    newline = stdoutRemainder.indexOf("\n");
-                }
-                // A malformed or unexpectedly large line is not a heartbeat. Bound
-                // retained data so a broken child cannot grow daemon memory forever.
-                if (Buffer.byteLength(stdoutRemainder) > 1024 * 1024)
-                    stdoutRemainder = "";
-            });
-            child.stdout.on("end", () => {
-                stdoutRemainder += decoder.end();
-                if (stdoutRemainder)
-                    acceptProtocolLine(stdoutRemainder.trim());
-                stdoutRemainder = "";
-            });
-        }
-        armHeartbeatWatchdog();
         const onEnd = (code, signal) => {
             if (ended)
                 return;
@@ -211,7 +132,6 @@ export function createSupervisor(deps) {
             if (slot.child !== child)
                 return;
             slot.child = undefined;
-            clearHeartbeatTimer(slot);
             if (slot.killTimer !== undefined) {
                 clearT(slot.killTimer);
                 slot.killTimer = undefined;
@@ -239,20 +159,6 @@ export function createSupervisor(deps) {
                 emit();
                 return;
             }
-            if (slot.plan.service === "sync" && code === SYNC_RUNNER_LEASE_CONFLICT_EXIT) {
-                const reason = deps.syncOwnerBlockReason?.() ?? "sync owned by another runner";
-                slot.state.status = "waiting";
-                slot.state.reason = reason;
-                slot.state.nextRunAt = now() + SYNC_RUNNER_LEASE_RETRY_MS;
-                deps.log("info", `${reason}; retrying in ${SYNC_RUNNER_LEASE_RETRY_MS}ms`);
-                slot.timer = setT(() => {
-                    slot.timer = undefined;
-                    startLong(slot);
-                    emit();
-                }, SYNC_RUNNER_LEASE_RETRY_MS);
-                emit();
-                return;
-            }
             deps.log("warn", `${slot.plan.id} exited (code=${code ?? "null"} signal=${signal ?? "none"})`);
             if (ranFor >= HEALTHY_RUN_MS)
                 slot.attempts = 0;
@@ -463,11 +369,6 @@ export function createSupervisor(deps) {
         emit();
     };
     const handleRequest = (req) => {
-        if (req.action === "reconcile") {
-            deps.log("info", "reconciling daemon configuration (requested)");
-            reconcile();
-            return;
-        }
         if (req.action === "restart-daemon") {
             deps.log("info", "restarting the daemon (requested)");
             if (deps.restartDaemon)
@@ -574,7 +475,6 @@ export function createSupervisor(deps) {
                 clearT(requestTimer);
             for (const slot of slots.values()) {
                 clearTimer(slot);
-                clearHeartbeatTimer(slot);
                 slot.child = undefined;
                 if (slot.killTimer !== undefined)
                     clearT(slot.killTimer);

package/dist/lib/doctor/checks/scaffold-cli-floor.d.ts

@@ -0,0 +1,7 @@
+import type { CheckContext, CheckFamily, CheckResult } from "../types.js";
+export declare const SCAFFOLD_CLI_FLOOR_FAMILY_ID = "scaffold-cli-floor";
+export declare const SCAFFOLD_CLI_FLOOR_FAMILY_TITLE = "Scaffold CLI compatibility";
+export declare const SCAFFOLD_CLI_FLOOR_CHECK_ID = "scaffold-cli-floor.requires-hq-cli";
+export declare const scaffoldCliFloorFamily: CheckFamily;
+export declare function checkScaffoldCliFloor(context: CheckContext): CheckResult[];
+//# sourceMappingURL=scaffold-cli-floor.d.ts.map

package/dist/lib/doctor/checks/scaffold-cli-floor.js

@@ -0,0 +1,73 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
+import { CLI_VERSION } from "../../../cli-version.js";
+import { compareScaffoldCliFloor } from "../../scaffold-cli-floor.js";
+export const SCAFFOLD_CLI_FLOOR_FAMILY_ID = "scaffold-cli-floor";
+export const SCAFFOLD_CLI_FLOOR_FAMILY_TITLE = "Scaffold CLI compatibility";
+export const SCAFFOLD_CLI_FLOOR_CHECK_ID = "scaffold-cli-floor.requires-hq-cli";
+export const scaffoldCliFloorFamily = {
+    id: SCAFFOLD_CLI_FLOOR_FAMILY_ID,
+    title: SCAFFOLD_CLI_FLOOR_FAMILY_TITLE,
+    run: (context) => Promise.resolve(checkScaffoldCliFloor(context)),
+};
+export function checkScaffoldCliFloor(context) {
+    const coreYamlPath = path.join(context.hqRoot, "core", "core.yaml");
+    if (!fs.existsSync(coreYamlPath)) {
+        return [skipped(coreYamlPath, "core/core.yaml is missing")];
+    }
+    let document;
+    try {
+        document = yaml.load(fs.readFileSync(coreYamlPath, "utf8"));
+    }
+    catch {
+        return [
+            {
+                status: "WARN",
+                checkId: SCAFFOLD_CLI_FLOOR_CHECK_ID,
+                target: coreYamlPath,
+                message: "core/core.yaml could not be parsed, so the hq-cli floor was not checked.",
+            },
+        ];
+    }
+    if (!document || typeof document !== "object" || Array.isArray(document)) {
+        if (document === undefined || document === null) {
+            return [skipped(coreYamlPath, "core/core.yaml does not declare requiresHqCli")];
+        }
+        return [
+            {
+                status: "WARN",
+                checkId: SCAFFOLD_CLI_FLOOR_CHECK_ID,
+                target: coreYamlPath,
+                message: "core/core.yaml is not a mapping, so the hq-cli floor was not checked.",
+            },
+        ];
+    }
+    const required = document.requiresHqCli;
+    const comparison = compareScaffoldCliFloor(required, CLI_VERSION);
+    if (comparison.status === "skip") {
+        return [skipped(coreYamlPath, "core/core.yaml does not declare requiresHqCli")];
+    }
+    return [
+        {
+            status: comparison.status === "pass"
+                ? "PASS"
+                : comparison.status === "fail"
+                    ? "FAIL"
+                    : "WARN",
+            checkId: SCAFFOLD_CLI_FLOOR_CHECK_ID,
+            target: coreYamlPath,
+            message: comparison.message,
+            ...(comparison.remediation ? { remediation: comparison.remediation } : {}),
+        },
+    ];
+}
+function skipped(target, reason) {
+    return {
+        status: "NA",
+        checkId: SCAFFOLD_CLI_FLOOR_CHECK_ID,
+        target,
+        message: `Skipped: ${reason}; no hq-cli floor was checked.`,
+    };
+}
+//# sourceMappingURL=scaffold-cli-floor.js.map

package/dist/lib/doctor/registry.js

@@ -23,6 +23,7 @@ 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 { scaffoldCliFloorFamily } from "./checks/scaffold-cli-floor.js";
 import { fixtureCoverageFamily } from "./fixtures/discover.js";
 import { checkClaudeWiring } from "./checks/claude-wiring.js";
 /**
@@ -236,6 +237,7 @@ function hasCommandHook(settings, event) {
 export function createDefaultRegistry() {
     const registry = new DoctorRegistry();
     registry.register(hooksFamily);
+    registry.register(scaffoldCliFloorFamily);
     // Fixture coverage (US-007): reports UNTESTED for every registered hook with
     // no fixture and prints the tested/total coverage line. A separate family so
     // it needs no change to the hooks tier, per the registry's extensibility