@zeroroot-ai/zerocool-claude 0.5.2 → 0.6.0

package/dist/cli.d.ts

@@ -1,88 +0,0 @@
-import { type ChildProcess } from "node:child_process";
-/**
- * The `gibson` CLI as the session's user. It holds the login session
- * (`gibson login`, a browser device flow), so it is the one process on the
- * host that can mint an enrollment token or create a target. The plugin
- * drives it instead of asking a person to copy tokens between terminals.
- */
-export type Spawn = (cmd: string, args: string[], opts: {
-    detached?: boolean;
-    env?: NodeJS.ProcessEnv;
-}) => ChildProcess;
-export interface CliOptions {
-    bin?: string;
-    env?: NodeJS.ProcessEnv;
-    spawn?: Spawn;
-    timeoutMs?: number;
-}
-export interface CliResult {
-    code: number;
-    stdout: string;
-    stderr: string;
-}
-export declare function runGibson(args: string[], opts?: CliOptions): Promise<CliResult>;
-/** True when the CLI's failure reads as "no login session". */
-export declare function needsLogin(r: CliResult): boolean;
-/**
- * `gibson agent enroll`: mint a one-time bootstrap token for a new machine
- * identity, authenticated as the person who ran `gibson login`.
- */
-/**
- * The session capabilities an interactive coding agent needs in its
- * credential's ceiling (ADR-0045): it starts its own live mission
- * (gibson#1593 decision 9) and may hand sub-tasks to other agents.
- */
-export declare const INTERACTIVE_AGENT_CAPABILITIES: readonly ["mission:originate", "mission:delegate"];
-export declare function enrollIdentity(name: string, opts?: CliOptions & {
-    gibsonURL?: string;
-    tenant?: string;
-    capabilities?: readonly string[];
-}): Promise<string>;
-export interface Target {
-    id: string;
-    name: string;
-    type: string;
-    status: string;
-}
-/** `gibson target list`, a tabwriter table: UUID NAME TYPE STATUS. */
-export declare function parseTargetList(stdout: string): Target[];
-export declare function listTargets(opts?: CliOptions & {
-    gibsonURL?: string;
-    tenant?: string;
-}): Promise<Target[]>;
-/**
- * `gibson target create`: prints the new target id. The daemon refuses a
- * target with neither a URL nor connection parameters, so the URL is
- * required here: for a coding workspace it names the repository.
- */
-export declare function createTarget(name: string, url: string, opts?: CliOptions & {
-    gibsonURL?: string;
-    tenant?: string;
-    type?: string;
-}): Promise<string>;
-export interface LoginPrompt {
-    url: string;
-    code: string;
-}
-/**
- * `gibson login`: a browser device flow. The CLI prints a URL and a code, then
- * waits for the approval. This starts it detached, returns the URL and code
- * as soon as they appear, and leaves the CLI waiting so the session lands in
- * `~/.gibson/auth/credentials` when the person approves.
- */
-export declare function startLogin(opts?: CliOptions & {
-    gibsonURL?: string;
-}): Promise<LoginPrompt>;
-/**
- * The person originates the session mission. A component may originate a
- * mission only from inside one it was dispatched to (gibson ADR-0063), and an
- * interactive session has no parent mission, so the definition goes through
- * the CLI's login session: `gibson mission submit` validates it, registers it
- * and runs it, then prints the mission id. The daemon dispatches the one AGENT
- * node to this component, which must already be checked in.
- */
-export declare function submitMission(definition: unknown, targetId: string, opts?: CliOptions & {
-    gibsonURL?: string;
-    tenant?: string;
-    dir?: string;
-}): Promise<string>;

package/dist/cli.js

