@indigoai-us/hq-cli 5.345.198 → 5.345.200

package/dist/lib/bot/events.js

@@ -0,0 +1,160 @@
+/** Local event journal and durable inbox. Cursor and queued deliveries commit together. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { readLocalJobsStrict, withJobsLock } from "./local-jobs.js";
+/** Rotate journals at five MiB without discarding unread records. */
+export const EVENT_ROTATE_BYTES = 5 * 1024 * 1024;
+export const EVENT_PAYLOAD_BYTES = 16 * 1024;
+const journal = "events.jsonl";
+const stateFile = "events-state.json";
+export function validateEventPayload(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        throw new Error("Event payload must be a JSON object.");
+    if (Buffer.byteLength(JSON.stringify(payload), "utf8") >= EVENT_PAYLOAD_BYTES)
+        throw new Error("Event payload must be under 16 KB.");
+}
+function readState(dir) {
+    try {
+        const state = JSON.parse(fs.readFileSync(path.join(dir, stateFile), "utf8"));
+        if (state.v !== 1 || !state.cursors || !Array.isArray(state.pending))
+            throw new Error("Invalid event state");
+        return state;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return { v: 1, cursors: {}, pending: [] };
+        throw err; // Never reset a corrupt cursor and replay the journal.
+    }
+}
+function writeState(dir, state) {
+    const file = path.join(dir, stateFile);
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function files(dir) {
+    return fs.readdirSync(dir).filter((f) => /^events\.\d+-[a-f0-9-]+\.jsonl$/.test(f)).sort().concat(journal);
+}
+/** A persisted intent makes both sides of the journal rename recoverable. */
+function recoverRotation(dir, state) {
+    if (!state.rotating)
+        return;
+    const archived = state.rotating;
+    if (!fs.existsSync(path.join(dir, archived))) {
+        fs.renameSync(path.join(dir, journal), path.join(dir, archived));
+    }
+    state.cursors[archived] = state.cursors[journal] ?? 0;
+    delete state.cursors[journal];
+    delete state.rotating;
+    writeState(dir, state);
+}
+export function emitBotEvent(dir, event, payload, now = new Date(), alreadyEmitted) {
+    if (!event.trim() || event.length > 256 || /[\r\n]/.test(event))
+        throw new Error("Event name must be 1–256 characters without newlines.");
+    validateEventPayload(payload);
+    const record = { event, at: now.toISOString(), payload };
+    return withJobsLock(dir, () => {
+        const state = readState(dir);
+        recoverRotation(dir, state);
+        // Optional producer idempotency: scan and append under the same lock as
+        // rotation, including archived journals and only fully written lines.
+        if (alreadyEmitted) {
+            for (const name of files(dir)) {
+                const candidate = path.join(dir, name);
+                if (!fs.existsSync(candidate))
+                    continue;
+                const lines = fs.readFileSync(candidate, "utf8").split("\n").slice(0, -1);
+                for (const line of lines.filter(Boolean)) {
+                    const prior = JSON.parse(line);
+                    if (alreadyEmitted(prior))
+                        return prior;
+                }
+            }
+        }
+        const file = path.join(dir, journal);
+        const bytes = fs.existsSync(file) ? fs.readFileSync(file) : Buffer.alloc(0);
+        // A process killed during append may leave an incomplete final line.
+        // It was never accepted as an event: discard it before the next append,
+        // otherwise that next valid record would join it and poison the drain.
+        const size = bytes.length && bytes.at(-1) !== 10 ? bytes.lastIndexOf(10) + 1 : bytes.length;
+        if (size !== bytes.length)
+            fs.truncateSync(file, size);
+        if (size >= EVENT_ROTATE_BYTES) {
+            state.rotating = `events.${Date.now()}-${randomUUID()}.jsonl`;
+            writeState(dir, state);
+            recoverRotation(dir, state);
+        }
+        fs.appendFileSync(file, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+        return record;
+    });
+}
+export function eventMatches(job, record) {
+    return job.trigger?.kind === "event" && job.trigger.event === record.event &&
+        Object.entries(job.trigger.filter ?? {}).every(([key, value]) => {
+            if (!Object.hasOwn(record.payload, key))
+                return false;
+            // JSON objects can shadow toString/valueOf with non-callable fields.
+            // Such a value cannot match a string filter and must not poison the drain.
+            try {
+                return String(record.payload[key]) === value;
+            }
+            catch {
+                return false;
+            }
+        });
+}
+/** Pending items survive a crash between queueing and the next poll. */
+export function drainBotEvents(dir) {
+    return withJobsLock(dir, () => {
+        const state = readState(dir);
+        recoverRotation(dir, state);
+        const jobs = readLocalJobsStrict(dir);
+        for (const name of files(dir)) {
+            const file = path.join(dir, name);
+            if (!fs.existsSync(file))
+                continue;
+            let offset = state.cursors[name] ?? 0;
+            // Consumed archives need only a stat, not a full read on every poll.
+            if (offset === fs.statSync(file).size)
+                continue;
+            const bytes = fs.readFileSync(file);
+            if (offset > bytes.length)
+                throw new Error(`Event journal was truncated: ${name}`);
+            while (offset < bytes.length) {
+                const end = bytes.indexOf(10, offset);
+                if (end < 0)
+                    break; // An interrupted append is never treated as a full event.
+                const record = JSON.parse(bytes.subarray(offset, end).toString("utf8"));
+                validateEventPayload(record.payload);
+                for (const job of jobs.filter((j) => eventMatches(j, record))) {
+                    state.pending.push({
+                        messageId: `localjob-event-${randomUUID()}`, channel: "job", jobId: job.jobId,
+                        prompt: job.prompt, firedAt: record.at, receivedAt: record.at,
+                        context: { ...job.context, payload: record.payload, event: record },
+                    });
+                }
+                offset = end + 1;
+            }
+            state.cursors[name] = offset;
+        }
+        writeState(dir, state);
+        return state.pending;
+    });
+}
+export function ackBotEvent(dir, messageId) {
+    withJobsLock(dir, () => {
+        const state = readState(dir);
+        state.pending = state.pending.filter((item) => item.messageId !== messageId);
+        writeState(dir, state);
+    });
+}
+export function tailBotEvents(dir, predicate = () => true) {
+    return withJobsLock(dir, () => files(dir).flatMap((name) => {
+        const file = path.join(dir, name);
+        if (!fs.existsSync(file))
+            return [];
+        return fs.readFileSync(file, "utf8").split("\n").slice(0, -1).filter(Boolean).map((line) => JSON.parse(line));
+    }).filter(predicate).slice(-50));
+}
+//# sourceMappingURL=events.js.map

package/dist/lib/bot/executive-settings.d.ts

@@ -0,0 +1,10 @@
+import { type BotConfig } from "./config.js";
+export declare function executiveRiderEnabled(home?: string): boolean;
+export declare function isExecutiveBot(config: Pick<BotConfig, "name" | "kind" | "workerId">, home?: string): boolean;
+export declare function executiveStatus(config: Pick<BotConfig, "name" | "kind" | "workerId">, dir: string, home?: string): {
+    is_executive: boolean;
+    rider_enabled: boolean;
+    detect_source_last: string | null;
+    last_detected_at: string | null;
+};
+//# sourceMappingURL=executive-settings.d.ts.map

package/dist/lib/bot/executive-settings.js

@@ -0,0 +1,43 @@
+/** Shared Executive identity and the desktop's default-on rider preference. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { effectiveBotKind } from "./config.js";
+import { tailBotEvents } from "./events.js";
+export function executiveRiderEnabled(home = os.homedir()) {
+    try {
+        const settings = JSON.parse(fs.readFileSync(path.join(home, ".hq/menubar.json"), "utf8"));
+        return settings?.executiveMeetingRider?.enabled !== false;
+    }
+    catch (err) {
+        return err.code === "ENOENT";
+    }
+}
+export function isExecutiveBot(config, home = os.homedir()) {
+    if (effectiveBotKind(config) !== "personal")
+        return false;
+    let name = "setup";
+    try {
+        const value = JSON.parse(fs.readFileSync(path.join(home, ".hq/executive.json"), "utf8"));
+        if (value?.bot != null) {
+            if (typeof value.bot !== "string" || !value.bot.trim())
+                return false;
+            name = value.bot;
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            return false;
+    }
+    return config.name === name;
+}
+export function executiveStatus(config, dir, home = os.homedir()) {
+    const last = tailBotEvents(dir, (event) => event.event === "meeting.detected").at(-1);
+    return {
+        is_executive: isExecutiveBot(config, home), rider_enabled: executiveRiderEnabled(home),
+        // The first desktop producer did not set source.
+        detect_source_last: last ? (last.payload.source === "poll" ? "poll" : "desktop") : null,
+        last_detected_at: last?.at ?? null,
+    };
+}
+//# sourceMappingURL=executive-settings.js.map

package/dist/lib/bot/fleet-cron.js

@@ -169,6 +169,10 @@ export function migrateLegacyJobsToFleet(dir, config, ops, now = new Date()) {
         const skipped = [];
         const moved = new Set();
         for (const job of legacy) {
+            if (job.trigger || !job.cron) {
+                skipped.push(job.jobId);
+                continue;
+            }
             let schedule;
             try {
                 schedule = /^(cron|rate)\(/i.test(job.cron.trim()) ? fleetScheduleFromLegacy(job.cron) : job.cron.trim();

package/dist/lib/bot/fleet-download.d.ts

@@ -0,0 +1,27 @@
+/** A download that receives no bytes for this long is treated as stalled and retried. */
+export declare const FLEET_DOWNLOAD_STALL_MS = 90000;
+/** How many times a stalled or broken download is resumed before giving up. */
+export declare const FLEET_DOWNLOAD_MAX_RESUMES = 5;
+export interface FleetDownloadProgress {
+    name: string;
+    received: number;
+    total: number | null;
+}
+export interface FleetDownloadOptions {
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    stallMs?: number;
+    maxResumes?: number;
+    onProgress?: (progress: FleetDownloadProgress) => void;
+}
+/**
+ * Download `url` into `destination`, writing through `<destination>.part` and
+ * resuming from the bytes already there. Every attempt that receives nothing
+ * for `stallMs` is retried from where it stopped, up to `maxResumes` times.
+ * The file is renamed into place only when the body ended cleanly and, when
+ * the server told us its size, the sizes match.
+ */
+export declare function downloadFleetFile(url: string, destination: string, options?: FleetDownloadOptions): Promise<string>;
+/** sha256 of a file on disk, streamed. */
+export declare function fileSha256(file: string): string;
+//# sourceMappingURL=fleet-download.d.ts.map

package/dist/lib/bot/fleet-download.js

@@ -0,0 +1,162 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** A download that receives no bytes for this long is treated as stalled and retried. */
+export const FLEET_DOWNLOAD_STALL_MS = 90_000;
+/** How many times a stalled or broken download is resumed before giving up. */
+export const FLEET_DOWNLOAD_MAX_RESUMES = 5;
+function expectedError(message) {
+    return Object.assign(new Error(message), { expected: true });
+}
+function partFileSize(file) {
+    try {
+        return fs.statSync(file).size;
+    }
+    catch {
+        return 0;
+    }
+}
+function contentLength(response) {
+    const raw = response.headers.get("content-length");
+    if (!raw)
+        return null;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function contentRangeTotal(response) {
+    const raw = response.headers.get("content-range");
+    const match = raw ? /\/(\d+)\s*$/.exec(raw) : null;
+    if (!match)
+        return null;
+    const value = Number.parseInt(match[1], 10);
+    return Number.isFinite(value) ? value : null;
+}
+async function pumpBody(response, fd, offset, name, total, stallMs, onProgress) {
+    if (!response.body) {
+        const bytes = Buffer.from(await response.arrayBuffer());
+        fs.writeSync(fd, bytes, 0, bytes.length, offset);
+        const received = offset + bytes.length;
+        onProgress?.({ name, received, total });
+        return received;
+    }
+    const reader = response.body.getReader();
+    let received = offset;
+    let lastReport = 0;
+    for (;;) {
+        let timer;
+        const stalled = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(expectedError(`stalled: no data for ${Math.round(stallMs / 1000)}s`)), stallMs);
+        });
+        let chunk;
+        try {
+            chunk = await Promise.race([reader.read(), stalled]);
+        }
+        catch (error) {
+            void reader.cancel().catch(() => undefined);
+            throw error;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+        if (chunk.done)
+            break;
+        fs.writeSync(fd, chunk.value, 0, chunk.value.length, received);
+        received += chunk.value.length;
+        const now = Date.now();
+        if (now - lastReport >= 250 || (total !== null && received >= total)) {
+            lastReport = now;
+            onProgress?.({ name, received, total });
+        }
+    }
+    onProgress?.({ name, received, total });
+    return received;
+}
+/**
+ * Download `url` into `destination`, writing through `<destination>.part` and
+ * resuming from the bytes already there. Every attempt that receives nothing
+ * for `stallMs` is retried from where it stopped, up to `maxResumes` times.
+ * The file is renamed into place only when the body ended cleanly and, when
+ * the server told us its size, the sizes match.
+ */
+export async function downloadFleetFile(url, destination, options = {}) {
+    const fetcher = options.fetch ?? fetch;
+    const stallMs = options.stallMs ?? FLEET_DOWNLOAD_STALL_MS;
+    const maxResumes = options.maxResumes ?? FLEET_DOWNLOAD_MAX_RESUMES;
+    const name = path.basename(destination);
+    const part = `${destination}.part`;
+    fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+    let lastFailure = null;
+    for (let attempt = 0; attempt <= maxResumes; attempt += 1) {
+        const have = partFileSize(part);
+        const headers = { ...options.headers };
+        if (have > 0)
+            headers.Range = `bytes=${have}-`;
+        let response;
+        try {
+            response = await (Object.keys(headers).length > 0 ? fetcher(url, { headers }) : fetcher(url));
+        }
+        catch (error) {
+            lastFailure = error;
+            continue;
+        }
+        let offset = have;
+        let total;
+        if (response.status === 206 && have > 0) {
+            total = contentRangeTotal(response) ?? (contentLength(response) !== null ? have + contentLength(response) : null);
+        }
+        else if (response.status === 416 && have > 0) {
+            void response.body?.cancel().catch(() => undefined);
+            fs.renameSync(part, destination);
+            return destination;
+        }
+        else if (response.ok) {
+            offset = 0;
+            total = contentLength(response);
+        }
+        else {
+            void response.body?.cancel().catch(() => undefined);
+            throw expectedError(`Could not download ${name}: HQ storage returned HTTP ${response.status}.`);
+        }
+        const fd = fs.openSync(part, offset === 0 ? "w" : "r+", 0o600);
+        let received;
+        try {
+            received = await pumpBody(response, fd, offset, name, total, stallMs, options.onProgress);
+        }
+        catch (error) {
+            fs.closeSync(fd);
+            lastFailure = error;
+            continue;
+        }
+        fs.closeSync(fd);
+        if (total !== null && received !== total) {
+            if (received > total)
+                fs.rmSync(part, { force: true });
+            lastFailure = expectedError(`ended early at ${received} of ${total} bytes`);
+            continue;
+        }
+        fs.renameSync(part, destination);
+        return destination;
+    }
+    const cause = lastFailure instanceof Error ? lastFailure.message : String(lastFailure ?? "unknown error");
+    throw expectedError(`Could not download ${name} after ${maxResumes + 1} attempts (${cause}). Check your internet connection and retry; the download continues where it stopped.`);
+}
+/** sha256 of a file on disk, streamed. */
+export function fileSha256(file) {
+    const hash = crypto.createHash("sha256");
+    const fd = fs.openSync(file, "r");
+    try {
+        const chunk = Buffer.allocUnsafe(1 << 20);
+        for (;;) {
+            const read = fs.readSync(fd, chunk, 0, chunk.length, null);
+            if (read === 0)
+                break;
+            hash.update(chunk.subarray(0, read));
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return hash.digest("hex");
+}
+//# sourceMappingURL=fleet-download.js.map

package/dist/lib/bot/fleet-local.d.ts

@@ -65,6 +65,9 @@ export interface FleetLocalInstallDeps {
     now?: () => Date;
     release?: FleetLocalReleasePin;
     publicKey?: string | readonly string[];
+    onProgress?: FleetInstallProgressListener;
+    /** How long a download may go without bytes before it is resumed (tests). */
+    downloadStallMs?: number;
 }
 export interface FleetLocalProfileInput {
     agentUid: string;
@@ -113,6 +116,7 @@ export interface FleetLocalBootstrapDeps {
     spawn?: FleetLocalSpawn;
     start?: boolean;
     python?: FleetPython;
+    onProgress?: FleetInstallProgressListener;
 }
 interface SharedFleetRuntime {
     id: string;
@@ -257,9 +261,35 @@ export declare function installTargetFleetLocalDistribution(deps?: Omit<FleetLoc
     target?: FleetLocalTargetRelease;
     now?: () => number;
 }): Promise<FleetLocalInstallation>;
+/** What an install is doing right now, for a progress bar or a log line. */
+export type FleetInstallProgress = {
+    phase: "download";
+    file: string;
+    received: number;
+    total: number | null;
+} | {
+    phase: "verify";
+} | {
+    phase: "python";
+} | {
+    phase: "extract";
+} | {
+    phase: "environment";
+} | {
+    phase: "packages";
+} | {
+    phase: "ready";
+    step: "download" | "runtime";
+    cached: boolean;
+};
+export type FleetInstallProgressListener = (progress: FleetInstallProgress) => void;
 export declare const FLEET_LOCAL_METADATA_DOWNLOAD_TIMEOUT_MS = 30000;
-export declare const FLEET_LOCAL_ARCHIVE_DOWNLOAD_TIMEOUT_MS: number;
-export declare const FLEET_LOCAL_RUNTIME_DOWNLOAD_TIMEOUT_MS: number;
+/** One machine-wide lock: concurrent creates and adopts share one download instead of repeating it. */
+export declare const FLEET_LOCAL_DISTRIBUTION_LOCK_NAME = "hq-fleet-local-distribution";
+export declare const FLEET_LOCAL_DISTRIBUTION_LOCK_WAIT_MS: number;
+export declare const FLEET_LOCAL_DISTRIBUTION_LOCK_STALE_MS: number;
+/** Whether the pinned release is installed on this machine (no download needed). */
+export declare function fleetLocalDistributionInstalled(release?: FleetLocalReleasePin, root?: string): boolean;
 export declare function installPinnedFleetLocalDistribution(deps?: FleetLocalInstallDeps): Promise<FleetLocalInstallation>;
 /** The process id the bot's gateway recorded, when its file reads; the caller checks whether it is alive. */
 export declare function fleetLocalGatewayPid(agentUid: string, deps?: Pick<FleetLocalControlDeps, "fleetHome">): number | null;
@@ -339,6 +369,25 @@ export declare function windowsExtractionPathProblem(destination: string, longes
 export declare function importFleetLocalMachineCredential(agentUid: string, machineCredentials: string, deps?: FleetLocalControlDeps, opts?: {
     keepSource?: boolean;
 }): void;
+export interface FleetRuntimeInstallResult {
+    release: FleetLocalReleasePin;
+    distributionDir: string;
+    runtimeDir: string;
+    runtimeId: string;
+}
+/**
+ * Everything a bot needs that is shared by every bot on this machine: the
+ * pinned distribution and runtime archive, the private Python, and the built
+ * runtime environment. Safe to run any number of times; a complete install
+ * returns at once.
+ */
+export declare function ensureFleetRuntimeInstalled(installation: FleetLocalInstallation, deps?: FleetLocalBootstrapDeps): Promise<FleetRuntimeInstallResult>;
+/** Whether the shared runtime for this release is already built on this machine. */
+export declare function fleetRuntimeReady(installation: Pick<FleetLocalInstallation, "release">, deps?: {
+    fleetHome?: string;
+    platform?: NodeJS.Platform;
+    python?: FleetPython;
+}): boolean;
 export declare function bootstrapFleetLocalBot(input: FleetLocalProfileInput & {
     machineCredentials?: string;
 }, deps?: FleetLocalBootstrapDeps): Promise<FleetLocalBootstrapResult>;