@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/bot/attachments.d.ts

@@ -1,45 +0,0 @@
-/**
- * Chat attachments for local bot turns (`hq bot run`).
- *
- * A local bot's runtime (claude / codex / grok) runs without the `hq agent
- * mcp` server, so it cannot call `hq_attachment_fetch`. The runner therefore
- * downloads every file named on an inbox item BEFORE the turn, through the
- * same validated path the MCP tool uses (`fetchChatAttachment`: key shape,
- * DM-pair membership, company gate, size cap, private file), with the bot's
- * own machine credentials, into the bot's own directory. The turn text gets a
- * short block naming each file and where it is on disk; a file that could
- * not be fetched gets a one-line reason instead of a path. Doing it in the
- * runner makes it work the same for every runtime.
- */
-import type { VaultObjectDownloader } from "../agent-kit/attachment-download.js";
-import type { InboxAttachment } from "../agent-kit/inbox-state.js";
-export interface TurnAttachment {
-    /** Display name (sanitized file name once saved). */
-    name: string;
-    contentType?: string;
-    sizeBytes?: number;
-    /** Set when the file was saved; absent when `error` is set. */
-    localPath?: string;
-    /** Bounded inline rendering for text-like files. */
-    text?: string;
-    /** How to open a non-text file. */
-    note?: string;
-    /** One-line reason the file was not downloaded. */
-    error?: string;
-}
-/**
- * Download each attachment for one turn. Never throws: a per-file failure is
- * returned as `error` (the caller logs it and shows it to the model), so one
- * bad reference never costs the sender their reply.
- */
-export declare function downloadTurnAttachments(input: {
-    attachments: readonly InboxAttachment[];
-    botEntityUid: string;
-    attachmentsDir: string;
-    /** The bot's own company uids (its server memberships); consulted only for a cmp_ scope. */
-    resolveBotCompanyUids: () => Promise<readonly string[]>;
-    download?: VaultObjectDownloader;
-}): Promise<TurnAttachment[]>;
-/** The plain block appended to the turn text. Empty when there are no files. */
-export declare function attachmentTurnBlock(files: readonly TurnAttachment[]): string;
-//# sourceMappingURL=attachments.d.ts.map

package/dist/lib/bot/attachments.js

