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

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

@@ -1,349 +0,0 @@
-/**
- * Typed HQ API client for the bot runtime (local-bots US-004).
- *
- * Every call goes through the shared `vaultApiFetch` helper with a token
- * supplier so the bot's machine identity (agt_) is minted and refreshed by the
- * existing Cognito machinery. `fetch` is injectable for tests.
- */
-import { vaultApiFetch } from "../../utils/vault-api.js";
-import { type BotLocalConfig } from "./local-config.js";
-export type TokenSupplier = () => Promise<string>;
-/**
- * One agent-inbox item. DMs carry the base fields; room (channel / group chat)
- * items add the optional room fields (server: hq-pro-core
- * room-agent-delivery.ts `RoomInboxMessage`).
- */
-export interface InboxItem {
-    messageId: string;
-    channel: string;
-    eventId?: string;
-    fromPersonUid?: string;
-    fromDisplayName?: string;
-    text?: string;
-    rootEventId?: string;
-    receivedAt?: string;
-    /**
-     * Files attached to the message, as vault references (never content):
-     * `{ vaultPath, name, sizeBytes, contentType | kind, companyUid }`, where
-     * `companyUid` is the vault scope (the sender's prs_ for a DM). Server:
-     * hq-pro-agents channels/agent-dm-dispatch.ts. Parse with
-     * `inboxEntryAttachments`; the singular `attachment` is the legacy form.
-     */
-    attachments?: unknown[];
-    attachment?: unknown;
-    /** Room items only (channel === "room"). */
-    channelId?: string;
-    channelName?: string;
-    channelScope?: string;
-    mentionedMe?: boolean;
-    memberCount?: number;
-    senderTrust?: "member";
-    /**
-     * Scheduled-job run items only (channel === "job"). The cloud fires the job
-     * on its own schedule and writes this durable item; the run carries its own
-     * prompt instead of `text` (server: hq-pro-agents jobs/run-record.ts
-     * `JobRunInboxItem`).
-     */
-    jobId?: string;
-    prompt?: string;
-    context?: Record<string, unknown> | string;
-    script?: string;
-    firedAt?: string;
-    staleAfter?: string;
-    requestId?: string;
-}
-/** The terminal outcome a box reports for one fired run. */
-export type JobRunStatus = "succeeded" | "failed" | "skipped-precondition";
-export interface JobRunCompletion {
-    status: JobRunStatus;
-    output?: string;
-    disposition?: string;
-}
-/** A job record as the cloud returns it (hq-pro-agents jobs/schema.ts `JobRecord`). */
-export interface BotJobRecord {
-    jobId: string;
-    prompt: string;
-    status?: string;
-    schedule?: {
-        kind?: string;
-        cron?: string;
-        at?: string;
-        timezone?: string;
-    };
-    context?: Record<string, unknown>;
-    script?: string;
-    createdAt?: string;
-    nextRunAt?: string;
-    lastRunAt?: string;
-    lastStatus?: string;
-    runCount?: number;
-}
-export interface CreateJobInput {
-    prompt: string;
-    context?: Record<string, unknown>;
-    script?: string;
-    schedule: {
-        kind: "once";
-        at: string;
-        timezone: string;
-    } | {
-        kind: "recurring";
-        cron: string;
-        timezone: string;
-    };
-}
-/** @deprecated use InboxItem */
-export type DmInboxItem = InboxItem;
-/** A simplified channel message for the "Recent messages" context block. */
-export interface ChannelMessageSummary {
-    eventId?: string;
-    fromPersonUid?: string;
-    fromDisplayName?: string;
-    body: string;
-    createdAt?: string;
-}
-export interface AgentRecord {
-    uid: string;
-    name?: string;
-    ownerUid?: string | null;
-    computeMode?: string;
-    botKind?: string;
-    /** Company bots: the `cmp_` uids the server made it a member of. */
-    companyMemberships?: string[];
-    online?: boolean;
-    runtime?: {
-        status?: string;
-        lastHeartbeat?: {
-            at?: string;
-        } | null;
-    };
-}
-/**
- * One of the caller's own local bots, as `GET /v1/agents/mine?local=1` lists
- * them — enough to tell a bot that is missing from this machine from one that
- * is already here, and to rebuild it.
- */
-export interface MyLocalBot {
-    agentUid: string;
-    slug?: string;
-    name?: string;
-    botKind?: "personal" | "company";
-    computeMode?: string;
-    ownerUid?: string;
-    online?: boolean;
-    lastHeartbeatAt?: string | null;
-    localConfig?: unknown;
-}
-/** What the credential re-issue route hands back (a rotated machine secret). */
-export interface ReissuedBotCredentials {
-    agent: AgentRecord;
-    identity: {
-        cognitoUsername: string;
-        secret: string;
-    };
-    localConfig: unknown;
-}
-export declare class BotApiError extends Error {
-    readonly status: number;
-    readonly path: string;
-    readonly code?: string | undefined;
-    readonly detail?: string | undefined;
-    readonly retryAfterMs?: number | undefined;
-    readonly tokenAgentUid?: string | undefined;
-    constructor(status: number, path: string, code?: string | undefined, detail?: string | undefined, retryAfterMs?: number | undefined, tokenAgentUid?: string | undefined);
-}
-export declare class InvalidDmRecipientError extends Error {
-    readonly recipient: string;
-    constructor(recipient: string);
-}
-/** Parse a Retry-After header (delta-seconds or HTTP-date) to milliseconds. */
-export declare function retryAfterHeaderMs(value: string | null | undefined, nowMs?: number): number | undefined;
-export interface BotApiOptions {
-    token: TokenSupplier;
-    baseUrl?: string;
-    fetchImpl?: typeof vaultApiFetch;
-}
-export interface BotPromotionState {
-    version: number;
-    operationId: string;
-    agentUid: string;
-    ownerUid: string;
-    companyUid: string;
-    snapshotSha256: string;
-    phase: "preparing" | "local-stopped" | "imported" | "cloud-ready" | "active" | "cancelled";
-    updatedAt: string;
-}
-export interface BotPromotionUpload {
-    url: string;
-    method: "PUT";
-    headers: Record<string, string>;
-    bytes: number;
-    sha256: string;
-    expiresInSeconds: number;
-}
-export declare class BotApi {
-    private readonly opts;
-    private readonly fetchImpl;
-    constructor(opts: BotApiOptions);
-    private call;
-    /** GET /v1/agents/{uid} — owner-only local bot record (403/404 for others). */
-    getAgent(agentUid: string): Promise<AgentRecord>;
-    /** POST /v1/agents/{uid}/heartbeat — agent-JWT only. */
-    heartbeat(agentUid: string, components: Record<string, "ok" | "degraded" | "failed" | "unknown">): Promise<{
-        ok: boolean;
-        at?: string;
-        local?: boolean;
-    }>;
-    /** GET /v1/agents/{uid}/inbox → { messages } (agent-JWT only). */
-    pullInbox(agentUid: string): Promise<InboxItem[]>;
-    /** POST /v1/agents/{uid}/inbox/{messageId}/ack */
-    ackInbox(agentUid: string, messageId: string): Promise<void>;
-    /**
-     * POST /v1/agents/{uid}/jobs/{jobId}/runs/{messageId}/complete — report one
-     * fired run as finished. MANDATORY: nothing else clears the job's
-     * in-progress flag, so a run that is never reported makes every later fire
-     * of that job `skipped-overlap` for up to an hour.
-     */
-    completeJobRun(agentUid: string, jobId: string, messageId: string, completion: JobRunCompletion): Promise<void>;
-    /** GET /v1/agents/{uid}/jobs — the bot's own scheduled jobs (self-only). */
-    listJobs(agentUid: string): Promise<BotJobRecord[]>;
-    /** POST /v1/agents/{uid}/jobs — schedule a new job for the bot itself. */
-    createJob(agentUid: string, input: CreateJobInput): Promise<BotJobRecord>;
-    /** POST /v1/agents/{uid}/jobs/{jobId}/cancel — cancel and delete its schedule. */
-    cancelJob(agentUid: string, jobId: string): Promise<void>;
-    /** POST /v1/notify/dm — send as the bot (agent identity). */
-    sendDm(input: {
-        toPersonUid: string;
-        body: string;
-        rootEventId?: string;
-        audience?: "human" | "agent" | "both";
-    }): Promise<{
-        eventId?: string;
-        createdAt?: string;
-        state?: string;
-    }>;
-    /** POST|DELETE /v1/notify/reactions on a DM message (best-effort thinking status). */
-    setReaction(input: {
-        peerUid: string;
-        messageId: string;
-        emoji: string;
-    }, present: boolean): Promise<boolean>;
-    /**
-     * POST /v1/notify/channels/{id}/claims — first-claim-wins on a room unit.
-     * 200 → true (this bot answers), 409 THREAD_ALREADY_CLAIMED → false
-     * (someone else does). Anything else throws.
-     */
-    claimChannelUnit(channelId: string, unitId: string): Promise<boolean>;
-    /** POST /v1/notify/channels/{id}/messages — post in a room as the bot. */
-    sendChannelMessage(input: {
-        channelId: string;
-        body: string;
-        rootEventId?: string;
-    }): Promise<{
-        eventId?: string;
-        createdAt?: string;
-        rootEventId?: string;
-    }>;
-    /**
-     * POST /v1/notify/channels/{id}/agent-status — ephemeral "thinking" hint in
-     * a room (never durable; the server clears it on the next event). Best-effort.
-     */
-    postAgentStatus(channelId: string, status: string, threadRoot?: string): Promise<boolean>;
-    /**
-     * GET /v1/notify/channels/{id}/messages?limit=N — the newest N messages,
-     * returned oldest-first so they read as a transcript.
-     */
-    fetchChannelMessages(channelId: string, limit?: number): Promise<ChannelMessageSummary[]>;
-    /** POST /v1/agents — person identity creates a local bot (US-002). */
-    /** Promotion mutations must use a human owner token, not bot credentials. */
-    preparePromotion(agentUid: string, input: {
-        companyUid: string;
-        operationId: string;
-        snapshotSha256: string;
-    }): Promise<BotPromotionState>;
-    promotionDetails(agentUid: string, companyUid: string): Promise<{
-        promotion: BotPromotionState | null;
-        failure?: string;
-        pairing: {
-            url: string;
-            code: string;
-            capturedAt?: string;
-        } | null;
-    }>;
-    promotionStatus(agentUid: string, companyUid: string): Promise<BotPromotionState | null>;
-    resumePromotion(agentUid: string, input: {
-        companyUid: string;
-        operationId: string;
-    }): Promise<{
-        promotion: BotPromotionState;
-        pending: boolean;
-    }>;
-    confirmPromotionStopped(agentUid: string, input: {
-        companyUid: string;
-        operationId: string;
-        proof: string;
-    }): Promise<BotPromotionState>;
-    promotionUpload(agentUid: string, input: {
-        companyUid: string;
-        operationId: string;
-        sha256: string;
-        bytes: number;
-        kind: "snapshot" | "machine-credential";
-    }): Promise<{
-        promotion: BotPromotionState;
-        upload: BotPromotionUpload;
-    }>;
-    /**
-     * POST /v1/agents — a local bot identity. `kind` is the bot kind the cloud
-     * stores and enforces ("personal" acts as its owner through mirror-owner;
-     * "company" is evaluated as itself through its memberships). Default personal.
-     */
-    createLocalBot(input: {
-        name: string;
-        slug?: string;
-        kind?: "personal" | "company";
-        /** Company bots: the company it acts for, plus any further companies. The server makes it a member of each. */
-        companyUid?: string;
-        companyMemberships?: string[];
-        /**
-         * The bot's non-secret settings, kept by the cloud so a reinstall can
-         * rebuild it. Checked here too: the server 400s on any key that looks
-         * like a credential.
-         */
-        localConfig?: BotLocalConfig;
-    }): Promise<{
-        agent: AgentRecord;
-        identity: {
-            cognitoUsername: string;
-            secret: string;
-        };
-    }>;
-    /**
-     * POST /v1/agents/{uid}/credentials — owner-only, local bots only: mint a
-     * fresh machine secret for a bot this account already owns, so it can come
-     * back after a reinstall or move to another Mac.
-     *
-     * This ROTATES the secret: whatever machine held the bot before stops being
-     * able to authenticate as it (one machine runs a local bot at a time).
-     */
-    reissueCredentials(agentUid: string, input?: {
-        machineId?: string;
-        reason?: "reinstall" | "move";
-    }): Promise<ReissuedBotCredentials>;
-    /**
-     * GET /v1/agents/mine — the caller's own agents; `local: true` narrows it to
-     * the local bots they own in any company, which is what a restore works from.
-     */
-    listMine(opts?: {
-        local?: boolean;
-    }): Promise<MyLocalBot[]>;
-    /** DELETE /v1/agents/{uid} — owner tears the identity down. */
-    deleteLocalBot(agentUid: string): Promise<{
-        uid: string;
-        terminal: boolean;
-        compensations: string[];
-        failures?: Record<string, string>;
-        code?: string;
-    }>;
-}
-//# sourceMappingURL=api.d.ts.map

