@pivanov/claude-wire 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pavel Ivanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# claude-wire
+
+Run [Claude Code](https://claude.ai/download) programmatically from TypeScript.
+
+[![npm](https://img.shields.io/npm/v/@pivanov/claude-wire)](https://www.npmjs.com/package/@pivanov/claude-wire)
+[![npm bundle size](https://img.shields.io/bundlephobia/minzip/@pivanov/claude-wire)](https://bundlephobia.com/package/@pivanov/claude-wire)
+[![license](https://img.shields.io/npm/l/claude-wire)](./LICENSE)
+
+```ts
+import { claude } from "@pivanov/claude-wire";
+
+const result = await claude.ask("Fix the bug in main.ts", {
+  model: "haiku",
+  maxCostUsd: 0.50,
+});
+
+console.log(result.text);     // "Fixed the undefined variable..."
+console.log(result.costUsd);  // 0.0084
+```
+
+## Features
+
+- **Simple API** - `claude.ask()` returns a typed result, `claude.stream()` yields events
+- **Tool control** - allow, block, or intercept any tool at runtime
+- **Multi-turn sessions** - persistent process across multiple prompts
+- **Cost tracking** - per-request budgets with auto-abort
+- **Fully typed** - discriminated union events, full IntelliSense
+- **Resilient** - auto-respawn, transient error detection, AbortSignal
+- **Zero dependencies** - 13 kB gzipped
+
+## Install
+
+```bash
+bun add @pivanov/claude-wire
+# or
+npm install @pivanov/claude-wire
+```
+
+Requires [Claude Code CLI](https://claude.ai/download) installed and authenticated. Runs on [Bun](https://bun.sh) >= 1.0 or Node.js >= 22.
+
+> This SDK wraps Claude Code's `--output-format stream-json` protocol, which is not officially documented by Anthropic and may change between releases.
+
+## Documentation
+
+Full docs, API reference, and protocol guide at **[pivanov.github.io/claude-wire](https://pivanov.github.io/claude-wire/)**
+
+## Try the Examples
+
+```bash
+git clone https://github.com/pivanov/claude-wire
+cd claude-wire && bun install
+bun run examples
+```
+
+Interactive menu with 8 runnable demos covering ask, streaming, sessions, tool control, cost budgets, abort, system prompts, and session resume.
+
+## Project Structure
+
+```
+packages/claude-wire/   the npm package
+apps/docs/              VitePress documentation site
+apps/examples/          interactive example runner
+```
+
+## Development
+
+```bash
+bun install
+bun run test        # 147 tests
+bun run typecheck
+bun run lint
+bun run docs:dev    # local docs server
+bun run examples    # try the examples
+```
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import type { IClaudeSession } from "./session.js";
+import type { IClaudeStream } from "./stream.js";
+import type { IClaudeOptions, ISessionOptions } from "./types/options.js";
+import type { TAskResult } from "./types/results.js";
+export interface IClaudeClient {
+    ask: (prompt: string, options?: IClaudeOptions) => Promise<TAskResult>;
+    stream: (prompt: string, options?: IClaudeOptions) => IClaudeStream;
+    session: (options?: ISessionOptions) => IClaudeSession;
+    create: (defaults: IClaudeOptions) => IClaudeClient;
+}
+export declare const createClient: (defaults?: IClaudeOptions) => IClaudeClient;

package/dist/client.js

@@ -0,0 +1,28 @@
+import { createSession } from "./session.js";
+import { createStream } from "./stream.js";
+const mergeOptions = (defaults, overrides) => ({
+    ...defaults,
+    ...overrides,
+    tools: overrides && "tools" in overrides ? (overrides.tools ? { ...defaults.tools, ...overrides.tools } : overrides.tools) : defaults.tools,
+    env: overrides && "env" in overrides ? (overrides.env ? { ...defaults.env, ...overrides.env } : overrides.env) : defaults.env,
+});
+export const createClient = (defaults = {}) => {
+    const ask = async (prompt, options) => {
+        const merged = mergeOptions(defaults, options);
+        const stream = createStream(prompt, merged);
+        return stream.result();
+    };
+    const stream = (prompt, options) => {
+        const merged = mergeOptions(defaults, options);
+        return createStream(prompt, merged);
+    };
+    const session = (options) => {
+        const merged = mergeOptions(defaults, options);
+        return createSession(merged);
+    };
+    const create = (newDefaults) => {
+        const merged = mergeOptions(defaults, newDefaults);
+        return createClient(merged);
+    };
+    return { ask, stream, session, create };
+};

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const TIMEOUTS: {
+    readonly defaultAbortMs: 300000;
+    readonly gracefulExitMs: 5000;
+};
+export declare const LIMITS: {
+    readonly maxRespawnAttempts: 3;
+    readonly sessionMaxTurnsBeforeRecycle: 100;
+    readonly ndjsonMaxLineChars: number;
+};
+export declare const BINARY: {
+    readonly name: "claude";
+    readonly commonPaths: readonly [`${string}/.local/bin/claude`, `${string}/.claude/bin/claude`, "/usr/local/bin/claude", "/opt/homebrew/bin/claude"];
+};

package/dist/constants.js

@@ -0,0 +1,15 @@
+import { homedir } from "node:os";
+export const TIMEOUTS = {
+    defaultAbortMs: 300_000,
+    gracefulExitMs: 5_000,
+};
+export const LIMITS = {
+    maxRespawnAttempts: 3,
+    sessionMaxTurnsBeforeRecycle: 100,
+    ndjsonMaxLineChars: 10 * 1024 * 1024,
+};
+const home = homedir();
+export const BINARY = {
+    name: "claude",
+    commonPaths: [`${home}/.local/bin/claude`, `${home}/.claude/bin/claude`, "/usr/local/bin/claude", "/opt/homebrew/bin/claude"],
+};

package/dist/cost.d.ts

@@ -0,0 +1,12 @@
+import type { TCostSnapshot } from "./types/results.js";
+export interface ICostTracker {
+    update: (totalCostUsd: number, totalInputTokens: number, totalOutputTokens: number) => void;
+    snapshot: () => TCostSnapshot;
+    checkBudget: () => void;
+    reset: () => void;
+}
+export interface ICostTrackerOptions {
+    maxCostUsd?: number;
+    onCostUpdate?: (cost: TCostSnapshot) => void;
+}
+export declare const createCostTracker: (options?: ICostTrackerOptions) => ICostTracker;

package/dist/cost.js

@@ -0,0 +1,36 @@
+import { assertPositiveNumber, BudgetExceededError } from "./errors.js";
+export const createCostTracker = (options = {}) => {
+    assertPositiveNumber(options.maxCostUsd, "maxCostUsd");
+    let totalUsd = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const snapshot = () => ({
+        totalUsd,
+        inputTokens,
+        outputTokens,
+    });
+    const update = (totalCostUsd, totalInputToks, totalOutputToks) => {
+        totalUsd = totalCostUsd;
+        inputTokens = totalInputToks;
+        outputTokens = totalOutputToks;
+        if (options.onCostUpdate) {
+            try {
+                options.onCostUpdate(snapshot());
+            }
+            catch {
+                // user callback error - don't crash the stream/session
+            }
+        }
+    };
+    const checkBudget = () => {
+        if (options.maxCostUsd !== undefined && totalUsd > options.maxCostUsd) {
+            throw new BudgetExceededError(totalUsd, options.maxCostUsd);
+        }
+    };
+    const reset = () => {
+        totalUsd = 0;
+        inputTokens = 0;
+        outputTokens = 0;
+    };
+    return { update, snapshot, checkBudget, reset };
+};

package/dist/errors.d.ts

@@ -0,0 +1,29 @@
+export declare class ClaudeError extends Error {
+    constructor(message: string);
+}
+export declare class BudgetExceededError extends ClaudeError {
+    readonly spent: number;
+    readonly budget: number;
+    constructor(spent: number, budget: number);
+}
+export declare class AbortError extends ClaudeError {
+    constructor(message?: string);
+}
+export declare class TimeoutError extends ClaudeError {
+    constructor(message?: string);
+}
+export declare class ProcessError extends ClaudeError {
+    readonly exitCode?: number | undefined;
+    constructor(message: string, exitCode?: number | undefined);
+}
+declare const KNOWN_ERROR_CODES: readonly ["not-authenticated", "binary-not-found", "session-expired", "permission-denied", "invalid-model"];
+type TKnownErrorCode = (typeof KNOWN_ERROR_CODES)[number];
+export declare class KnownError extends ClaudeError {
+    readonly code: TKnownErrorCode;
+    constructor(code: TKnownErrorCode, message?: string);
+}
+export declare const isKnownError: (error: unknown) => error is KnownError;
+export declare const isTransientError: (error: unknown) => boolean;
+export declare const errorMessage: (error: unknown) => string;
+export declare const assertPositiveNumber: (value: number | undefined, name: string) => void;
+export {};

package/dist/errors.js

@@ -0,0 +1,68 @@
+export class ClaudeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ClaudeError";
+    }
+}
+export class BudgetExceededError extends ClaudeError {
+    spent;
+    budget;
+    constructor(spent, budget) {
+        super(`Budget exceeded: $${spent.toFixed(4)} spent, $${budget.toFixed(4)} limit`);
+        this.spent = spent;
+        this.budget = budget;
+        this.name = "BudgetExceededError";
+    }
+}
+export class AbortError extends ClaudeError {
+    constructor(message = "Operation aborted") {
+        super(message);
+        this.name = "AbortError";
+    }
+}
+export class TimeoutError extends ClaudeError {
+    constructor(message = "Operation timed out") {
+        super(message);
+        this.name = "TimeoutError";
+    }
+}
+export class ProcessError extends ClaudeError {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "ProcessError";
+    }
+}
+const KNOWN_ERROR_CODES = ["not-authenticated", "binary-not-found", "session-expired", "permission-denied", "invalid-model"];
+export class KnownError extends ClaudeError {
+    code;
+    constructor(code, message) {
+        super(message ?? code);
+        this.code = code;
+        this.name = "KnownError";
+    }
+}
+export const isKnownError = (error) => {
+    return error instanceof KnownError;
+};
+const TRANSIENT_PATTERN = /fetch failed|ECONNREFUSED|ETIMEDOUT|ECONNRESET|EAI_AGAIN|network error|network timeout|EPIPE|SIGPIPE|broken pipe/i;
+export const isTransientError = (error) => {
+    if (error instanceof AbortError || error instanceof BudgetExceededError) {
+        return false;
+    }
+    if (error instanceof ProcessError) {
+        const transientCodes = [137, 143];
+        return error.exitCode !== undefined && transientCodes.includes(error.exitCode);
+    }
+    const message = errorMessage(error);
+    return TRANSIENT_PATTERN.test(message);
+};
+export const errorMessage = (error) => {
+    return error instanceof Error ? error.message : String(error);
+};
+export const assertPositiveNumber = (value, name) => {
+    if (value !== undefined && (!Number.isFinite(value) || value <= 0)) {
+        throw new ClaudeError(`${name} must be a finite positive number`);
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export type { IClaudeClient } from "./client.js";
+export { createClient } from "./client.js";
+export { BINARY, LIMITS, TIMEOUTS } from "./constants.js";
+export type { ICostTracker, ICostTrackerOptions } from "./cost.js";
+export { createCostTracker } from "./cost.js";
+export { AbortError, assertPositiveNumber, BudgetExceededError, ClaudeError, errorMessage, isKnownError, isTransientError, KnownError, ProcessError, TimeoutError, } from "./errors.js";
+export { blockFingerprint, extractContent, parseDoubleEncoded } from "./parser/content.js";
+export { parseLine } from "./parser/ndjson.js";
+export type { ITranslator } from "./parser/translator.js";
+export { createTranslator } from "./parser/translator.js";
+export type { IClaudeProcess, ISpawnOptions } from "./process.js";
+export { buildArgs, resetBinaryCache, spawnClaude } from "./process.js";
+export type { IReaderOptions } from "./reader.js";
+export { readNdjsonEvents } from "./reader.js";
+export type { IClaudeSession } from "./session.js";
+export { createSession } from "./session.js";
+export type { IClaudeStream } from "./stream.js";
+export { createStream } from "./stream.js";
+export type { IToolHandlerInstance, TToolDecision } from "./tools/handler.js";
+export { createToolHandler } from "./tools/handler.js";
+export { BUILT_IN_TOOLS, isBuiltInTool } from "./tools/registry.js";
+export type { TErrorEvent, TRelayEvent, TSessionMetaEvent, TTextEvent, TThinkingEvent, TToolResultEvent, TToolUseEvent, TTurnCompleteEvent, } from "./types/events.js";
+export type { IClaudeOptions, ISessionOptions, IToolHandler } from "./types/options.js";
+export type { TClaudeContent, TClaudeContentType, TClaudeEvent, TClaudeEventType, TClaudeMessage, TModelUsageEntry } from "./types/protocol.js";
+export type { TAskResult, TCostSnapshot } from "./types/results.js";
+export { writer } from "./writer.js";
+export declare const claude: import("./client.js").IClaudeClient;

package/dist/index.js

@@ -0,0 +1,16 @@
+export { createClient } from "./client.js";
+export { BINARY, LIMITS, TIMEOUTS } from "./constants.js";
+export { createCostTracker } from "./cost.js";
+export { AbortError, assertPositiveNumber, BudgetExceededError, ClaudeError, errorMessage, isKnownError, isTransientError, KnownError, ProcessError, TimeoutError, } from "./errors.js";
+export { blockFingerprint, extractContent, parseDoubleEncoded } from "./parser/content.js";
+export { parseLine } from "./parser/ndjson.js";
+export { createTranslator } from "./parser/translator.js";
+export { buildArgs, resetBinaryCache, spawnClaude } from "./process.js";
+export { readNdjsonEvents } from "./reader.js";
+export { createSession } from "./session.js";
+export { createStream } from "./stream.js";
+export { createToolHandler } from "./tools/handler.js";
+export { BUILT_IN_TOOLS, isBuiltInTool } from "./tools/registry.js";
+export { writer } from "./writer.js";
+import { createClient } from "./client.js";
+export const claude = createClient();

package/dist/parser/content.d.ts

@@ -0,0 +1,4 @@
+import type { TClaudeContent } from "../types/protocol.js";
+export declare const blockFingerprint: (block: TClaudeContent) => string;
+export declare const extractContent: (content: unknown) => string;
+export declare const parseDoubleEncoded: (value: unknown) => string;

package/dist/parser/content.js

@@ -0,0 +1,46 @@
+export const blockFingerprint = (block) => {
+    if (block.type === "tool_use" && block.id) {
+        return `tool_use:${block.id}`;
+    }
+    const text = block.type === "thinking" ? (block.thinking ?? block.text ?? "") : (block.text ?? "");
+    if (text) {
+        return `${block.type}:${text.slice(0, 64)}`;
+    }
+    return `${block.type}:${block.tool_use_id ?? "unknown"}`;
+};
+export const extractContent = (content) => {
+    if (content === null || content === undefined) {
+        return "";
+    }
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content
+            .filter((block) => typeof block === "object" && block !== null && "text" in block)
+            .map((block) => block.text)
+            .join("\n");
+    }
+    return "";
+};
+export const parseDoubleEncoded = (value) => {
+    if (typeof value !== "string") {
+        if (typeof value === "object" && value !== null) {
+            return JSON.stringify(value);
+        }
+        return String(value ?? "");
+    }
+    if (!value.startsWith('"')) {
+        return value;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "string") {
+            return parsed;
+        }
+        return value;
+    }
+    catch {
+        return value;
+    }
+};

package/dist/parser/ndjson.d.ts

@@ -0,0 +1,2 @@
+import type { TClaudeEvent } from "../types/protocol.js";
+export declare const parseLine: (line: string) => TClaudeEvent | undefined;

package/dist/parser/ndjson.js

@@ -0,0 +1,12 @@
+export const parseLine = (line) => {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+};

package/dist/parser/translator.d.ts

@@ -0,0 +1,7 @@
+import type { TRelayEvent } from "../types/events.js";
+import type { TClaudeEvent } from "../types/protocol.js";
+export interface ITranslator {
+    translate: (raw: TClaudeEvent) => TRelayEvent[];
+    reset: () => void;
+}
+export declare const createTranslator: () => ITranslator;

package/dist/parser/translator.js

@@ -0,0 +1,127 @@
+import { blockFingerprint, extractContent, parseDoubleEncoded } from "./content.js";
+const extractTokens = (modelUsage) => {
+    let inputTokens;
+    let outputTokens;
+    let contextWindow;
+    if (modelUsage) {
+        for (const entry of Object.values(modelUsage)) {
+            inputTokens = (inputTokens ?? 0) + entry.inputTokens + (entry.cacheReadInputTokens ?? 0) + (entry.cacheCreationInputTokens ?? 0);
+            outputTokens = (outputTokens ?? 0) + entry.outputTokens;
+            contextWindow = entry.contextWindow;
+        }
+    }
+    return { inputTokens, outputTokens, contextWindow };
+};
+const buildTurnComplete = (raw) => {
+    const { inputTokens, outputTokens, contextWindow } = extractTokens(raw.modelUsage);
+    return {
+        type: "turn_complete",
+        sessionId: raw.session_id,
+        costUsd: raw.total_cost_usd,
+        inputTokens,
+        outputTokens,
+        contextWindow,
+        durationMs: raw.duration_ms,
+    };
+};
+const translateContentBlock = (block) => {
+    switch (block.type) {
+        case "thinking": {
+            const content = block.thinking ?? block.text ?? "";
+            if (content) {
+                return { type: "thinking", content };
+            }
+            return undefined;
+        }
+        case "text": {
+            const content = block.text ?? "";
+            if (content) {
+                return { type: "text", content };
+            }
+            return undefined;
+        }
+        case "tool_use": {
+            if (!block.id) {
+                return undefined;
+            }
+            return {
+                type: "tool_use",
+                toolUseId: block.id,
+                toolName: block.name ?? "",
+                input: typeof block.input === "string" ? block.input : JSON.stringify(block.input ?? {}),
+            };
+        }
+        case "tool_result": {
+            return {
+                type: "tool_result",
+                toolUseId: block.tool_use_id ?? "",
+                output: extractContent(block.content),
+                isError: block.is_error ?? false,
+            };
+        }
+        default:
+            return undefined;
+    }
+};
+export const createTranslator = () => {
+    let lastContentIndex = 0;
+    let lastFirstBlockKey;
+    const reset = () => {
+        lastContentIndex = 0;
+        lastFirstBlockKey = undefined;
+    };
+    const translate = (raw) => {
+        const events = [];
+        if (raw.type === "system" && raw.subtype === "init") {
+            events.push({
+                type: "session_meta",
+                sessionId: raw.session_id ?? "",
+                model: raw.model ?? "",
+                tools: raw.tools ?? [],
+            });
+            return events;
+        }
+        if (raw.type === "result" || (raw.type === "system" && raw.subtype === "result")) {
+            if (raw.is_error) {
+                const text = parseDoubleEncoded(raw.result);
+                events.push({ type: "error", message: text, sessionId: raw.session_id });
+            }
+            events.push(buildTurnComplete(raw));
+            reset();
+            return events;
+        }
+        if (raw.type === "assistant" && raw.message?.content) {
+            const content = raw.message.content;
+            if (content.length > 0) {
+                const firstBlock = content[0];
+                if (firstBlock) {
+                    const key = blockFingerprint(firstBlock);
+                    if (lastFirstBlockKey !== undefined && key !== lastFirstBlockKey) {
+                        lastContentIndex = 0;
+                    }
+                    lastFirstBlockKey = key;
+                }
+            }
+            const newBlocks = content.slice(lastContentIndex);
+            lastContentIndex = content.length;
+            for (const block of newBlocks) {
+                const event = translateContentBlock(block);
+                if (event) {
+                    events.push(event);
+                }
+            }
+            return events;
+        }
+        if (raw.type === "user" && raw.message?.content) {
+            for (const block of raw.message.content) {
+                const event = translateContentBlock(block);
+                if (event) {
+                    events.push(event);
+                }
+            }
+            return events;
+        }
+        return events;
+    };
+    return { translate, reset };
+};

package/dist/pipeline.d.ts

@@ -0,0 +1,8 @@
+import type { ICostTracker } from "./cost.js";
+import type { IClaudeProcess } from "./process.js";
+import type { IToolHandlerInstance } from "./tools/handler.js";
+import type { TRelayEvent, TToolUseEvent } from "./types/events.js";
+import type { TAskResult } from "./types/results.js";
+export declare const dispatchToolDecision: (proc: IClaudeProcess, toolHandler: IToolHandlerInstance, event: TToolUseEvent) => Promise<void>;
+export declare const extractText: (events: TRelayEvent[]) => string;
+export declare const buildResult: (events: TRelayEvent[], costTracker: ICostTracker, sessionId: string | undefined) => TAskResult;

package/dist/pipeline.js

@@ -0,0 +1,47 @@
+import { writer } from "./writer.js";
+export const dispatchToolDecision = async (proc, toolHandler, event) => {
+    let decision;
+    try {
+        decision = await toolHandler.decide(event);
+    }
+    catch (error) {
+        console.warn(`[claude-wire] Tool handler threw, defaulting to deny: ${error instanceof Error ? error.message : String(error)}`);
+        decision = "deny";
+    }
+    try {
+        if (decision === "approve") {
+            proc.write(writer.approve(event.toolUseId));
+        }
+        else if (decision === "deny") {
+            proc.write(writer.deny(event.toolUseId));
+        }
+        else if (typeof decision === "object" && decision !== null && typeof decision.result === "string") {
+            proc.write(writer.toolResult(event.toolUseId, decision.result));
+        }
+        else {
+            console.warn("[claude-wire] Invalid tool decision, defaulting to deny");
+            proc.write(writer.deny(event.toolUseId));
+        }
+    }
+    catch {
+        // stdin closed - process died, error will surface through read path
+    }
+};
+export const extractText = (events) => {
+    return events
+        .filter((e) => e.type === "text")
+        .map((e) => e.content)
+        .join("");
+};
+export const buildResult = (events, costTracker, sessionId) => {
+    const tc = events.findLast((e) => e.type === "turn_complete");
+    const snap = costTracker.snapshot();
+    return {
+        text: extractText(events),
+        costUsd: snap.totalUsd,
+        tokens: { input: snap.inputTokens, output: snap.outputTokens },
+        duration: tc?.durationMs ?? 0,
+        sessionId,
+        events,
+    };
+};

package/dist/process.d.ts

@@ -0,0 +1,15 @@
+import type { IClaudeOptions } from "./types/options.js";
+export interface IClaudeProcess {
+    write: (message: string) => void;
+    kill: () => void;
+    exited: Promise<number>;
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    pid: number;
+}
+export interface ISpawnOptions extends IClaudeOptions {
+    prompt?: string;
+}
+export declare const resetBinaryCache: () => void;
+export declare const buildArgs: (options: ISpawnOptions, binaryPath: string) => string[];
+export declare const spawnClaude: (options: ISpawnOptions) => IClaudeProcess;