@@ -1,186 +0,0 @@
-import { spawn as nodeSpawn } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-export async function runGibson(args, opts = {}) {
-    const spawn = opts.spawn ?? nodeSpawn;
-    const child = spawn(opts.bin ?? opts.env?.GIBSON_CLI ?? "gibson", args, { env: opts.env ?? process.env });
-    return await new Promise((resolve, reject) => {
-        const out = [];
-        const err = [];
-        const timer = setTimeout(() => {
-            child.kill();
-            reject(new Error(`gibson ${args[0] ?? ""} ${args[1] ?? ""} timed out after ${opts.timeoutMs ?? 60_000}ms`));
-        }, opts.timeoutMs ?? 60_000);
-        child.stdout?.on("data", (d) => out.push(d.toString()));
-        child.stderr?.on("data", (d) => err.push(d.toString()));
-        child.on("error", (e) => {
-            clearTimeout(timer);
-            reject(new Error(`cannot run the gibson CLI (${e.message}). Install it: see https://github.com/zeroroot-ai/adk`));
-        });
-        child.on("exit", (code) => {
-            clearTimeout(timer);
-            resolve({ code: code ?? -1, stdout: out.join(""), stderr: err.join("") });
-        });
-    });
-}
-/** True when the CLI's failure reads as "no login session". */
-export function needsLogin(r) {
-    return /login|credentials|unauthenticated|token expired|not signed in/i.test(r.stderr + r.stdout);
-}
-/**
- * `gibson agent enroll`: mint a one-time bootstrap token for a new machine
- * identity, authenticated as the person who ran `gibson login`.
- */
-/**
- * The session capabilities an interactive coding agent needs in its
- * credential's ceiling (ADR-0045): it starts its own live mission
- * (gibson#1593 decision 9) and may hand sub-tasks to other agents.
- */
-export const INTERACTIVE_AGENT_CAPABILITIES = ["mission:originate", "mission:delegate"];
-export async function enrollIdentity(name, opts = {}) {
-    const args = ["agent", "enroll", "--name", name, "--kind", "agent"];
-    for (const c of opts.capabilities ?? INTERACTIVE_AGENT_CAPABILITIES)
-        args.push("--capability", c);
-    if (opts.gibsonURL)
-        args.push("--gibson-url", opts.gibsonURL);
-    if (opts.tenant)
-        args.push("--tenant", opts.tenant);
-    const r = await runGibson(args, opts);
-    const m = /^bootstrap_token:\s*(\S+)/m.exec(r.stdout);
-    if (r.code !== 0 || !m) {
-        const why = (r.stderr || r.stdout).trim();
-        throw new Error(needsLogin(r)
-            ? `the gibson CLI has no login session (${why}). Call gibson_login first.`
-            : `gibson agent enroll failed (exit ${r.code}): ${why || "no bootstrap_token in the output"}`);
-    }
-    return m[1];
-}
-/** `gibson target list`, a tabwriter table: UUID NAME TYPE STATUS. */
-export function parseTargetList(stdout) {
-    return stdout
-        .split("\n")
-        .map((l) => l.trim())
-        .filter((l) => l && !/^UUID\s+NAME/.test(l))
-        .map((l) => l.split(/\s{2,}|\t/))
-        .filter((cols) => cols.length >= 2)
-        .map(([id, name, type, status]) => ({ id: id, name: name ?? "", type: type ?? "", status: status ?? "" }));
-}
-export async function listTargets(opts = {}) {
-    const args = ["target", "list"];
-    if (opts.gibsonURL)
-        args.push("--gibson-url", opts.gibsonURL);
-    if (opts.tenant)
-        args.push("--tenant", opts.tenant);
-    const r = await runGibson(args, opts);
-    if (r.code !== 0) {
-        const why = (r.stderr || r.stdout).trim();
-        throw new Error(needsLogin(r) ? `the gibson CLI has no login session (${why}). Call gibson_login first.` : `gibson target list failed: ${why}`);
-    }
-    return parseTargetList(r.stdout);
-}
-/**
- * `gibson target create`: prints the new target id. The daemon refuses a
- * target with neither a URL nor connection parameters, so the URL is
- * required here: for a coding workspace it names the repository.
- */
-export async function createTarget(name, url, opts = {}) {
-    const args = ["target", "create", "--name", name, "--url", url, "--type", opts.type ?? "custom"];
-    if (opts.gibsonURL)
-        args.push("--gibson-url", opts.gibsonURL);
-    if (opts.tenant)
-        args.push("--tenant", opts.tenant);
-    const r = await runGibson(args, opts);
-    const id = r.stdout.trim().split("\n").pop()?.trim() ?? "";
-    if (r.code !== 0 || !id) {
-        const why = (r.stderr || r.stdout).trim();
-        throw new Error(needsLogin(r) ? `the gibson CLI has no login session (${why}). Call gibson_login first.` : `gibson target create failed: ${why}`);
-    }
-    return id;
-}
-/**
- * `gibson login`: a browser device flow. The CLI prints a URL and a code, then
- * waits for the approval. This starts it detached, returns the URL and code
- * as soon as they appear, and leaves the CLI waiting so the session lands in
- * `~/.gibson/auth/credentials` when the person approves.
- */
-export async function startLogin(opts = {}) {
-    const spawn = opts.spawn ?? nodeSpawn;
-    const args = ["login"];
-    if (opts.gibsonURL)
-        args.push("--gibson-url", opts.gibsonURL);
-    const child = spawn(opts.bin ?? opts.env?.GIBSON_CLI ?? "gibson", args, { detached: true, env: opts.env ?? process.env });
-    return await new Promise((resolve, reject) => {
-        let buf = "";
-        const timer = setTimeout(() => {
-            child.kill();
-            reject(new Error(`gibson login printed no device code within ${opts.timeoutMs ?? 30_000}ms: ${buf.trim()}`));
-        }, opts.timeoutMs ?? 30_000);
-        const check = () => {
-            const url = /open:\s*\n?\s*(https?:\/\/\S+)/.exec(buf);
-            const code = /confirm this code:\s*(\S+)/.exec(buf);
-            if (url && code) {
-                clearTimeout(timer);
-                child.unref();
-                resolve({ url: url[1], code: code[1] });
-            }
-        };
-        child.stdout?.on("data", (d) => {
-            buf += d.toString();
-            check();
-        });
-        child.stderr?.on("data", (d) => {
-            buf += d.toString();
-            check();
-        });
-        child.on("error", (e) => {
-            clearTimeout(timer);
-            reject(new Error(`cannot run the gibson CLI (${e.message}). Install it: see https://github.com/zeroroot-ai/adk`));
-        });
-        child.on("exit", (code) => {
-            clearTimeout(timer);
-            reject(new Error(`gibson login exited with ${code} before printing a device code: ${buf.trim()}`));
-        });
-    });
-}
-const UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/g;
-/**
- * The person originates the session mission. A component may originate a
- * mission only from inside one it was dispatched to (gibson ADR-0063), and an
- * interactive session has no parent mission, so the definition goes through
- * the CLI's login session: `gibson mission submit` validates it, registers it
- * and runs it, then prints the mission id. The daemon dispatches the one AGENT
- * node to this component, which must already be checked in.
- */
-export async function submitMission(definition, targetId, opts = {}) {
-    const dir = await mkdtemp(join(opts.dir ?? tmpdir(), "zerocool-claude-mission-"));
-    const file = join(dir, "session.json");
-    try {
-        await writeFile(file, JSON.stringify(definition), { mode: 0o600 });
-        // --detach: the CLI returns once the daemon started the run and prints the
-        // mission id. Without it the CLI holds the RunMission stream until the
-        // mission ends, which never happens: this process must go on to claim the
-        // dispatch, and the CLI's own deadline fires first.
-        const args = ["mission", "submit", file, "--format", "json", "--target", targetId, "--detach"];
-        if (opts.gibsonURL)
-            args.push("--gibson-url", opts.gibsonURL);
-        if (opts.tenant)
-            args.push("--tenant", opts.tenant);
-        const r = await runGibson(args, { ...opts, timeoutMs: opts.timeoutMs ?? 120_000 });
-        if (r.code !== 0) {
-            if (needsLogin(r))
-                throw new Error("the gibson CLI has no session; run gibson_login first");
-            if (/unknown flag: --detach/.test(r.stderr))
-                throw new Error("the gibson CLI is too old for mission submit --detach; update the gibson CLI (adk >= 0.109)");
-            throw new Error(`gibson mission submit failed (exit ${r.code}): ${(r.stderr || r.stdout).trim().slice(0, 400)}`);
-        }
-        const ids = r.stdout.match(UUID) ?? [];
-        const missionId = ids[ids.length - 1];
-        if (!missionId)
-            throw new Error(`gibson mission submit printed no mission id: ${r.stdout.trim().slice(0, 400)}`);
-        return missionId;
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true });
-    }
-}