package/dist/lib/bot/api.js

@@ -1,316 +0,0 @@
-/**
- * Typed HQ API client for the bot runtime (local-bots US-004).
- *
- * Every call goes through the shared `vaultApiFetch` helper with a token
- * supplier so the bot's machine identity (agt_) is minted and refreshed by the
- * existing Cognito machinery. `fetch` is injectable for tests.
- */
-import { vaultApiFetch } from "../../utils/vault-api.js";
-import { tokenAgentUid } from "../heartbeat-identity.js";
-import { assertNoSecretKeys } from "./local-config.js";
-import { isRecipientUid } from "../notify-recipient.js";
-export class BotApiError extends Error {
-    status;
-    path;
-    code;
-    detail;
-    retryAfterMs;
-    tokenAgentUid;
-    constructor(status, path, code, detail, retryAfterMs, tokenAgentUid) {
-        super(`HQ API ${path} → ${status}${code ? ` ${code}` : ""}${detail ? `: ${detail}` : ""}`);
-        this.status = status;
-        this.path = path;
-        this.code = code;
-        this.detail = detail;
-        this.retryAfterMs = retryAfterMs;
-        this.tokenAgentUid = tokenAgentUid;
-        this.name = "BotApiError";
-    }
-}
-export class InvalidDmRecipientError extends Error {
-    recipient;
-    constructor(recipient) {
-        super(`Invalid DM recipient '${recipient}': expected a prs_ or agt_ uid.`);
-        this.recipient = recipient;
-        this.name = "InvalidDmRecipientError";
-    }
-}
-/** Parse a Retry-After header (delta-seconds or HTTP-date) to milliseconds. */
-export function retryAfterHeaderMs(value, nowMs = Date.now()) {
-    if (!value)
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    const seconds = Number(trimmed);
-    if (Number.isFinite(seconds) && seconds >= 0) {
-        return Math.round(seconds * 1000);
-    }
-    const dateMs = Date.parse(trimmed);
-    if (!Number.isNaN(dateMs))
-        return Math.max(0, dateMs - nowMs);
-    return undefined;
-}
-async function readError(res) {
-    try {
-        const body = (await res.json());
-        return {
-            code: typeof body.code === "string" ? body.code : undefined,
-            detail: typeof body.error === "string"
-                ? body.error
-                : typeof body.message === "string"
-                    ? body.message
-                    : undefined,
-        };
-    }
-    catch {
-        return {};
-    }
-}
-export class BotApi {
-    opts;
-    fetchImpl;
-    constructor(opts) {
-        this.opts = opts;
-        this.fetchImpl = opts.fetchImpl ?? vaultApiFetch;
-    }
-    async call(path, init = {}, accept = [200, 201, 202]) {
-        const token = await this.opts.token();
-        const res = await this.fetchImpl({
-            token,
-            path,
-            method: init.method,
-            body: init.body,
-            query: init.query,
-            ...(this.opts.baseUrl ? { baseUrl: this.opts.baseUrl } : {}),
-        });
-        if (!accept.includes(res.status)) {
-            const err = await readError(res);
-            throw new BotApiError(res.status, path, err.code, err.detail, retryAfterHeaderMs(res.headers.get("Retry-After")), path.endsWith("/heartbeat") ? tokenAgentUid(token) : undefined);
-        }
-        const text = await res.text();
-        return { status: res.status, body: (text ? JSON.parse(text) : {}) };
-    }
-    /** GET /v1/agents/{uid} — owner-only local bot record (403/404 for others). */
-    async getAgent(agentUid) {
-        const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}`);
-        return body.agent ?? body;
-    }
-    /** POST /v1/agents/{uid}/heartbeat — agent-JWT only. */
-    async heartbeat(agentUid, components) {
-        const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/heartbeat`, { method: "POST", body: { components } });
-        return body;
-    }
-    /** GET /v1/agents/{uid}/inbox → { messages } (agent-JWT only). */
-    async pullInbox(agentUid) {
-        const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/inbox`);
-        return body.messages ?? body.items ?? [];
-    }
-    /** POST /v1/agents/{uid}/inbox/{messageId}/ack */
-    async ackInbox(agentUid, messageId) {
-        await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/inbox/${encodeURIComponent(messageId)}/ack`, { method: "POST", body: {} });
-    }
-    /**
-     * POST /v1/agents/{uid}/jobs/{jobId}/runs/{messageId}/complete — report one
-     * fired run as finished. MANDATORY: nothing else clears the job's
-     * in-progress flag, so a run that is never reported makes every later fire
-     * of that job `skipped-overlap` for up to an hour.
-     */
-    async completeJobRun(agentUid, jobId, messageId, completion) {
-        await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/jobs/${encodeURIComponent(jobId)}/runs/${encodeURIComponent(messageId)}/complete`, {
-            method: "POST",
-            body: {
-                status: completion.status,
-                ...(completion.output !== undefined ? { output: completion.output } : {}),
-                ...(completion.disposition !== undefined ? { disposition: completion.disposition } : {}),
-            },
-        }, [200, 201, 202, 204]);
-    }
-    /** GET /v1/agents/{uid}/jobs — the bot's own scheduled jobs (self-only). */
-    async listJobs(agentUid) {
-        const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/jobs`);
-        return body.jobs ?? [];
-    }
-    /** POST /v1/agents/{uid}/jobs — schedule a new job for the bot itself. */
-    async createJob(agentUid, input) {
-        const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/jobs`, {
-            method: "POST",
-            body: {
-                prompt: input.prompt,
-                ...(input.context ? { context: input.context } : {}),
-                ...(input.script ? { script: input.script } : {}),
-                schedule: input.schedule,
-            },
-        });
-        return body.job;
-    }
-    /** POST /v1/agents/{uid}/jobs/{jobId}/cancel — cancel and delete its schedule. */
-    async cancelJob(agentUid, jobId) {
-        await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/jobs/${encodeURIComponent(jobId)}/cancel`, { method: "POST", body: {} }, [200, 201, 202, 204]);
-    }
-    /** POST /v1/notify/dm — send as the bot (agent identity). */
-    async sendDm(input) {
-        const recipient = input.toPersonUid.trim();
-        if (!isRecipientUid(recipient))
-            throw new InvalidDmRecipientError(input.toPersonUid);
-        const payload = { toPersonUid: recipient, body: input.body };
-        if (input.rootEventId)
-            payload.rootEventId = input.rootEventId;
-        if (input.audience)
-            payload.audience = input.audience;
-        const { body } = await this.call("/v1/notify/dm", { method: "POST", body: payload });
-        return body;
-    }
-    /** POST|DELETE /v1/notify/reactions on a DM message (best-effort thinking status). */
-    async setReaction(input, present) {
-        try {
-            await this.call("/v1/notify/reactions", {
-                method: present ? "POST" : "DELETE",
-                body: { messageScope: `dm:${input.peerUid}`, messageId: input.messageId, emoji: input.emoji },
-            }, [200, 201, 204]);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * POST /v1/notify/channels/{id}/claims — first-claim-wins on a room unit.
-     * 200 → true (this bot answers), 409 THREAD_ALREADY_CLAIMED → false
-     * (someone else does). Anything else throws.
-     */
-    async claimChannelUnit(channelId, unitId) {
-        try {
-            await this.call(`/v1/notify/channels/${encodeURIComponent(channelId)}/claims`, { method: "POST", body: { unitId } }, [200]);
-            return true;
-        }
-        catch (err) {
-            if (err instanceof BotApiError && err.status === 409)
-                return false;
-            throw err;
-        }
-    }
-    /** POST /v1/notify/channels/{id}/messages — post in a room as the bot. */
-    async sendChannelMessage(input) {
-        const payload = { body: input.body };
-        if (input.rootEventId)
-            payload.rootEventId = input.rootEventId;
-        const { body } = await this.call(`/v1/notify/channels/${encodeURIComponent(input.channelId)}/messages`, { method: "POST", body: payload });
-        return body;
-    }
-    /**
-     * POST /v1/notify/channels/{id}/agent-status — ephemeral "thinking" hint in
-     * a room (never durable; the server clears it on the next event). Best-effort.
-     */
-    async postAgentStatus(channelId, status, threadRoot) {
-        try {
-            await this.call(`/v1/notify/channels/${encodeURIComponent(channelId)}/agent-status`, { method: "POST", body: { status, ...(threadRoot ? { threadRoot } : {}) } }, [200]);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * GET /v1/notify/channels/{id}/messages?limit=N — the newest N messages,
-     * returned oldest-first so they read as a transcript.
-     */
-    async fetchChannelMessages(channelId, limit = 15) {
-        const { body } = await this.call(`/v1/notify/channels/${encodeURIComponent(channelId)}/messages`, { query: { limit: String(limit) } });
-        const rows = Array.isArray(body.messages) ? body.messages : [];
-        const out = [];
-        for (const row of rows) {
-            const text = typeof row.body === "string" ? row.body.trim() : "";
-            if (!text)
-                continue;
-            out.push({
-                ...(typeof row.eventId === "string" ? { eventId: row.eventId } : {}),
-                ...(typeof row.fromPersonUid === "string" ? { fromPersonUid: row.fromPersonUid } : {}),
-                ...(typeof row.fromDisplayName === "string" && row.fromDisplayName.trim()
-                    ? { fromDisplayName: row.fromDisplayName.trim() }
-                    : {}),
-                body: text,
-                ...(typeof row.createdAt === "string" ? { createdAt: row.createdAt } : {}),
-            });
-        }
-        out.sort((a, b) => (a.createdAt ?? "").localeCompare(b.createdAt ?? ""));
-        return out;
-    }
-    /** POST /v1/agents — person identity creates a local bot (US-002). */
-    /** Promotion mutations must use a human owner token, not bot credentials. */
-    async preparePromotion(agentUid, input) {
-        return (await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/promote/prepare`, { method: "POST", body: input })).body.promotion;
-    }
-    async promotionDetails(agentUid, companyUid) {
-        return (await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/promote?companyUid=${encodeURIComponent(companyUid)}`, { method: "GET" })).body;
-    }
-    async promotionStatus(agentUid, companyUid) {
-        return (await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/promote?companyUid=${encodeURIComponent(companyUid)}`, { method: "GET" })).body.promotion;
-    }
-    async resumePromotion(agentUid, input) {
-        return (await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/promote/resume`, { method: "POST", body: input })).body;
-    }
-    async confirmPromotionStopped(agentUid, input) {
-        return (await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/promote/local-stopped`, { method: "POST", body: input })).body.promotion;
-    }
-    async promotionUpload(agentUid, input) {
-        return (await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/promote/snapshot-upload`, { method: "POST", body: input })).body;
-    }
-    /**
-     * POST /v1/agents — a local bot identity. `kind` is the bot kind the cloud
-     * stores and enforces ("personal" acts as its owner through mirror-owner;
-     * "company" is evaluated as itself through its memberships). Default personal.
-     */
-    async createLocalBot(input) {
-        if (input.localConfig)
-            assertNoSecretKeys(input.localConfig);
-        const { body } = await this.call("/v1/agents", {
-            method: "POST",
-            body: {
-                name: input.name,
-                ...(input.slug ? { slug: input.slug } : {}),
-                computeMode: "local",
-                botKind: input.kind ?? "personal",
-                ...(input.companyUid ? { companyUid: input.companyUid } : {}),
-                ...(input.companyMemberships?.length ? { companyMemberships: input.companyMemberships } : {}),
-                role: "local-bot",
-                ...(input.localConfig ? { localConfig: input.localConfig } : {}),
-            },
-        });
-        return body;
-    }
-    /**
-     * POST /v1/agents/{uid}/credentials — owner-only, local bots only: mint a
-     * fresh machine secret for a bot this account already owns, so it can come
-     * back after a reinstall or move to another Mac.
-     *
-     * This ROTATES the secret: whatever machine held the bot before stops being
-     * able to authenticate as it (one machine runs a local bot at a time).
-     */
-    async reissueCredentials(agentUid, input = {}) {
-        const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}/credentials`, {
-            method: "POST",
-            body: {
-                ...(input.machineId ? { machineId: input.machineId } : {}),
-                ...(input.reason ? { reason: input.reason } : {}),
-            },
-        }, [200]);
-        return { agent: body.agent, identity: body.identity, localConfig: body.localConfig ?? null };
-    }
-    /**
-     * GET /v1/agents/mine — the caller's own agents; `local: true` narrows it to
-     * the local bots they own in any company, which is what a restore works from.
-     */
-    async listMine(opts = {}) {
-        const { body } = await this.call("/v1/agents/mine", {
-            ...(opts.local ? { query: { local: "1" } } : {}),
-        });
-        return Array.isArray(body.agents) ? body.agents : [];
-    }
-    /** DELETE /v1/agents/{uid} — owner tears the identity down. */
-    async deleteLocalBot(agentUid) {
-        const { body } = await this.call(`/v1/agents/${encodeURIComponent(agentUid)}`, { method: "DELETE" });
-        return body;
-    }
-}
-//# sourceMappingURL=api.js.map