@@ -1,89 +0,0 @@
-/**
- * Chat attachments for local bot turns (`hq bot run`).
- *
- * A local bot's runtime (claude / codex / grok) runs without the `hq agent
- * mcp` server, so it cannot call `hq_attachment_fetch`. The runner therefore
- * downloads every file named on an inbox item BEFORE the turn, through the
- * same validated path the MCP tool uses (`fetchChatAttachment`: key shape,
- * DM-pair membership, company gate, size cap, private file), with the bot's
- * own machine credentials, into the bot's own directory. The turn text gets a
- * short block naming each file and where it is on disk; a file that could
- * not be fetched gets a one-line reason instead of a path. Doing it in the
- * runner makes it work the same for every runtime.
- */
-import { fetchChatAttachment, sanitizeAttachmentFileName } from "../agent-kit/mcp/attachments.js";
-function oneLine(s, max = 300) {
-    const flat = s.replace(/\s+/g, " ").trim();
-    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
-}
-/**
- * Download each attachment for one turn. Never throws: a per-file failure is
- * returned as `error` (the caller logs it and shows it to the model), so one
- * bad reference never costs the sender their reply.
- */
-export async function downloadTurnAttachments(input) {
-    const out = [];
-    for (const ref of input.attachments) {
-        const name = sanitizeAttachmentFileName(ref.name || ref.vaultPath.split("/").pop() || "file");
-        const base = {
-            name,
-            ...(ref.contentType ? { contentType: ref.contentType } : {}),
-            ...(typeof ref.sizeBytes === "number" ? { sizeBytes: ref.sizeBytes } : {}),
-        };
-        if (!ref.companyUid) {
-            out.push({ ...base, error: "the message did not say which vault holds this file (no companyUid)" });
-            continue;
-        }
-        if (!input.download) {
-            out.push({ ...base, error: "this bot runner cannot download attachments" });
-            continue;
-        }
-        try {
-            const saved = await fetchChatAttachment({
-                vaultPath: ref.vaultPath,
-                scopeUid: ref.companyUid,
-                ...(ref.name ? { name: ref.name } : {}),
-                ...(ref.contentType ? { contentType: ref.contentType } : {}),
-                botEntityUid: input.botEntityUid,
-                resolveBotCompanyUids: input.resolveBotCompanyUids,
-                attachmentsDir: input.attachmentsDir,
-                download: input.download,
-            });
-            out.push({
-                name: saved.name,
-                ...(saved.contentType ? { contentType: saved.contentType } : {}),
-                sizeBytes: saved.sizeBytes,
-                localPath: saved.localPath,
-                ...(saved.text !== undefined ? { text: saved.text } : {}),
-                ...(saved.note ? { note: saved.note } : {}),
-            });
-        }
-        catch (err) {
-            out.push({ ...base, error: oneLine(err instanceof Error ? err.message : String(err)) });
-        }
-    }
-    return out;
-}
-/** The plain block appended to the turn text. Empty when there are no files. */
-export function attachmentTurnBlock(files) {
-    if (files.length === 0)
-        return "";
-    const lines = [`[Attached files: ${files.length}]`];
-    for (const f of files) {
-        const meta = [f.contentType, typeof f.sizeBytes === "number" ? `${f.sizeBytes} bytes` : undefined].filter(Boolean).join(", ");
-        const head = `- ${f.name}${meta ? ` (${meta})` : ""}`;
-        if (f.error || !f.localPath) {
-            lines.push(`${head}: not downloaded: ${f.error ?? "unknown error"}`);
-            continue;
-        }
-        lines.push(`${head}: saved at ${f.localPath}`);
-        if (f.text !== undefined) {
-            lines.push(`  Contents of ${f.name}:`, `----- begin ${f.name} -----`, f.text, `----- end ${f.name} -----`);
-        }
-        else if (f.note) {
-            lines.push(`  ${f.note.replace(/localPath/g, "the saved file")}`);
-        }
-    }
-    return lines.join("\n");
-}
-//# sourceMappingURL=attachments.js.map

package/dist/lib/bot/cli-update.d.ts