package/dist/config.d.ts

@@ -1,44 +0,0 @@
-/**
- * Where a session learns how to reach Gibson, in precedence order:
- *
- *  1. the environment (`GIBSON_*`), for people who script it,
- *  2. the plugin config this plugin wrote after a `gibson_connect`,
- *  3. the `gibson` CLI login session (`~/.gibson/auth/credentials`), which
- *     already knows the platform URL, the active tenant and the private CA.
- *
- * So a person who ran `gibson login` once needs nothing else: the plugin
- * finds the platform through the same session the CLI uses.
- */
-export interface PluginConfig {
-    platformURL?: string;
-    daemonURL?: string;
-    targetId?: string;
-    caCertPath?: string;
-    callbackInsecure?: boolean;
-}
-export interface CliCredentials {
-    gibsonURL?: string;
-    tenant?: string;
-    caCertPath?: string;
-}
-export interface Settings {
-    platformURL?: string;
-    daemonURL?: string;
-    targetId?: string;
-    caCertPath?: string;
-    callbackInsecure: boolean;
-    bootstrapToken?: string;
-    hostKeyPath: string;
-    agentName: string;
-    tenant?: string;
-}
-export declare const DEFAULT_AGENT_NAME = "zerocool-claude";
-export declare function configPath(env: NodeJS.ProcessEnv): string;
-export declare function readConfig(env: NodeJS.ProcessEnv): Promise<PluginConfig>;
-/** Merge and persist. Only the keys given change. */
-export declare function writeConfig(env: NodeJS.ProcessEnv, patch: PluginConfig): Promise<PluginConfig>;
-export declare function cliCredentialsPath(env: NodeJS.ProcessEnv): string;
-/** The `gibson` CLI login session, addressing fields only. Tokens are never read. */
-export declare function cliCredentials(env: NodeJS.ProcessEnv): Promise<CliCredentials | undefined>;
-export declare function resolveSettings(env: NodeJS.ProcessEnv, cfg: PluginConfig, creds: CliCredentials | undefined): Settings;
-export declare function loadSettings(env: NodeJS.ProcessEnv): Promise<Settings>;

