@alpacakit/agents 0.1.0-beta.39 → 0.2.0-beta.3

package/dist/agents/claude/session.js

@@ -0,0 +1,321 @@
+/**
+ * Claude session adapter: one `claude -p --input-format stream-json
+ * --output-format stream-json` process held open across turns.
+ *
+ * Protocol facts (claude 2.1.270, T52 / T61 lab runs):
+ * - a turn is one user line `{"type":"user","message":{"role":"user","content":…}}`
+ *   and ends with the `result` line; a user line written mid-turn is absorbed
+ *   into the running turn at its next tool boundary (`steer`);
+ * - `{"type":"control_request","request_id":…,"request":{"subtype":"interrupt"}}`
+ *   is answered by a `control_response`, and the turn then ends with
+ *   `is_error: true` / `terminal_reason: "aborted_tools"`;
+ * - approval prompts reach stdout only with `--permission-prompt-tool stdio`, as
+ *   `control_request` / `can_use_tool`, and are answered with a
+ *   `control_response` whose `behavior` is `allow` (+ `updatedInput`) or `deny`;
+ * - `--session-id <uuid>` fixes the id before the first turn (no `init` line
+ *   is emitted until then), `--resume <id>` continues a recorded one;
+ * - the child needs `USER` in its env: without it the CLI reports "Not logged in".
+ */
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { AGENT_ERROR_CODE, AgentError, TIMEOUT_KIND, } from "../../core/error.js";
+import { readJsonRecord, readNumber, readRecord, readString, } from "../../core/json.js";
+import { redactSecrets } from "../../core/redact.js";
+import { AGENT_EVENT_TYPE } from "../../core/run.js";
+import { APPROVAL_DECISION, SESSION_OWNER_KIND, TURN_OUTCOME, } from "../../core/session.js";
+import { fileExists, readDirectoryNames, readJsonFile, scanJsonlFirstLast, } from "../../host/session-files.js";
+import { assertHostSessionId, SessionProcess, driveSession, sessionStateError, } from "../../kernel/session.js";
+import { CLAUDE, CLAUDE_PERMISSION_MODE, parseClaudeRecord, permissionModeArgs, } from "./cli.js";
+const CONTROL_RESPONSE_TIMEOUT_MS = 30_000;
+const DECLINED_MESSAGE = "Declined by the session owner";
+function sessionArgs(permissions, target, options) {
+    return [
+        CLAUDE.cli.prompt,
+        CLAUDE.cli.inputFormat,
+        CLAUDE.cli.streamJson,
+        CLAUDE.cli.outputFormat,
+        CLAUDE.cli.streamJson,
+        CLAUDE.cli.verbose,
+        ...permissionModeArgs(permissions.mode),
+        CLAUDE.cli.permissionPromptTool,
+        CLAUDE.cli.stdio,
+        // A session's whole point is the recorded conversation, so `disabled`
+        // drops only the customization flags, never `--no-session-persistence`.
+        ...(options.customizations === "disabled"
+            ? [CLAUDE.cli.safeMode, CLAUDE.cli.strictMcpConfig]
+            : []),
+        target.kind === "resume" ? CLAUDE.cli.resume : CLAUDE.cli.sessionId,
+        target.sessionId,
+    ];
+}
+/**
+ * The Claude side of a Session: user lines and control requests out,
+ * stream-json records in. Control responses are correlated here (they
+ * answer this protocol's own requests); everything else is decoded into
+ * the driver's sink. Claude's stream carries no turn id, so the turn id
+ * is a per-session counter.
+ */
+class ClaudeProtocol {
+    process;
+    ctx;
+    pendingControls = new Map();
+    turnCount = 0;
+    interruptRequested = false;
+    incoming;
+    constructor(process, ctx) {
+        this.process = process;
+        this.ctx = ctx;
+        this.incoming = this.records();
+    }
+    get exit() {
+        return this.process.exit;
+    }
+    get stderrTail() {
+        return this.process.stderr;
+    }
+    async startTurn(text) {
+        this.turnCount += 1;
+        this.writeUserLine(text);
+        return String(this.turnCount);
+    }
+    async steer(_turnId, text) {
+        this.writeUserLine(text);
+    }
+    async interrupt() {
+        const requestId = randomUUID();
+        this.interruptRequested = true;
+        const answered = this.awaitControlResponse(requestId);
+        this.process.writeLine(JSON.stringify({
+            type: CLAUDE.json.type.controlRequest,
+            [CLAUDE.json.field.requestId]: requestId,
+            request: { subtype: CLAUDE.json.subtype.interrupt },
+        }));
+        try {
+            await answered;
+        }
+        catch (error) {
+            // An unanswered interrupt must not color the next turn's outcome.
+            this.interruptRequested = false;
+            throw error;
+        }
+    }
+    respond(approval, decision) {
+        const response = decision === APPROVAL_DECISION.accept
+            ? {
+                behavior: CLAUDE.json.behavior.allow,
+                updatedInput: approval.input,
+            }
+            : {
+                behavior: CLAUDE.json.behavior.deny,
+                message: DECLINED_MESSAGE,
+            };
+        this.process.writeLine(JSON.stringify({
+            type: CLAUDE.json.type.controlResponse,
+            response: {
+                subtype: CLAUDE.json.subtype.success,
+                [CLAUDE.json.field.requestId]: approval.requestId,
+                response,
+            },
+        }));
+    }
+    async close() {
+        await this.process.close();
+    }
+    decode(record, sink) {
+        const type = readString(record, CLAUDE.json.field.type);
+        if (type === CLAUDE.json.type.assistant) {
+            for (const event of parseClaudeRecord(record)) {
+                if (event.type === AGENT_EVENT_TYPE.message) {
+                    sink.message(event.text);
+                }
+                else if (event.type === AGENT_EVENT_TYPE.tool) {
+                    sink.tool(event.name);
+                }
+            }
+            return;
+        }
+        if (type === CLAUDE.json.type.result) {
+            const isError = record[CLAUDE.json.field.isError] === true;
+            const outcome = this.interruptRequested
+                ? TURN_OUTCOME.interrupted
+                : isError
+                    ? TURN_OUTCOME.failed
+                    : TURN_OUTCOME.completed;
+            this.interruptRequested = false;
+            sink.endTurn(outcome, readString(record, CLAUDE.json.field.result));
+            return;
+        }
+        if (type === CLAUDE.json.type.controlRequest) {
+            this.decodeControlRequest(record, sink);
+        }
+    }
+    writeUserLine(text) {
+        this.process.writeLine(JSON.stringify({
+            type: CLAUDE.json.type.user,
+            message: { role: CLAUDE.json.type.user, content: text },
+        }));
+    }
+    awaitControlResponse(requestId) {
+        return new Promise((resolve, reject) => {
+            const cancelTimeout = this.ctx.clock.setTimeout(() => {
+                this.pendingControls.delete(requestId);
+                reject(new AgentError({
+                    code: AGENT_ERROR_CODE.timeout,
+                    classification: AgentError.agentFailure(AGENT_ERROR_CODE.timeout),
+                    message: "Claude did not answer the control request in time",
+                    data: {
+                        kind: TIMEOUT_KIND.total,
+                        limitMs: CONTROL_RESPONSE_TIMEOUT_MS,
+                    },
+                    agentId: CLAUDE.id,
+                }));
+            }, CONTROL_RESPONSE_TIMEOUT_MS);
+            this.pendingControls.set(requestId, { resolve, reject, cancelTimeout });
+        });
+    }
+    /** stdout records minus the control responses, which are answered here; settles waiters when the child is gone. */
+    async *records() {
+        try {
+            for await (const line of this.process.lines()) {
+                const record = readJsonRecord(line);
+                if (record === null) {
+                    continue;
+                }
+                if (readString(record, CLAUDE.json.field.type) ===
+                    CLAUDE.json.type.controlResponse) {
+                    this.handleControlResponse(record);
+                    continue;
+                }
+                yield record;
+            }
+        }
+        finally {
+            for (const pending of this.pendingControls.values()) {
+                pending.cancelTimeout();
+                pending.reject(sessionStateError(CLAUDE.id, "session process exited"));
+            }
+            this.pendingControls.clear();
+            this.interruptRequested = false;
+        }
+    }
+    decodeControlRequest(record, sink) {
+        const requestId = readString(record, CLAUDE.json.field.requestId);
+        const request = readRecord(record, CLAUDE.json.field.request);
+        const subtype = request === null ? null : readString(request, CLAUDE.json.field.subtype);
+        if (requestId === null || request === null) {
+            return;
+        }
+        if (subtype !== CLAUDE.json.subtype.canUseTool) {
+            this.ctx.logger.log("warn", `ignoring unsupported claude control request "${subtype ?? "?"}"`);
+            return;
+        }
+        const toolName = readString(request, CLAUDE.json.field.toolName) ?? "";
+        const description = readString(request, CLAUDE.json.field.description);
+        sink.approvalRequested(requestId, description === null ? toolName : `${toolName} ${description}`, { requestId, input: request[CLAUDE.json.field.input] });
+    }
+    handleControlResponse(record) {
+        const response = readRecord(record, CLAUDE.json.field.response);
+        const requestId = response === null
+            ? null
+            : readString(response, CLAUDE.json.field.requestId);
+        if (response === null || requestId === null) {
+            return;
+        }
+        const pending = this.pendingControls.get(requestId);
+        if (pending === undefined) {
+            return;
+        }
+        this.pendingControls.delete(requestId);
+        pending.cancelTimeout();
+        if (readString(response, CLAUDE.json.field.subtype) ===
+            CLAUDE.json.subtype.error) {
+            pending.reject(sessionStateError(CLAUDE.id, redactSecrets(readString(response, CLAUDE.json.field.error) ??
+                "control request failed")));
+            return;
+        }
+        pending.resolve();
+    }
+}
+async function openClaudeSession(target, options, ctx, sessionOptions) {
+    const process = await SessionProcess.spawn({
+        command: CLAUDE.command,
+        args: sessionArgs(options.permissions, target, sessionOptions),
+        cwd: options.workspace,
+        ctx,
+        agentId: CLAUDE.id,
+    });
+    return driveSession({
+        id: target.sessionId,
+        agentId: CLAUDE.id,
+        protocol: new ClaudeProtocol(process, ctx),
+        logger: ctx.logger,
+    });
+}
+function claudeRoot(ctx, ...segments) {
+    return path.join(ctx.location.homeDir, CLAUDE.files.root, ...segments);
+}
+/** `~/.claude/projects/<encoded cwd>/<id>.jsonl` — the project directory name is not derivable, so scan. */
+async function findClaudeTranscript(ctx, id) {
+    const root = claudeRoot(ctx, CLAUDE.files.projects);
+    for (const project of await readDirectoryNames(root)) {
+        const candidate = path.join(root, project, `${id}${CLAUDE.files.transcriptExtension}`);
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/** `~/.claude/sessions/<pid>.json` — one file per live CLI process, keyed by pid. */
+async function claudeRegistryOwner(ctx, id) {
+    const root = claudeRoot(ctx, CLAUDE.files.sessions);
+    for (const name of await readDirectoryNames(root)) {
+        if (!name.endsWith(CLAUDE.files.registryExtension)) {
+            continue;
+        }
+        const entry = await readJsonFile(path.join(root, name));
+        if (entry === null || readString(entry, CLAUDE.files.sessionId) !== id) {
+            continue;
+        }
+        return {
+            kind: SESSION_OWNER_KIND.process,
+            pid: readNumber(entry, CLAUDE.files.pid),
+            entrypoint: readString(entry, CLAUDE.files.entrypoint),
+        };
+    }
+    return { kind: SESSION_OWNER_KIND.none };
+}
+function permissionModeFrom(value) {
+    return value !== null &&
+        Object.values(CLAUDE_PERMISSION_MODE).includes(value)
+        ? value
+        : null;
+}
+async function inspectClaudeSession(id, ctx) {
+    assertHostSessionId(id, CLAUDE.id);
+    const transcript = await findClaudeTranscript(ctx, id);
+    if (transcript === null) {
+        return null;
+    }
+    const cwd = await scanJsonlFirstLast(transcript, (record) => readString(record, CLAUDE.files.cwd));
+    if (cwd.first === null) {
+        return null;
+    }
+    const modes = await scanJsonlFirstLast(transcript, (record) => readString(record, CLAUDE.files.permissionMode));
+    const mode = permissionModeFrom(modes.last);
+    return {
+        workspace: cwd.first,
+        lastPermissions: mode === null ? null : { mode },
+        owner: await claudeRegistryOwner(ctx, id),
+        archived: false,
+    };
+}
+export function claudeSessions(options) {
+    return {
+        open: (resolved, ctx) => openClaudeSession({ kind: "new", sessionId: randomUUID() }, resolved, ctx, options),
+        resume: async (id, resolved, ctx) => {
+            assertHostSessionId(id, CLAUDE.id);
+            return openClaudeSession({ kind: "resume", sessionId: id }, resolved, ctx, options);
+        },
+        inspect: inspectClaudeSession,
+    };
+}

package/dist/agents/codex/cli.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The Codex vocabulary, spelled once: the `codex exec` flags, the app-server
+ * notification and file fields the session reads, the permission words, and
+ * the host's own file names. The run adapter (`index.ts`), the session
+ * adapter (`session.ts`), and the host plane (`host.ts`) all read from here;
+ * JSON-RPC method names and sandbox words come from `codex/protocol.ts`.
+ */
+import type { CODEX_SANDBOX_MODE } from "../../codex/protocol.js";
+export declare const CODEX_HOME_ENV_VAR = "CODEX_HOME";
+export declare const CODEX_API_KEY_ENV_VAR = "OPENAI_API_KEY";
+export declare const CODEX: {
+    readonly id: "codex";
+    readonly command: "codex";
+    readonly cli: {
+        readonly exec: "exec";
+        readonly model: "--model";
+        readonly config: "-c";
+        readonly reasoningEffortConfigKey: "model_reasoning_effort";
+        readonly json: "--json";
+        readonly skipGitRepoCheck: "--skip-git-repo-check";
+        readonly sandbox: "--sandbox";
+        readonly workspace: "-C";
+    };
+    readonly auth: {
+        readonly statusArgs: readonly ["login", "status"];
+        readonly oauthLoginArgs: readonly ["login"];
+        readonly deviceLoginArgs: readonly ["login", "--device-auth"];
+    };
+    readonly json: {
+        readonly field: {
+            readonly type: "type";
+            readonly text: "text";
+            readonly item: "item";
+        };
+        readonly event: {
+            readonly turnCompleted: "turn.completed";
+            readonly agentMessage: "agent_message";
+            readonly itemCompleted: "item.completed";
+        };
+    };
+    readonly mcp: {
+        readonly add: "add";
+        readonly env: "--env";
+        readonly executableSeparator: "--";
+        readonly mcp: "mcp";
+        readonly remove: "remove";
+    };
+    readonly notification: {
+        readonly threadId: "threadId";
+        readonly turnId: "turnId";
+        readonly turn: "turn";
+        readonly item: "item";
+        readonly id: "id";
+        readonly type: "type";
+        readonly text: "text";
+        readonly status: "status";
+        readonly items: "items";
+        readonly phase: "phase";
+        readonly finalAnswer: "final_answer";
+        readonly agentMessage: "agentMessage";
+        readonly userMessage: "userMessage";
+        readonly reasoning: "reasoning";
+        readonly command: "command";
+        readonly reason: "reason";
+    };
+    readonly turnStatus: {
+        readonly completed: "completed";
+        readonly interrupted: "interrupted";
+        readonly failed: "failed";
+    };
+    readonly decision: {
+        readonly accept: "accept";
+        readonly decline: "decline";
+    };
+    readonly error: {
+        readonly archived: "is archived";
+        readonly methodNotFound: -32601;
+        readonly unsupported: "unsupported server request";
+    };
+    readonly files: {
+        readonly root: ".codex";
+        readonly sessions: "sessions";
+        readonly archivedSessions: "archived_sessions";
+        readonly writerLocks: "thread-writer-locks";
+        readonly lockExtension: ".lock";
+        readonly rolloutExtension: ".jsonl";
+        readonly type: "type";
+        readonly payload: "payload";
+        readonly sessionMeta: "session_meta";
+        readonly turnContext: "turn_context";
+        readonly cwd: "cwd";
+        readonly approvalPolicy: "approval_policy";
+        readonly approvalsReviewer: "approvals_reviewer";
+        readonly sandboxPolicy: "sandbox_policy";
+        readonly writableRoots: "writable_roots";
+        readonly networkAccess: "network_access";
+        readonly excludeTmpdirEnvVar: "exclude_tmpdir_env_var";
+        readonly excludeSlashTmp: "exclude_slash_tmp";
+    };
+};
+/** `approval_policy` words (codex 0.153.4 `AskForApproval`; the granular object form is not modeled). */
+export declare const CODEX_APPROVAL_POLICY: {
+    readonly untrusted: "untrusted";
+    readonly onRequest: "on-request";
+    readonly never: "never";
+};
+export type CodexApprovalPolicy = (typeof CODEX_APPROVAL_POLICY)[keyof typeof CODEX_APPROVAL_POLICY];
+export declare const CODEX_APPROVALS_REVIEWER: {
+    readonly user: "user";
+    readonly autoReview: "auto_review";
+    readonly guardianSubagent: "guardian_subagent";
+};
+export type CodexApprovalsReviewer = (typeof CODEX_APPROVALS_REVIEWER)[keyof typeof CODEX_APPROVALS_REVIEWER];
+/** Spelled as the rollout's `turn_context.sandbox_policy` records it. */
+export type { CodexSandboxMode } from "../../codex/protocol.js";
+export type CodexSandboxPolicy = {
+    readonly type: typeof CODEX_SANDBOX_MODE.readOnly;
+} | {
+    readonly type: typeof CODEX_SANDBOX_MODE.dangerFullAccess;
+} | {
+    readonly type: typeof CODEX_SANDBOX_MODE.workspaceWrite;
+    readonly writableRoots: readonly string[];
+    readonly networkAccess: boolean;
+    readonly excludeTmpdirEnvVar: boolean;
+    readonly excludeSlashTmp: boolean;
+};
+export type CodexSessionPermissions = {
+    readonly approvalPolicy: CodexApprovalPolicy;
+    readonly approvalsReviewer: CodexApprovalsReviewer;
+    readonly sandbox: CodexSandboxPolicy;
+};
+//# sourceMappingURL=cli.d.ts.map

package/dist/agents/codex/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/agents/codex/cli.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAC/C,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAEtD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFR,CAAC;AAEX,yGAAyG;AACzG,eAAO,MAAM,qBAAqB;;;;CAIxB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAC7B,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAErE,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAChC,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAE3E,yEAAyE;AACzE,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,QAAQ,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,gBAAgB,CAAA;CAAE,GAC7D;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,cAAc,CAAC;IACxD,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC,CAAC;AAEN,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,sBAAsB,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;CACtC,CAAC"}

package/dist/agents/codex/cli.js

@@ -0,0 +1,110 @@
+/**
+ * The Codex vocabulary, spelled once: the `codex exec` flags, the app-server
+ * notification and file fields the session reads, the permission words, and
+ * the host's own file names. The run adapter (`index.ts`), the session
+ * adapter (`session.ts`), and the host plane (`host.ts`) all read from here;
+ * JSON-RPC method names and sandbox words come from `codex/protocol.ts`.
+ */
+export const CODEX_HOME_ENV_VAR = "CODEX_HOME";
+export const CODEX_API_KEY_ENV_VAR = "OPENAI_API_KEY";
+export const CODEX = {
+    id: "codex",
+    command: "codex",
+    cli: {
+        exec: "exec",
+        model: "--model",
+        config: "-c",
+        reasoningEffortConfigKey: "model_reasoning_effort",
+        json: "--json",
+        skipGitRepoCheck: "--skip-git-repo-check",
+        sandbox: "--sandbox",
+        workspace: "-C",
+    },
+    auth: {
+        // Exit-code-only login probe (E12): `codex login status` exits 0 when a
+        // credential is present, nonzero otherwise. The output format is not
+        // parsed — only the exit code decides valid/invalid, like claude's.
+        statusArgs: ["login", "status"],
+        oauthLoginArgs: ["login"],
+        deviceLoginArgs: ["login", "--device-auth"],
+    },
+    json: {
+        field: {
+            type: "type",
+            text: "text",
+            item: "item",
+        },
+        event: {
+            turnCompleted: "turn.completed",
+            agentMessage: "agent_message",
+            itemCompleted: "item.completed",
+        },
+    },
+    mcp: {
+        add: "add",
+        env: "--env",
+        executableSeparator: "--",
+        mcp: "mcp",
+        remove: "remove",
+    },
+    notification: {
+        threadId: "threadId",
+        turnId: "turnId",
+        turn: "turn",
+        item: "item",
+        id: "id",
+        type: "type",
+        text: "text",
+        status: "status",
+        items: "items",
+        phase: "phase",
+        finalAnswer: "final_answer",
+        agentMessage: "agentMessage",
+        userMessage: "userMessage",
+        reasoning: "reasoning",
+        command: "command",
+        reason: "reason",
+    },
+    turnStatus: {
+        completed: "completed",
+        interrupted: "interrupted",
+        failed: "failed",
+    },
+    decision: { accept: "accept", decline: "decline" },
+    error: {
+        archived: "is archived",
+        methodNotFound: -32601,
+        unsupported: "unsupported server request",
+    },
+    files: {
+        root: ".codex",
+        sessions: "sessions",
+        archivedSessions: "archived_sessions",
+        writerLocks: "thread-writer-locks",
+        lockExtension: ".lock",
+        rolloutExtension: ".jsonl",
+        type: "type",
+        payload: "payload",
+        sessionMeta: "session_meta",
+        turnContext: "turn_context",
+        cwd: "cwd",
+        approvalPolicy: "approval_policy",
+        approvalsReviewer: "approvals_reviewer",
+        sandboxPolicy: "sandbox_policy",
+        writableRoots: "writable_roots",
+        networkAccess: "network_access",
+        excludeTmpdirEnvVar: "exclude_tmpdir_env_var",
+        excludeSlashTmp: "exclude_slash_tmp",
+    },
+};
+/** `approval_policy` words (codex 0.153.4 `AskForApproval`; the granular object form is not modeled). */
+export const CODEX_APPROVAL_POLICY = {
+    untrusted: "untrusted",
+    onRequest: "on-request",
+    never: "never",
+};
+export const CODEX_APPROVALS_REVIEWER = {
+    user: "user",
+    autoReview: "auto_review",
+    guardianSubagent: "guardian_subagent",
+};

package/dist/agents/codex/host.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The codex host plane: auth materials and sign-in, skills and plugins
+ * through a short-lived app-server client, and MCP registration through
+ * the CLI. Outside a run and a session; every path comes from
+ * `HostContext.location`, never `os.homedir()`.
+ */
+import { type LoginCapability } from "../../auth/login.js";
+import type { MaterialHandlers } from "../../auth/material.js";
+import { type McpCapability, type SkillsCapability } from "../../host/capabilities.js";
+export declare const codexAuth: MaterialHandlers;
+export declare const codexLogin: LoginCapability;
+export declare const codexSkills: SkillsCapability;
+export declare const codexMcp: McpCapability;
+//# sourceMappingURL=host.d.ts.map

package/dist/agents/codex/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../../src/agents/codex/host.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAmB/D,OAAO,EAOL,KAAK,aAAa,EAKlB,KAAK,gBAAgB,EAEtB,MAAM,4BAA4B,CAAC;AAkOpC,eAAO,MAAM,SAAS,EAAE,gBAqBvB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,eAKxB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,gBAKzB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,aAMtB,CAAC"}