@@ -1,138 +0,0 @@
-/**
- * A resident bot notices that the hq-cli install it was started from has been
- * updated on disk, and restarts itself onto the new code.
- *
- * `hq bot run <name>` loads the CLI once and runs for days. The install under
- * it moves on (the attended self-updater, the `hq daemon` updater, a manual
- * `npm i -g`), but nothing reloaded a running bot: on 2026-09-24 the bot
- * dr-love was still running code from 2026-09-19 while its install had moved
- * to 5.163.0, so a shipped attachment fix never reached it.
- *
- * The watcher re-resolves the entry script the process was launched with
- * (process.argv[1], the same path launchd / systemd / `hq daemon` will launch
- * again) to its package.json on a timer. Once a complete, valid, different
- * version is seen on consecutive checks, the run loop stops taking new inbox
- * items, lets the running turns finish, and exits with
- * CLI_UPDATE_RESTART_EXIT_CODE so its supervisor starts it again on the new
- * code (or, with no supervisor, starts its own replacement first).
- *
- * Convergence (policy hq-self-updater-must-verify-convergence-after-install):
- * the restart is recorded in <botDir>/cli-update.json before the exit. The next
- * process checks the version it actually loaded against that record: a match
- * is logged as converged; a process that came back on the OLD version blocks
- * that target for CLI_UPDATE_NOT_CONVERGED_COOLDOWN_MS instead of restarting
- * again. Restarts are also capped per window, so an install that keeps
- * flipping cannot turn into a restart loop.
- */
-import type { BotLogger } from "./log.js";
-/**
- * Exit code for "restart me onto the updated CLI". Non-zero on purpose: every
- * supervisor a bot runs under restarts only a failed exit — launchd
- * KeepAlive{SuccessfulExit:false}, systemd Restart=on-failure, and the
- * `hq daemon` "on-failure" bot units — while a clean exit 0 (a stopped or
- * disabled bot) stays down. Same value as the daemon's RESTART_EXIT_CODE.
- */
-export declare const CLI_UPDATE_RESTART_EXIT_CODE = 75;
-/** How often the installed package.json is read. */
-export declare const CLI_UPDATE_CHECK_INTERVAL_MS = 60000;
-/** Set to "1" to turn the watcher off (development runs). */
-export declare const CLI_UPDATE_DISABLE_ENV = "HQ_BOT_NO_CLI_UPDATE_RESTART";
-export type InstalledCliRead = {
-    ok: true;
-    version: string;
-    packageRoot: string;
-} | {
-    ok: false;
-    reason: string;
-    packageRoot?: string;
-};
-export interface InstalledCliFs {
-    realpathSync(p: string): string;
-    readFileSync(p: string, encoding: "utf8"): string;
-}
-/**
- * The hq-cli version installed behind `entry`, resolved the way the next launch
- * of the same command line will resolve it: follow the symlinks now (a pnpm or
- * versioned layout moves the link, npm rewrites the directory in place), then
- * walk up to the package.json that names this CLI. Anything short of a
- * readable manifest with a valid semver version is not a version.
- */
-export declare function readInstalledCli(entry: string, io?: InstalledCliFs): InstalledCliRead;
-export interface CliUpdate {
-    from: string;
-    to: string;
-    packageRoot: string;
-}
-interface CliUpdateLedger {
-    v: 1;
-    /** Written just before an update restart; settled by the next process. */
-    pending?: {
-        from: string;
-        to: string;
-        at: string;
-    };
-    /** ISO times of recent update restarts (for the per-window cap). */
-    restarts: string[];
-    /** A target that did not converge, and when it may be tried again. */
-    blocked?: {
-        version: string;
-        until: string;
-    };
-}
-export declare function readCliUpdateLedger(dir: string): CliUpdateLedger;
-/** What the run loop needs from the watcher (injectable in tests). */
-export interface CliUpdateWatch {
-    /** The version of the code this process loaded. */
-    readonly runningVersion: string;
-    /** Settle the previous restart (converged or not) and say what is watched. */
-    startup(log: BotLogger): void;
-    /** A confirmed update to restart onto, or null. Cheap; rate-limits itself. */
-    poll(log: BotLogger): CliUpdate | null;
-    /** Record the restart about to happen, before the process exits. */
-    recordRestart(update: CliUpdate): void;
-}
-export interface CliUpdateWatcherOptions {
-    dir: string;
-    /** The script this process was launched with (process.argv[1]); null = do not watch. */
-    entry: string | null;
-    runningVersion?: string;
-    now?: () => number;
-    read?: (entry: string) => InstalledCliRead;
-    /** True while an installer is provably rewriting the package dir. */
-    rewriteInProgress?: (packageRoot: string) => boolean;
-    checkIntervalMs?: number;
-    confirmations?: number;
-    restartLimit?: number;
-    restartWindowMs?: number;
-    cooldownMs?: number;
-}
-export declare function createCliUpdateWatcher(opts: CliUpdateWatcherOptions): CliUpdateWatch;
-/**
- * Who starts this bot again after it exits.
- *
- * - "hq-daemon": `hq daemon` sets HQ_DAEMON_UNIT=bots:<name> on its children;
- *   the unit is "on-failure" (supervisor.ts).
- * - "launchd": launchd sets XPC_SERVICE_NAME to the job label for every job it
- *   spawns, including LaunchAgents installed before this code existed.
- * - "systemd": the unit `hq-bot-<name>.service` shows up in the process cgroup.
- * - "none": `hq bot start` without a service (Windows, --no-daemon, a Linux
- *   unit never enabled) or a foreground run. Nobody restarts this process.
- */
-export type BotSupervisor = "hq-daemon" | "launchd" | "systemd" | "none";
-export declare function detectBotSupervisor(name: string, opts?: {
-    env?: NodeJS.ProcessEnv;
-    platform?: NodeJS.Platform;
-    readCgroup?: () => string | null;
-}): BotSupervisor;
-/**
- * The last step of an update restart, run after the pid lock is released and
- * just before the exit. A supervised bot only has to exit; an unsupervised one
- * starts its replacement on the same entry script (now the new code) first,
- * because nothing else will.
- */
-export declare function handOffToUpdatedCli(name: string, log: BotLogger, deps: {
-    supervisor?: BotSupervisor;
-    spawnReplacement: () => number;
-}): BotSupervisor;
-export {};
-//# sourceMappingURL=cli-update.d.ts.map