package/dist/config.js

@@ -1,53 +0,0 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { stateDir } from "./state.js";
-export const DEFAULT_AGENT_NAME = "zerocool-claude";
-export function configPath(env) {
-    return join(stateDir(env), "config.json");
-}
-export async function readConfig(env) {
-    try {
-        return JSON.parse(await readFile(configPath(env), "utf8"));
-    }
-    catch {
-        return {};
-    }
-}
-/** Merge and persist. Only the keys given change. */
-export async function writeConfig(env, patch) {
-    const merged = { ...(await readConfig(env)), ...patch };
-    await mkdir(stateDir(env), { recursive: true, mode: 0o700 });
-    await writeFile(configPath(env), `${JSON.stringify(merged, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-    return merged;
-}
-export function cliCredentialsPath(env) {
-    return env.GIBSON_CLI_CREDENTIALS ?? join(homedir(), ".gibson", "auth", "credentials");
-}
-/** The `gibson` CLI login session, addressing fields only. Tokens are never read. */
-export async function cliCredentials(env) {
-    try {
-        const raw = JSON.parse(await readFile(cliCredentialsPath(env), "utf8"));
-        const str = (k) => (typeof raw[k] === "string" && raw[k] ? raw[k] : undefined);
-        return { gibsonURL: str("gibson_url"), tenant: str("active_tenant"), caCertPath: str("ca_cert_path") };
-    }
-    catch {
-        return undefined;
-    }
-}
-export function resolveSettings(env, cfg, creds) {
-    return {
-        platformURL: env.GIBSON_PLATFORM_URL ?? cfg.platformURL ?? creds?.gibsonURL,
-        daemonURL: env.GIBSON_DAEMON_URL ?? cfg.daemonURL,
-        targetId: env.GIBSON_TARGET_ID ?? cfg.targetId,
-        caCertPath: env.GIBSON_CA_CERT ?? cfg.caCertPath ?? creds?.caCertPath,
-        callbackInsecure: env.GIBSON_CALLBACK_INSECURE === "1" || cfg.callbackInsecure === true,
-        bootstrapToken: env.GIBSON_BOOTSTRAP_TOKEN,
-        hostKeyPath: env.GIBSON_HOST_KEY_PATH ?? join(homedir(), ".zerocool", "host.key"),
-        agentName: env.ZEROCOOL_AGENT_NAME ?? DEFAULT_AGENT_NAME,
-        tenant: creds?.tenant,
-    };
-}
-export async function loadSettings(env) {
-    return resolveSettings(env, await readConfig(env), await cliCredentials(env));
-}

package/dist/mode.d.ts

@@ -1,32 +0,0 @@
-/**
- * Which of three postures this process runs in. Pure: decided from what the
- * environment says and whether the host key exists, so it is testable and the
- * reasons are printed once at start instead of discovered per tool call.
- *
- *  - `standalone`: no platform. Findings go to a local log, componentize works.
- *  - `component`: checked in, no live mission. Reads and findings run under the
- *    component grant. No memory writes: a memory is a World observation and
- *    the World is written under a mission (gibson ADR-0012).
- *  - `live`: checked in, and this session is a mission (gibson#1593, decision 9).
- *  - `task`: a sandboxed dispatch (gibson ADR-0016). The launch injected the
- *    per-dispatch grant and the task; there is no check-in and no live
- *    mission to create, the mission already exists and this run is one of
- *    its nodes. Reads and writes use that grant.
- *
- * The postures are one path with fewer tools at each step down, the same
- * fail-open shape as the opencode plugin: a coding agent that cannot reach its
- * platform is still a working coding agent.
- */
-export type Mode = "standalone" | "component" | "live" | "task";
-export interface ModeDecision {
-    mode: Mode;
-    /** One line a person can act on. Empty when nothing is missing. */
-    reason: string;
-}
-export interface ModeInputs {
-    platformURL?: string;
-    bootstrapToken?: string;
-    hostKeyExists: boolean;
-    targetId?: string;
-}
-export declare function decideMode(env: ModeInputs, hostKeyPath: string): ModeDecision;

package/dist/mode.js

@@ -1,21 +0,0 @@
-export function decideMode(env, hostKeyPath) {
-    if (!env.platformURL) {
-        return { mode: "standalone", reason: "GIBSON_PLATFORM_URL is not set." };
-    }
-    if (!env.hostKeyExists && !env.bootstrapToken) {
-        return {
-            mode: "standalone",
-            reason: "GIBSON_PLATFORM_URL is set but this host has not checked in. Run `gibson login` then " +
-                "`gibson agent enroll`, and start once with GIBSON_BOOTSTRAP_TOKEN=<one-time token>. " +
-                `After that the host key at ${hostKeyPath} is enough.`,
-        };
-    }
-    if (!env.targetId) {
-        return {
-            mode: "component",
-            reason: "GIBSON_TARGET_ID is not set, so this session cannot be a live mission and cannot " +
-                "write memories. Create a target once (`gibson target create`) and set GIBSON_TARGET_ID.",
-        };
-    }
-    return { mode: "live", reason: "" };
-}

package/dist/sandbox-run.d.ts

@@ -1,26 +0,0 @@
-import { type SandboxDispatch } from "@zeroroot-ai/sdk";
-import { runClaude, type ClaudeRunResult } from "./claude-run.js";
-/**
- * The sandboxed-dispatch bin (gibson ADR-0016, #1621). gibson launches this
- * image once per mission run with the task, the per-dispatch grant and the
- * callback endpoint in the environment, and the tenant's own Anthropic key
- * as ANTHROPIC_API_KEY (the manifest's `credentials`). It runs Claude Code
- * headless with the Gibson MCP server attached in its task posture, streams
- * the NDJSON events to stdout for the live console, and exits 0 when the
- * run completed. Findings and memories reach the World through the
- * callbacks; there is no result blob.
- */
-export interface SandboxRunOptions {
-    env: NodeJS.ProcessEnv;
-    cwd: string;
-    run?: typeof runClaude;
-    onEvent?: (line: string) => void;
-}
-/** Everything the child claude and its MCP server need from the launch. */
-export declare function sandboxEnv(d: SandboxDispatch, env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-/** A `.js` path runs under node; anything else is a bin on PATH. */
-export declare function mcpServerSpec(bin: string): {
-    command: string;
-    args?: string[];
-};
-export declare function runSandbox(opts: SandboxRunOptions): Promise<ClaudeRunResult>;

package/dist/sandbox-run.js

@@ -1,42 +0,0 @@
-import { readSandboxDispatch, SANDBOX_ENV } from "@zeroroot-ai/sdk";
-import { runClaude } from "./claude-run.js";
-/** Everything the child claude and its MCP server need from the launch. */
-export function sandboxEnv(d, env) {
-    return {
-        ...env,
-        [SANDBOX_ENV.grant]: d.grant,
-        [SANDBOX_ENV.callbackEndpoint]: d.callbackEndpoint,
-        [SANDBOX_ENV.missionId]: d.missionId,
-        [SANDBOX_ENV.missionRunId]: d.missionRunId,
-        [SANDBOX_ENV.agentRunId]: d.agentRunId,
-        ...(d.traceId ? { [SANDBOX_ENV.traceId]: d.traceId } : {}),
-    };
-}
-/** A `.js` path runs under node; anything else is a bin on PATH. */
-export function mcpServerSpec(bin) {
-    return bin.endsWith(".js") ? { command: "node", args: [bin] } : { command: bin };
-}
-export async function runSandbox(opts) {
-    const d = readSandboxDispatch(opts.env);
-    if (!opts.env.ANTHROPIC_API_KEY) {
-        throw new Error("ANTHROPIC_API_KEY is not set. Headless Claude Code runs on an API key only; the catalog manifest " +
-            "declares it under credentials and the launch injects the tenant's own (gibson#1621, decision 12).");
-    }
-    const env = sandboxEnv(d, opts.env);
-    const run = opts.run ?? runClaude;
-    return await run({
-        goal: d.goal,
-        cwd: opts.cwd,
-        ...(opts.env.ZEROCOOL_CLAUDE_MODEL ? { model: opts.env.ZEROCOOL_CLAUDE_MODEL } : {}),
-        maxTurns: Number(opts.env.ZEROCOOL_CLAUDE_MAX_TURNS ?? 200),
-        ...(opts.env.ZEROCOOL_CLAUDE_MAX_BUDGET_USD ? { maxBudgetUsd: Number(opts.env.ZEROCOOL_CLAUDE_MAX_BUDGET_USD) } : {}),
-        appendSystemPrompt: "You run inside a Gibson mission sandbox. Record every real security finding with submit_finding, " +
-            "keep facts worth carrying to later runs with remember, and read prior context with recall. " +
-            "Work until the goal is met or clearly unreachable, then state the outcome.",
-        mcpServers: { gibson: mcpServerSpec(opts.env.ZEROCOOL_CLAUDE_MCP_BIN ?? "zerocool-claude-mcp") },
-        allowedTools: ["mcp__gibson__*"],
-        timeoutMs: Number(opts.env.ZEROCOOL_CLAUDE_TIMEOUT_MS ?? 0),
-        env,
-        ...(opts.onEvent ? { onEvent: opts.onEvent } : {}),
-    });
-}

package/dist/sandbox.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/sandbox.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import { runSandbox } from "./sandbox-run.js";
-/**
- * The sandboxed-dispatch bin. Runs unconditionally: npm installs it as a
- * symlink named zerocool-claude-dispatch. Library code lives in sandbox-run.ts.
- */
-async function main() {
-    const log = (l) => process.stderr.write(`[zerocool-claude-dispatch] ${l}\n`);
-    let result;
-    try {
-        result = await runSandbox({
-            env: process.env,
-            cwd: process.env.ZEROCOOL_WORKSPACE ?? process.cwd(),
-            onEvent: (line) => process.stdout.write(`${line}\n`),
-        });
-    }
-    catch (e) {
-        log(`run failed: ${e.message}`);
-        process.exit(1);
-        return;
-    }
-    if (result.mcpServerErrors.length > 0)
-        log(`MCP: ${result.mcpServerErrors.join("; ")}`);
-    log(`done turns=${result.numTurns} cost_usd=${result.costUsd.toFixed(4)} session=${result.sessionId || "-"} error=${result.isError}`);
-    process.exit(result.isError ? 1 : 0);
-}
-main().catch((e) => {
-    process.stderr.write(`[zerocool-claude-dispatch] fatal: ${e.message}\n`);
-    process.exit(1);
-});

package/dist/server.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/server.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { buildServer, log } from "./build.js";
-import { clearLive, stateDir } from "./state.js";
-import { describeGibson } from "./tools/status.js";
-/**
- * The MCP server bin. This file runs main() unconditionally: npm installs
- * bins as symlinks named after the bin (`zerocool-claude-mcp`), so any
- * "am I the entry point" check on argv[1] is false there and the process
- * exits before it serves anything. Library code lives in build.ts.
- */
-async function main() {
-    const cwd = process.cwd();
-    const surface = await buildServer(process.env, cwd);
-    const { server } = surface;
-    log(`[zerocool-claude] ${describeGibson(surface.current()).replaceAll("\n", "; ")}`);
-    let closing = false;
-    const close = async () => {
-        if (closing)
-            return;
-        closing = true;
-        await clearLive(stateDir(process.env), cwd).catch(() => { });
-        await surface.current().close().catch((e) => log(`[zerocool-claude] close: ${e.message}`));
-    };
-    // Claude Code ends the session by closing stdio. The mission ends with it.
-    process.stdin.on("close", () => void close().finally(() => process.exit(0)));
-    for (const sig of ["SIGINT", "SIGTERM"])
-        process.on(sig, () => void close().finally(() => process.exit(0)));
-    await server.connect(new StdioServerTransport());
-}
-main().catch((e) => {
-    log(`[zerocool-claude] fatal: ${e.message}`);
-    process.exit(1);
-});

package/dist/session.d.ts

@@ -1,34 +0,0 @@
-import { connectGibson, startLiveMission, type GibsonSession, type KnowledgeSource, type LiveMission, type MissionOriginator } from "@zeroroot-ai/sdk";
-import type { Settings } from "./config.js";
-import { type Mode } from "./mode.js";
-export { DEFAULT_AGENT_NAME } from "./config.js";
-/** Everything the tools need, decided once per connect. */
-export interface Gibson {
-    mode: Mode;
-    reason: string;
-    agentName: string;
-    hostKeyPath: string;
-    settings: Settings;
-    session?: GibsonSession;
-    live?: LiveMission;
-    knowledge?: KnowledgeSource;
-    /** Release the mission and the component registration. Idempotent. */
-    close(): Promise<void>;
-}
-export interface OpenGibsonOptions {
-    settings: Settings;
-    log: (line: string) => void;
-    /** The process environment, for the sandboxed-dispatch contract. */
-    env?: NodeJS.ProcessEnv;
-    /** Test seams. */
-    connect?: typeof connectGibson;
-    start?: typeof startLiveMission;
-    originate?: MissionOriginator;
-    hostKeyExists?: (path: string) => boolean;
-    trust?: (path: string) => Promise<void>;
-}
-/**
- * Check in, then make the session a live mission. Fails open at every step:
- * a platform failure lands one posture down, never in a refusal to start.
- */
-export declare function openGibson(opts: OpenGibsonOptions): Promise<Gibson>;