@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/lib/daemon/updater.js

@@ -0,0 +1,163 @@
+/**
+ * One run of the `updater` service (`hq daemon service self-update`), which
+ * replaces the boxes' `hq-cli-update.timer` and `*-codex-update.timer`:
+ *
+ * 1. Update the hq CLI through the shared self-update path (same install
+ *    routing, lock and convergence check as every other CLI update), when it
+ *    is a global install this process may replace.
+ * 2. Update the Claude, Codex and Grok CLIs the login user installed, each
+ *    through its own update route. A copy this user cannot write (root's
+ *    under /usr) is reported and left alone.
+ * 3. Install or update the daemon's own hq-cloud (sync and the outpost
+ *    heartbeat run from it when it is newer than the CLI's bundled copy), and
+ *    restart sync and the heartbeat right after it changes.
+ * 4. After a CLI update, ask the daemon to restart itself so the supervisor and
+ *    every service run the new version. The remote-control hosts notice an
+ *    updated Claude or Codex on disk themselves and restart once idle.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import { locateTool, toolUpdateCommand } from "./tools.js";
+export async function runDaemonUpdater(deps) {
+    let ok = true;
+    // The restart stops this process too, so it is requested only once all the
+    // updater's work (every tool install) is done.
+    let restart = false;
+    if (deps.updateCli === null) {
+        deps.log("hq CLI: not a global install, so it is updated with the project or app that owns it");
+    }
+    else {
+        const cli = await deps.updateCli();
+        switch (cli.action) {
+            case "updated":
+                deps.log(`hq CLI updated to ${cli.latest ?? "the latest version"}; the daemon restarts onto it once the tools are checked`);
+                restart = true;
+                break;
+            case "update-failed":
+            case "update-ineffective":
+                deps.log(`hq CLI update to ${cli.latest ?? "latest"} did not take effect (${cli.action})`);
+                ok = false;
+                break;
+            default:
+                deps.log(`hq CLI: ${cli.action === "current" ? "up to date" : cli.action}`);
+        }
+    }
+    if (deps.updateHqCloud) {
+        const cloud = await deps.updateHqCloud().catch((err) => ({
+            ok: false,
+            from: null,
+            to: null,
+            detail: err instanceof Error ? err.message : String(err),
+        }));
+        if (!cloud.ok) {
+            deps.log(`hq-cloud update failed: ${cloud.detail ?? "unknown error"}`);
+            ok = false;
+        }
+        else if (cloud.to && cloud.to !== cloud.from) {
+            deps.log(`hq-cloud updated ${cloud.from ?? "(none)"} -> ${cloud.to}; restarting ${deps.hqCloudUnits.join(" and ")} onto it`);
+            for (const unit of deps.hqCloudUnits)
+                deps.requestRestart(unit);
+        }
+        else {
+            deps.log(`hq-cloud ${cloud.to ?? cloud.from ?? "unknown version"}: up to date`);
+        }
+    }
+    const updated = [];
+    for (const tool of deps.tools) {
+        const outcome = updateTool(tool, deps.log);
+        if (outcome === "failed")
+            ok = false;
+        if (outcome === "updated")
+            updated.push(tool.name);
+    }
+    if (restart)
+        deps.requestDaemonRestart();
+    return { ok, updated };
+}
+function updateTool(tool, log) {
+    const before = tool.locate();
+    if (!before) {
+        log(`${tool.name}: not installed`);
+        return "skipped";
+    }
+    if (!before.writable) {
+        log(`${tool.name} at ${before.path} belongs to another account, so it is not updated as this user`);
+        return "skipped";
+    }
+    const result = tool.update(before);
+    if (!result.ok) {
+        log(`${tool.name} update failed: ${result.detail ?? "unknown error"}`);
+        return "failed";
+    }
+    const after = tool.locate();
+    const from = before.version ?? "unknown version";
+    if (after?.version && after.version !== before.version) {
+        log(`${tool.name} updated ${from} -> ${after.version}`);
+        return "updated";
+    }
+    log(`${tool.name} ${from}: up to date`);
+    return "current";
+}
+/**
+ * The variables for the updater's own CLI update. Every supervised service
+ * gets HQ_NO_UPDATE_CHECK=1 so it never updates itself; the updater is the one
+ * process that must, so it drops that opt-out.
+ */
+export function updaterEnv(vars) {
+    const copy = { ...vars };
+    delete copy.HQ_NO_UPDATE_CHECK;
+    return copy;
+}
+function hostProbe(env, home) {
+    return {
+        home,
+        env,
+        exists: (p) => {
+            try {
+                fs.accessSync(p, fs.constants.X_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        realpath: (p) => fs.realpathSync(p),
+        writable: (dir) => {
+            try {
+                fs.accessSync(dir, fs.constants.W_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        version: (bin) => {
+            const r = spawnSync(bin, ["--version"], { encoding: "utf8", env, timeout: 30_000, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+            return { status: r.status, stdout: r.stdout ?? "" };
+        },
+    };
+}
+/** The real updater for one tool, run as this (the login) user. */
+export function hostToolUpdater(name, env, home) {
+    const probe = hostProbe(env, home);
+    return {
+        name,
+        locate: () => locateTool(name, probe),
+        update: (install) => {
+            const cmd = toolUpdateCommand(name, install);
+            const r = spawnSync(cmd.file, cmd.args, {
+                encoding: "utf8",
+                env: { ...env, ...cmd.env },
+                timeout: 10 * 60_000,
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+                shell: process.platform === "win32" && cmd.file === "npm",
+            });
+            if (r.status === 0)
+                return { ok: true };
+            const tail = `${r.stderr ?? ""}\n${r.stdout ?? ""}`.trim().split("\n").slice(-3).join(" ").slice(0, 400);
+            return { ok: false, detail: tail || (r.error ? r.error.message : `${cmd.file} exited ${r.status ?? "by signal"}`) };
+        },
+    };
+}
+//# sourceMappingURL=updater.js.map

package/dist/lib/db/control-plane.js

@@ -1,4 +1,8 @@
 import { planGateErrorFromPayload } from "../../utils/plan-gate-error.js";
+// Provision may allocate remote resources, so allow two minutes and never retry.
+const DB_PROVISION_TIMEOUT_MS = 120_000;
+// Status is a read-only probe; 15 seconds is longer than its normal response time.
+const DB_STATUS_TIMEOUT_MS = 15_000;
 function assertNoPostgresUrl(label, text) {
     if (/postgres:\/\//i.test(text) || /postgresql:\/\//i.test(text)) {
         throw new Error(`${label}: control plane returned a connection string (refusing to surface)`);
@@ -22,6 +26,7 @@ export class ControlPlaneDbClient {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify(input),
+            signal: AbortSignal.timeout(DB_PROVISION_TIMEOUT_MS),
         });
         const text = await res.text();
         assertNoPostgresUrl("provision", text);
@@ -53,6 +58,7 @@ export class ControlPlaneDbClient {
         const res = await this.fetchImpl(url, {
             method: "GET",
             headers: { Authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(DB_STATUS_TIMEOUT_MS),
         });
         const text = await res.text();
         assertNoPostgresUrl("status", text);

package/dist/lib/db/local.d.ts

@@ -23,11 +23,6 @@ export interface LocalDbStatus {
     /** Fingerprint of path for logs that prefer not to echo full home paths. */
     pathFingerprint: string;
 }
-/**
- * Short non-reversible fingerprint of a path (for status display).
- * Not a secret — just avoids dumping full home paths when preferred.
- */
-export declare function fingerprintPath(filePath: string): string;
 /**
  * Open (and create if missing) the company local vault DB with WAL mode.
  * Idempotent: reopening an existing file does not recreate or wipe it.

package/dist/lib/db/local.js

@@ -12,7 +12,7 @@ const MIGRATIONS_TABLE = "hq_schema_migrations";
  * Short non-reversible fingerprint of a path (for status display).
  * Not a secret — just avoids dumping full home paths when preferred.
  */
-export function fingerprintPath(filePath) {
+function fingerprintPath(filePath) {
     let h = 2166136261;
     for (let i = 0; i < filePath.length; i++) {
         h ^= filePath.charCodeAt(i);

package/dist/lib/db/migrate.d.ts

@@ -5,9 +5,7 @@
  *   companies/{company}/db/migrations/*.sql
  * Applied versions are recorded in hq_schema_migrations inside the local DB.
  */
-import type { LocalDb } from "./local.js";
 import type { LocalDbPathEnv } from "./paths.js";
-export declare const MIGRATIONS_TABLE = "hq_schema_migrations";
 export interface MigrateOptions extends LocalDbPathEnv {
     company: string;
     /**
@@ -24,16 +22,6 @@ export interface MigrateResult {
     head: string | null;
 }
 export declare function resolveMigrationsDir(hqRoot: string, companySlug: string): string;
-/**
- * Ensure migrations directory exists (creates empty dir on first migrate).
- */
-export declare function ensureMigrationsDir(hqRoot: string, companySlug: string): string;
-/**
- * List pending migration files in lexical/version order (filename sort).
- */
-export declare function listMigrationFiles(migrationsDir: string): string[];
-export declare function ensureMigrationsLedger(db: LocalDb): void;
-export declare function listAppliedVersions(db: LocalDb): Set<string>;
 /**
  * Apply pending migrations. On failure, does not mark the failed file applied.
  */

package/dist/lib/db/migrate.js

@@ -9,7 +9,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { openLocalDb, readMigrationHead } from "./local.js";
 import { normalizeCompanySlugForLocalDb } from "./paths.js";
-export const MIGRATIONS_TABLE = "hq_schema_migrations";
+const MIGRATIONS_TABLE = "hq_schema_migrations";
 export function resolveMigrationsDir(hqRoot, companySlug) {
     const slug = normalizeCompanySlugForLocalDb(companySlug);
     return path.join(hqRoot, "companies", slug, "db", "migrations");
@@ -17,7 +17,7 @@ export function resolveMigrationsDir(hqRoot, companySlug) {
 /**
  * Ensure migrations directory exists (creates empty dir on first migrate).
  */
-export function ensureMigrationsDir(hqRoot, companySlug) {
+function ensureMigrationsDir(hqRoot, companySlug) {
     const dir = resolveMigrationsDir(hqRoot, companySlug);
     fs.mkdirSync(dir, { recursive: true });
     return dir;
@@ -25,7 +25,7 @@ export function ensureMigrationsDir(hqRoot, companySlug) {
 /**
  * List pending migration files in lexical/version order (filename sort).
  */
-export function listMigrationFiles(migrationsDir) {
+function listMigrationFiles(migrationsDir) {
     if (!fs.existsSync(migrationsDir))
         return [];
     return fs
@@ -33,7 +33,7 @@ export function listMigrationFiles(migrationsDir) {
         .filter((f) => f.endsWith(".sql"))
         .sort((a, b) => a.localeCompare(b, "en"));
 }
-export function ensureMigrationsLedger(db) {
+function ensureMigrationsLedger(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
       version TEXT PRIMARY KEY NOT NULL,
@@ -41,7 +41,7 @@ export function ensureMigrationsLedger(db) {
     );
   `);
 }
-export function listAppliedVersions(db) {
+function listAppliedVersions(db) {
     ensureMigrationsLedger(db);
     const rows = db
         .prepare(`SELECT version FROM ${MIGRATIONS_TABLE} ORDER BY version`)

package/dist/lib/db/remote-sql.d.ts

@@ -1,8 +1,8 @@
 /**
- * Remote SQL via secrets-exec style injection (US-010).
+ * Remote SQL helper with injected credentials and executor (US-010).
  *
  * Connection string never appears in argv, logs, or stdout.
- * Local remains default when --remote is absent (handled by command layer).
+ * The CLI command does not currently wire this helper to a remote executor.
  */
 export interface RemoteSqlOptions {
     company: string;

package/dist/lib/db/remote-sql.js

@@ -1,8 +1,8 @@
 /**
- * Remote SQL via secrets-exec style injection (US-010).
+ * Remote SQL helper with injected credentials and executor (US-010).
  *
  * Connection string never appears in argv, logs, or stdout.
- * Local remains default when --remote is absent (handled by command layer).
+ * The CLI command does not currently wire this helper to a remote executor.
  */
 function assertNoLeak(label, value) {
     const s = typeof value === "string" ? value : JSON.stringify(value);
@@ -23,7 +23,7 @@ export async function runRemoteSql(opts) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : "no remote binding";
-        throw new Error(`remote SQL unavailable: ${msg}. Run \`hq db provision --company ${opts.company}\` first.`);
+        throw new Error(`remote SQL unavailable: ${msg}`);
     }
     assertNoLeak("connection config", config);
     if (!opts.execute) {

package/dist/lib/db/sql.d.ts

@@ -27,14 +27,6 @@ export interface SqlRunResult {
     changes: number;
     readonly: boolean;
 }
-export declare function stripSqlNoise(sql: string): string;
-export declare function isWriteSql(sql: string): boolean;
-/**
- * Statements that must never run via `hq db sql`, even with --write.
- * ATTACH/DETACH would let a company-scoped session open another company's
- * vault.db by absolute path (category-1 isolation).
- */
-export declare function assertSqlAllowed(sql: string): void;
 /**
  * Resolve which file path to open, enforcing company isolation by default.
  */
@@ -44,6 +36,4 @@ export declare function resolveSqlDbPath(opts: SqlRunOptions): string;
  */
 export declare function runLocalSql(opts: SqlRunOptions): SqlRunResult;
 export declare function formatSqlResult(result: SqlRunResult, format?: "jsonl" | "table"): string;
-/** Test helper: company dir for isolation assertions. */
-export declare function companyLocalDbDir(company: string, env?: LocalDbPathEnv): string;
 //# sourceMappingURL=sql.d.ts.map

package/dist/lib/db/sql.js

@@ -7,17 +7,17 @@
  */
 import Database from "better-sqlite3";
 import { openLocalDb } from "./local.js";
-import { normalizeCompanySlugForLocalDb, resolveLocalDbDir, resolveLocalDbPath, } from "./paths.js";
+import { normalizeCompanySlugForLocalDb, resolveLocalDbPath, } from "./paths.js";
 const WRITE_PATTERN = /^\s*(INSERT|UPDATE|DELETE|REPLACE|CREATE|DROP|ALTER|TRUNCATE|REINDEX|VACUUM|BEGIN|COMMIT|ROLLBACK)\b/i;
 /** Always forbidden — opens other files/DBs and breaks company path isolation. */
 const FORBIDDEN_SQL_PATTERN = /\b(ATTACH|DETACH|LOAD_EXTENSION)\b/i;
-export function stripSqlNoise(sql) {
+function stripSqlNoise(sql) {
     return sql
         .replace(/^\s*--[^\n]*\n/gm, "")
         .replace(/^\s*\/\*[\s\S]*?\*\//gm, "")
         .trim();
 }
-export function isWriteSql(sql) {
+function isWriteSql(sql) {
     return WRITE_PATTERN.test(stripSqlNoise(sql));
 }
 /**
@@ -25,7 +25,7 @@ export function isWriteSql(sql) {
  * ATTACH/DETACH would let a company-scoped session open another company's
  * vault.db by absolute path (category-1 isolation).
  */
-export function assertSqlAllowed(sql) {
+function assertSqlAllowed(sql) {
     const stripped = stripSqlNoise(sql);
     if (FORBIDDEN_SQL_PATTERN.test(stripped)) {
         throw new Error("ATTACH/DETACH/LOAD_EXTENSION are not allowed via hq db sql (tenant isolation); use the company-canonical local path only");
@@ -122,8 +122,4 @@ export function formatSqlResult(result, format = "jsonl") {
         .join("\n");
     return body ? `${header}\n${body}` : header;
 }
-/** Test helper: company dir for isolation assertions. */
-export function companyLocalDbDir(company, env) {
-    return resolveLocalDbDir(company, env);
-}
 //# sourceMappingURL=sql.js.map

package/dist/lib/deploy-api.d.ts

@@ -0,0 +1,5 @@
+/** Shared authenticated request path for the hq-deploy control plane. */
+export declare const DEPLOY_API_URL: string;
+export declare function deployHeaders(token: string, json?: boolean, extra?: Record<string, string>): Record<string, string>;
+export declare function deployApiRequest(token: string, route: string, method: string, body?: unknown, extraHeaders?: Record<string, string>): Promise<Response>;
+//# sourceMappingURL=deploy-api.d.ts.map

package/dist/lib/deploy-api.js

@@ -0,0 +1,21 @@
+/** Shared authenticated request path for the hq-deploy control plane. */
+export const DEPLOY_API_URL = process.env.HQ_DEPLOY_API_URL?.trim() || "https://api.indigo-hq.com";
+export function deployHeaders(token, json = true, extra = {}) {
+    return {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+        ...(json ? { "Content-Type": "application/json" } : {}),
+        ...extra,
+    };
+}
+function deployApiUrl(route) {
+    return `${DEPLOY_API_URL.replace(/\/+$/, "")}${route}`;
+}
+export async function deployApiRequest(token, route, method, body, extraHeaders = {}) {
+    return fetch(deployApiUrl(route), {
+        method,
+        headers: deployHeaders(token, body !== undefined, extraHeaders),
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+}
+//# sourceMappingURL=deploy-api.js.map

package/dist/lib/deploy-apps.d.ts

@@ -0,0 +1,13 @@
+/** Pagination for org-scoped hq-deploy app listings. */
+export declare const MAX_DEPLOY_APPS_PAGES = 100;
+export interface DeployAppsPage<T> {
+    apps?: unknown;
+    nextCursor?: unknown;
+}
+/**
+ * Collect every page from GET /api/apps. Older hq-deploy versions omit
+ * nextCursor, which remains a valid single-page response. The cap prevents a
+ * bad cursor response from creating an unbounded CLI request loop.
+ */
+export declare function listDeployApps<T>(fetchPage: (cursor?: string) => Promise<DeployAppsPage<T>>): Promise<T[]>;
+//# sourceMappingURL=deploy-apps.d.ts.map

package/dist/lib/deploy-apps.js

@@ -0,0 +1,29 @@
+/** Pagination for org-scoped hq-deploy app listings. */
+export const MAX_DEPLOY_APPS_PAGES = 100;
+/**
+ * Collect every page from GET /api/apps. Older hq-deploy versions omit
+ * nextCursor, which remains a valid single-page response. The cap prevents a
+ * bad cursor response from creating an unbounded CLI request loop.
+ */
+export async function listDeployApps(fetchPage) {
+    const apps = [];
+    const seenCursors = new Set();
+    let cursor;
+    for (let page = 0; page < MAX_DEPLOY_APPS_PAGES; page += 1) {
+        const result = await fetchPage(cursor);
+        if (Array.isArray(result.apps))
+            apps.push(...result.apps);
+        if (result.nextCursor === undefined || result.nextCursor === null)
+            return apps;
+        if (typeof result.nextCursor !== "string" || result.nextCursor.length === 0) {
+            throw new Error("hq-deploy returned an invalid apps-list cursor.");
+        }
+        if (seenCursors.has(result.nextCursor)) {
+            throw new Error("hq-deploy returned a repeated apps list cursor.");
+        }
+        seenCursors.add(result.nextCursor);
+        cursor = result.nextCursor;
+    }
+    throw new Error(`hq-deploy apps list exceeded the ${MAX_DEPLOY_APPS_PAGES}-page safety cap.`);
+}
+//# sourceMappingURL=deploy-apps.js.map

package/dist/lib/doctor/__testing__/fake-hq-tree.d.ts

@@ -74,7 +74,7 @@ export interface FakeHookSpec {
     mode?: number;
     /** Whether the hook is registered in `.claude/settings.json`. Default: true. */
     registered?: boolean;
-    /** Events the hook registers against. Default: ["PreToolUse"]. */
+    /** Events the hook registers against. Default: SessionStart and PreToolUse. */
     events?: HookEventName[];
     /** Optional settings matcher (e.g. "Bash", "Glob"). */
     matcher?: string;

package/dist/lib/doctor/__testing__/fake-hq-tree.js

@@ -166,7 +166,7 @@ function writeHook(claudeHooksDir, codexHooksDir, hook, defaultMirror) {
     const claudeBody = hook.body ?? DEFAULT_HOOK_BODY;
     const present = hook.present !== false;
     const registered = hook.registered !== false;
-    const events = hook.events ?? ["PreToolUse"];
+    const events = hook.events ?? ["SessionStart", "PreToolUse"];
     const profiles = hook.profiles ?? [...GATE_PROFILES];
     const scriptPath = path.join(claudeHooksDir, `${hook.id}.sh`);
     let mode = null;

package/dist/lib/doctor/__testing__/run-doctor.d.ts

@@ -0,0 +1,8 @@
+import { type RunDoctorOptions, type RunDoctorResult } from "../../../commands/doctor.js";
+/**
+ * Run doctor tests against synthetic state. The production registry normally
+ * reads local HQ work-context, sync, daemon, and session state; tests must not
+ * inspect the developer's HOME or request the live integrations inventory.
+ */
+export declare function runDoctorForTest(options?: RunDoctorOptions): Promise<RunDoctorResult>;
+//# sourceMappingURL=run-doctor.d.ts.map

package/dist/lib/doctor/__testing__/run-doctor.js

@@ -0,0 +1,52 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { runDoctor as runDoctorCommand, } from "../../../commands/doctor.js";
+/**
+ * Run doctor tests against synthetic state. The production registry normally
+ * reads local HQ work-context, sync, daemon, and session state; tests must not
+ * inspect the developer's HOME or request the live integrations inventory.
+ */
+export async function runDoctorForTest(options = {}) {
+    const home = fs.mkdtempSync(path.join(os.tmpdir(), "hq-doctor-test-home-"));
+    const homeRoot = path.parse(home).root;
+    const homeDrive = homeRoot.endsWith(path.sep) ? homeRoot.slice(0, -1) : homeRoot;
+    const homePath = home.slice(homeDrive.length);
+    const isolatedEnv = {
+        HOME: home,
+        USERPROFILE: home,
+        HOMEDRIVE: process.platform === "win32" ? homeDrive : undefined,
+        HOMEPATH: process.platform === "win32" ? homePath : undefined,
+        HQ_ROOT: undefined,
+        HQ_STATE_DIR: path.join(home, ".hq"),
+        HQ_MACHINE_TOKEN_STATE_DIR: path.join(home, ".hq", "work-mesh", "daemon"),
+        HQ_MACHINE_CREDS_FILE: undefined,
+        HQ_AGENT_DIR: path.join(home, ".hq-agent"),
+        HQ_BOTS_ROOT: path.join(home, ".hq", "bots"),
+        HQ_DAEMON_DIR: path.join(home, ".hq", "daemon"),
+        HQ_WORK_CONTEXT_ROOT: path.join(home, ".hq", "work-context"),
+        HQ_WORK_MESH_ROOT: path.join(home, ".hq", "work-mesh"),
+        HQ_RUNTIME_MARKER_FILE: path.join(home, "runtime.json"),
+        HQ_FLEET_CONFIG_FILE: path.join(home, ".hq-fleet", "config.yaml"),
+    };
+    const originalEnv = new Map(Object.keys(isolatedEnv).map((key) => [key, process.env[key]]));
+    try {
+        for (const [key, value] of Object.entries(isolatedEnv)) {
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
+        }
+        return await runDoctorCommand({ ...options, integrations: false });
+    }
+    finally {
+        for (const [key, value] of originalEnv) {
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
+        }
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=run-doctor.js.map

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

@@ -0,0 +1,13 @@
+import { type NodeBinaryIo } from "../../node-binary.js";
+import type { CheckContext, CheckFamily, CheckResult } from "../types.js";
+export declare const BOTS_FAMILY_ID = "bots";
+export declare const BOTS_FAMILY_TITLE = "Local bots";
+export interface BotsDoctorDeps {
+    home: () => string;
+    root: (home?: string) => string;
+    /** Filesystem view used to judge the startup agent's node path (tests). */
+    nodeIo?: NodeBinaryIo;
+}
+export declare const botsFamily: CheckFamily;
+export declare function checkBots(_context: CheckContext, deps?: BotsDoctorDeps): CheckResult[];
+//# sourceMappingURL=bots.d.ts.map