package/dist/lib/bot/cli-update.js

@@ -1,278 +0,0 @@
-/**
- * A resident bot notices that the hq-cli install it was started from has been
- * updated on disk, and restarts itself onto the new code.
- *
- * `hq bot run <name>` loads the CLI once and runs for days. The install under
- * it moves on (the attended self-updater, the `hq daemon` updater, a manual
- * `npm i -g`), but nothing reloaded a running bot: on 2026-09-24 the bot
- * dr-love was still running code from 2026-09-19 while its install had moved
- * to 5.163.0, so a shipped attachment fix never reached it.
- *
- * The watcher re-resolves the entry script the process was launched with
- * (process.argv[1], the same path launchd / systemd / `hq daemon` will launch
- * again) to its package.json on a timer. Once a complete, valid, different
- * version is seen on consecutive checks, the run loop stops taking new inbox
- * items, lets the running turns finish, and exits with
- * CLI_UPDATE_RESTART_EXIT_CODE so its supervisor starts it again on the new
- * code (or, with no supervisor, starts its own replacement first).
- *
- * Convergence (policy hq-self-updater-must-verify-convergence-after-install):
- * the restart is recorded in <botDir>/cli-update.json before the exit. The next
- * process checks the version it actually loaded against that record: a match
- * is logged as converged; a process that came back on the OLD version blocks
- * that target for CLI_UPDATE_NOT_CONVERGED_COOLDOWN_MS instead of restarting
- * again. Restarts are also capped per window, so an install that keeps
- * flipping cannot turn into a restart loop.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import semver from "semver";
-import { CLI_NAME, CLI_VERSION } from "../../cli-version.js";
-import { installRewriteInProgress } from "../../utils/install-tree-torn.js";
-import { updateLockPath } from "../../utils/update-lock.js";
-import { launchdLabel } from "./paths.js";
-/**
- * Exit code for "restart me onto the updated CLI". Non-zero on purpose: every
- * supervisor a bot runs under restarts only a failed exit — launchd
- * KeepAlive{SuccessfulExit:false}, systemd Restart=on-failure, and the
- * `hq daemon` "on-failure" bot units — while a clean exit 0 (a stopped or
- * disabled bot) stays down. Same value as the daemon's RESTART_EXIT_CODE.
- */
-export const CLI_UPDATE_RESTART_EXIT_CODE = 75;
-/** How often the installed package.json is read. */
-export const CLI_UPDATE_CHECK_INTERVAL_MS = 60_000;
-/** Consecutive checks that must agree on the new version before acting. */
-const CLI_UPDATE_CONFIRMATIONS = 2;
-/** At most this many update restarts per window, whatever the versions. */
-const CLI_UPDATE_RESTART_LIMIT = 4;
-const CLI_UPDATE_RESTART_WINDOW_MS = 60 * 60_000;
-/** A restart that came back on the old version blocks that target this long. */
-const CLI_UPDATE_NOT_CONVERGED_COOLDOWN_MS = 6 * 60 * 60_000;
-/** Set to "1" to turn the watcher off (development runs). */
-export const CLI_UPDATE_DISABLE_ENV = "HQ_BOT_NO_CLI_UPDATE_RESTART";
-const CLI_UPDATE_LEDGER_FILE = "cli-update.json";
-/**
- * The hq-cli version installed behind `entry`, resolved the way the next launch
- * of the same command line will resolve it: follow the symlinks now (a pnpm or
- * versioned layout moves the link, npm rewrites the directory in place), then
- * walk up to the package.json that names this CLI. Anything short of a
- * readable manifest with a valid semver version is not a version.
- */
-export function readInstalledCli(entry, io = fs) {
-    let real;
-    try {
-        real = io.realpathSync(entry);
-    }
-    catch {
-        return { ok: false, reason: `${entry} does not resolve` };
-    }
-    let dir = path.dirname(real);
-    for (let i = 0; i < 8; i++) {
-        const manifest = path.join(dir, "package.json");
-        let raw;
-        try {
-            raw = io.readFileSync(manifest, "utf8");
-        }
-        catch {
-            raw = null;
-        }
-        if (raw !== null) {
-            let parsed;
-            try {
-                parsed = JSON.parse(raw);
-            }
-            catch {
-                return { ok: false, reason: `${manifest} is not valid JSON`, packageRoot: dir };
-            }
-            if (parsed.name === CLI_NAME) {
-                const version = typeof parsed.version === "string" ? semver.valid(parsed.version) : null;
-                if (!version)
-                    return { ok: false, reason: `${manifest} has no valid version`, packageRoot: dir };
-                return { ok: true, version, packageRoot: dir };
-            }
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return { ok: false, reason: `no ${CLI_NAME} package.json above ${real}` };
-}
-function ledgerPath(dir) {
-    return path.join(dir, CLI_UPDATE_LEDGER_FILE);
-}
-export function readCliUpdateLedger(dir) {
-    try {
-        const raw = JSON.parse(fs.readFileSync(ledgerPath(dir), "utf8"));
-        return {
-            v: 1,
-            restarts: Array.isArray(raw.restarts) ? raw.restarts.filter((s) => typeof s === "string") : [],
-            ...(raw.pending && typeof raw.pending.from === "string" && typeof raw.pending.to === "string" ? { pending: raw.pending } : {}),
-            ...(raw.blocked && typeof raw.blocked.version === "string" && typeof raw.blocked.until === "string" ? { blocked: raw.blocked } : {}),
-        };
-    }
-    catch {
-        return { v: 1, restarts: [] };
-    }
-}
-function writeCliUpdateLedger(dir, ledger) {
-    const target = ledgerPath(dir);
-    const tmp = `${target}.${process.pid}.tmp`;
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    fs.writeFileSync(tmp, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 });
-    fs.renameSync(tmp, target);
-}
-export function createCliUpdateWatcher(opts) {
-    const runningVersion = opts.runningVersion ?? CLI_VERSION;
-    const now = opts.now ?? Date.now;
-    const read = opts.read ?? ((entry) => readInstalledCli(entry));
-    const rewriteInProgress = opts.rewriteInProgress ?? ((packageRoot) => installRewriteInProgress({ packageRoot, lockPath: updateLockPath() }));
-    const checkIntervalMs = opts.checkIntervalMs ?? CLI_UPDATE_CHECK_INTERVAL_MS;
-    const confirmations = Math.max(1, opts.confirmations ?? CLI_UPDATE_CONFIRMATIONS);
-    const restartLimit = Math.max(1, opts.restartLimit ?? CLI_UPDATE_RESTART_LIMIT);
-    const restartWindowMs = opts.restartWindowMs ?? CLI_UPDATE_RESTART_WINDOW_MS;
-    const cooldownMs = opts.cooldownMs ?? CLI_UPDATE_NOT_CONVERGED_COOLDOWN_MS;
-    const { dir, entry } = opts;
-    let nextCheckAt = now() + checkIntervalMs;
-    let candidate = null;
-    let seen = 0;
-    /** Last "why not" line, so a condition that persists is logged once. */
-    let lastNote = null;
-    const note = (log, level, message) => {
-        if (message === lastNote)
-            return;
-        lastNote = message;
-        log(level, message);
-    };
-    const recentRestarts = (ledger, at) => ledger.restarts.filter((iso) => {
-        const t = Date.parse(iso);
-        return Number.isFinite(t) && at - t < restartWindowMs;
-    });
-    return {
-        runningVersion,
-        startup(log) {
-            if (!entry) {
-                log("info", "not watching for hq-cli updates (no entry script)");
-                return;
-            }
-            const ledger = readCliUpdateLedger(dir);
-            const pending = ledger.pending;
-            if (pending) {
-                delete ledger.pending;
-                if (runningVersion === pending.to) {
-                    log("info", `hq-cli update converged: now running ${runningVersion} (was ${pending.from})`);
-                    if (ledger.blocked?.version === runningVersion)
-                        delete ledger.blocked;
-                }
-                else if (runningVersion === pending.from) {
-                    const until = new Date(now() + cooldownMs).toISOString();
-                    ledger.blocked = { version: pending.to, until };
-                    log("error", `restarted to load hq-cli ${pending.to} but this process still loaded ${runningVersion}; ` +
-                        `not restarting for ${pending.to} again until ${until} (check which install ${entry} resolves to)`);
-                }
-                else {
-                    log("info", `restarted for hq-cli ${pending.to}; now running ${runningVersion}`);
-                }
-                try {
-                    writeCliUpdateLedger(dir, ledger);
-                }
-                catch (err) {
-                    log("warn", `could not update ${CLI_UPDATE_LEDGER_FILE}: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            log("info", `watching ${entry} for hq-cli updates (running ${runningVersion})`);
-        },
-        poll(log) {
-            if (!entry)
-                return null;
-            const at = now();
-            if (at < nextCheckAt)
-                return null;
-            nextCheckAt = at + checkIntervalMs;
-            const installed = read(entry);
-            if (!installed.ok) {
-                candidate = null;
-                seen = 0;
-                note(log, "warn", `hq-cli install not readable, not restarting: ${installed.reason}`);
-                return null;
-            }
-            if (installed.version === runningVersion) {
-                candidate = null;
-                seen = 0;
-                lastNote = null;
-                return null;
-            }
-            if (rewriteInProgress(installed.packageRoot)) {
-                candidate = null;
-                seen = 0;
-                note(log, "info", `hq-cli ${installed.version} is still being installed; waiting for it to finish`);
-                return null;
-            }
-            if (candidate === installed.version)
-                seen += 1;
-            else {
-                candidate = installed.version;
-                seen = 1;
-            }
-            if (seen < confirmations) {
-                note(log, "info", `hq-cli ${installed.version} is installed (running ${runningVersion}); confirming before restarting`);
-                return null;
-            }
-            const ledger = readCliUpdateLedger(dir);
-            if (ledger.blocked?.version === installed.version && at < Date.parse(ledger.blocked.until)) {
-                note(log, "warn", `not restarting for hq-cli ${installed.version}: an earlier restart for it did not load it (retry after ${ledger.blocked.until})`);
-                return null;
-            }
-            if (recentRestarts(ledger, at).length >= restartLimit) {
-                note(log, "warn", `not restarting for hq-cli ${installed.version}: already restarted ${restartLimit} times for updates in the last ${Math.round(restartWindowMs / 60_000)} minutes`);
-                return null;
-            }
-            return { from: runningVersion, to: installed.version, packageRoot: installed.packageRoot };
-        },
-        recordRestart(update) {
-            const at = now();
-            const ledger = readCliUpdateLedger(dir);
-            ledger.restarts = [...recentRestarts(ledger, at), new Date(at).toISOString()];
-            ledger.pending = { from: update.from, to: update.to, at: new Date(at).toISOString() };
-            writeCliUpdateLedger(dir, ledger);
-        },
-    };
-}
-export function detectBotSupervisor(name, opts = {}) {
-    const env = opts.env ?? process.env;
-    const platform = opts.platform ?? process.platform;
-    if (env.HQ_DAEMON_UNIT === `bots:${name}`)
-        return "hq-daemon";
-    if (platform === "darwin" && env.XPC_SERVICE_NAME === launchdLabel(name))
-        return "launchd";
-    if (platform === "linux") {
-        const readCgroup = opts.readCgroup ??
-            (() => {
-                try {
-                    return fs.readFileSync("/proc/self/cgroup", "utf8");
-                }
-                catch {
-                    return null;
-                }
-            });
-        if (readCgroup()?.includes(`/hq-bot-${name}.service`))
-            return "systemd";
-    }
-    return "none";
-}
-/**
- * The last step of an update restart, run after the pid lock is released and
- * just before the exit. A supervised bot only has to exit; an unsupervised one
- * starts its replacement on the same entry script (now the new code) first,
- * because nothing else will.
- */
-export function handOffToUpdatedCli(name, log, deps) {
-    const supervisor = deps.supervisor ?? detectBotSupervisor(name);
-    if (supervisor !== "none") {
-        log("info", `exiting for ${supervisor} to start the updated hq-cli`);
-        return supervisor;
-    }
-    log("info", `no supervisor; started replacement pid ${deps.spawnReplacement()}`);
-    return supervisor;
-}
-//# sourceMappingURL=cli-update.js.map

package/dist/lib/bot/company-bind.d.ts

@@ -1,27 +0,0 @@
-/**
- * Company bind for worker-sourced bots (local-bots Feature 4).
- *
- * HQ's company hooks key on workspace/sessions/<sid>/meta.yaml `company_slug`,
- * where <sid> is the Claude session id carried in the hook payload. A bot that
- * runs a company worker writes that file for the session id it is about to
- * use, before every turn, so the hooks resolve the company exactly as they do
- * for the owner. Idempotent: an existing file keeps its other keys and only
- * has `company_slug` replaced.
- *
- * Coverage note: Claude bots get the full company hook set (their session id
- * is in the hook payload). Codex/Grok bots only see HQ_SESSION_ID in the env.
- */
-export interface CompanyBindFs {
-    existsSync: (p: string) => boolean;
-    readFileSync: (p: string) => string;
-    writeFileSync: (p: string, body: string) => void;
-    mkdirSync: (p: string) => void;
-}
-export declare const defaultCompanyBindFs: CompanyBindFs;
-export declare function botSessionMetaRelPath(sessionId: string): string;
-export declare function ensureBotSessionMeta(hqRoot: string, sessionId: string, companySlug: string, io?: CompanyBindFs, now?: () => Date): {
-    path: string;
-    created: boolean;
-    changed: boolean;
-};
-//# sourceMappingURL=company-bind.d.ts.map

package/dist/lib/bot/company-bind.js

@@ -1,62 +0,0 @@
-/**
- * Company bind for worker-sourced bots (local-bots Feature 4).
- *
- * HQ's company hooks key on workspace/sessions/<sid>/meta.yaml `company_slug`,
- * where <sid> is the Claude session id carried in the hook payload. A bot that
- * runs a company worker writes that file for the session id it is about to
- * use, before every turn, so the hooks resolve the company exactly as they do
- * for the owner. Idempotent: an existing file keeps its other keys and only
- * has `company_slug` replaced.
- *
- * Coverage note: Claude bots get the full company hook set (their session id
- * is in the hook payload). Codex/Grok bots only see HQ_SESSION_ID in the env.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-export const defaultCompanyBindFs = {
-    existsSync: (p) => fs.existsSync(p),
-    readFileSync: (p) => fs.readFileSync(p, "utf8"),
-    writeFileSync: (p, body) => fs.writeFileSync(p, body, { mode: 0o644 }),
-    mkdirSync: (p) => fs.mkdirSync(p, { recursive: true }),
-};
-const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-const COMPANY_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
-export function botSessionMetaRelPath(sessionId) {
-    return path.join("workspace", "sessions", sessionId, "meta.yaml");
-}
-export function ensureBotSessionMeta(hqRoot, sessionId, companySlug, io = defaultCompanyBindFs, now = () => new Date()) {
-    if (!SESSION_ID_RE.test(sessionId))
-        throw new Error(`Invalid session id for company bind: "${sessionId}"`);
-    if (!COMPANY_SLUG_RE.test(companySlug))
-        throw new Error(`Invalid company slug for company bind: "${companySlug}"`);
-    const file = path.join(hqRoot, botSessionMetaRelPath(sessionId));
-    io.mkdirSync(path.dirname(file));
-    if (!io.existsSync(file)) {
-        const body = `session_id: ${sessionId}\nstarted_at: "${now().toISOString()}"\ncompany_slug: ${companySlug}\n`;
-        io.writeFileSync(file, body);
-        return { path: file, created: true, changed: true };
-    }
-    const current = io.readFileSync(file);
-    const lines = current.split("\n");
-    let replaced = false;
-    const next = lines.map((line) => {
-        if (/^company_slug\s*:/.test(line)) {
-            replaced = true;
-            return `company_slug: ${companySlug}`;
-        }
-        return line;
-    });
-    if (!replaced) {
-        while (next.length > 0 && next[next.length - 1] === "")
-            next.pop();
-        next.push(`company_slug: ${companySlug}`);
-    }
-    if (!next.some((l) => /^session_id\s*:/.test(l)))
-        next.unshift(`session_id: ${sessionId}`);
-    const body = `${next.join("\n").replace(/\n+$/, "")}\n`;
-    if (body === current)
-        return { path: file, created: false, changed: false };
-    io.writeFileSync(file, body);
-    return { path: file, created: false, changed: true };
-}
-//# sourceMappingURL=company-bind.js.map