@pivanov/claude-wire 0.0.2

package/dist/stream.js

@@ -0,0 +1,130 @@
+import { createCostTracker } from "./cost.js";
+import { AbortError, ClaudeError, ProcessError } from "./errors.js";
+import { createTranslator } from "./parser/translator.js";
+import { buildResult, extractText } from "./pipeline.js";
+import { spawnClaude } from "./process.js";
+import { readNdjsonEvents } from "./reader.js";
+import { createToolHandler } from "./tools/handler.js";
+const drainStderr = (proc) => {
+    const chunks = [];
+    const stderrReader = proc.stderr.getReader();
+    const decoder = new TextDecoder();
+    const done = (async () => {
+        try {
+            while (true) {
+                const { done: isDone, value } = await stderrReader.read();
+                if (isDone) {
+                    break;
+                }
+                chunks.push(decoder.decode(value, { stream: true }));
+            }
+        }
+        catch {
+            // process exited
+        }
+        finally {
+            stderrReader.releaseLock();
+        }
+    })().catch(() => { });
+    return { chunks, done };
+};
+export const createStream = (prompt, options = {}) => {
+    if (options.signal?.aborted) {
+        throw new AbortError();
+    }
+    const proc = spawnClaude({ prompt, ...options });
+    const stderr = drainStderr(proc);
+    const translator = createTranslator();
+    const toolHandler = options.tools ? createToolHandler(options.tools) : undefined;
+    const costTracker = createCostTracker({
+        maxCostUsd: options.maxCostUsd,
+        onCostUpdate: options.onCostUpdate,
+    });
+    let cachedGenerator;
+    const generate = async function* () {
+        const stdoutReader = proc.stdout.getReader();
+        let turnComplete = false;
+        try {
+            for await (const event of readNdjsonEvents({
+                reader: stdoutReader,
+                translator,
+                toolHandler,
+                proc,
+                signal: options.signal,
+            })) {
+                if (event.type === "turn_complete") {
+                    costTracker.update(event.costUsd ?? 0, event.inputTokens ?? 0, event.outputTokens ?? 0);
+                    costTracker.checkBudget();
+                    turnComplete = true;
+                }
+                yield event;
+            }
+            if (!turnComplete) {
+                const exitCode = await proc.exited;
+                if (exitCode !== 0) {
+                    let errorMessage = `Claude process exited with code ${exitCode}`;
+                    await stderr.done;
+                    const stderrText = stderr.chunks.join("").trim();
+                    if (stderrText) {
+                        errorMessage = stderrText;
+                    }
+                    throw new ProcessError(errorMessage, exitCode);
+                }
+                throw new ProcessError("Process exited without completing the turn");
+            }
+        }
+        finally {
+            stdoutReader.releaseLock();
+            proc.kill();
+        }
+    };
+    const bufferedEvents = [];
+    let consumePromise;
+    const ensureConsumed = () => {
+        if (!consumePromise) {
+            if (cachedGenerator) {
+                throw new ClaudeError("Cannot call text()/cost()/result() after iterating with for-await. Use one or the other.");
+            }
+            consumePromise = (async () => {
+                cachedGenerator = generate();
+                for await (const event of { [Symbol.asyncIterator]: () => cachedGenerator }) {
+                    bufferedEvents.push(event);
+                }
+            })();
+        }
+        return consumePromise;
+    };
+    const text = async () => {
+        await ensureConsumed();
+        return extractText(bufferedEvents);
+    };
+    const cost = async () => {
+        await ensureConsumed();
+        return costTracker.snapshot();
+    };
+    const result = async () => {
+        await ensureConsumed();
+        const sessionId = bufferedEvents.find((e) => e.type === "session_meta")?.sessionId;
+        return buildResult(bufferedEvents, costTracker, sessionId);
+    };
+    const cleanup = () => {
+        if (!cachedGenerator) {
+            proc.kill();
+        }
+    };
+    return {
+        [Symbol.asyncIterator]: () => {
+            if (consumePromise) {
+                throw new ClaudeError("Cannot iterate after calling text()/cost()/result(). Use one or the other.");
+            }
+            cachedGenerator ??= generate();
+            return cachedGenerator;
+        },
+        text,
+        cost,
+        result,
+        [Symbol.asyncDispose]: async () => {
+            cleanup();
+        },
+    };
+};

package/dist/tools/handler.d.ts

@@ -0,0 +1,9 @@
+import type { TToolUseEvent } from "../types/events.js";
+import type { IToolHandler } from "../types/options.js";
+export type TToolDecision = "approve" | "deny" | {
+    result: string;
+};
+export interface IToolHandlerInstance {
+    decide: (tool: TToolUseEvent) => Promise<TToolDecision>;
+}
+export declare const createToolHandler: (options?: IToolHandler) => IToolHandlerInstance;

package/dist/tools/handler.js

@@ -0,0 +1,18 @@
+export const createToolHandler = (options = {}) => {
+    const { allowed, blocked, onToolUse } = options;
+    const allowedSet = allowed ? new Set(allowed) : undefined;
+    const blockedSet = blocked ? new Set(blocked) : undefined;
+    const decide = async (tool) => {
+        if (blockedSet?.has(tool.toolName)) {
+            return "deny";
+        }
+        if (allowedSet && !allowedSet.has(tool.toolName)) {
+            return "deny";
+        }
+        if (onToolUse) {
+            return onToolUse(tool);
+        }
+        return "approve";
+    };
+    return { decide };
+};

package/dist/tools/registry.d.ts

@@ -0,0 +1,2 @@
+export declare const BUILT_IN_TOOLS: Set<string>;
+export declare const isBuiltInTool: (name: string) => boolean;

package/dist/tools/registry.js

@@ -0,0 +1,42 @@
+// Best-effort snapshot of known Claude Code tools. May not be exhaustive.
+// For the authoritative list, check session_meta.tools from a live session.
+export const BUILT_IN_TOOLS = new Set([
+    "Read",
+    "Write",
+    "Edit",
+    "Bash",
+    "Glob",
+    "Grep",
+    "Agent",
+    "NotebookEdit",
+    "WebFetch",
+    "WebSearch",
+    "TodoRead",
+    "TodoWrite",
+    "TaskCreate",
+    "TaskUpdate",
+    "TaskGet",
+    "TaskList",
+    "TaskStop",
+    "TaskOutput",
+    "ToolSearch",
+    "Monitor",
+    "EnterPlanMode",
+    "ExitPlanMode",
+    "SendMessage",
+    "LSP",
+    "AskUserQuestion",
+    "Skill",
+    "CronCreate",
+    "CronDelete",
+    "CronList",
+    "RemoteTrigger",
+    "TeamCreate",
+    "TeamDelete",
+    "EnterWorktree",
+    "ExitWorktree",
+    "ScheduleWakeup",
+]);
+export const isBuiltInTool = (name) => {
+    return BUILT_IN_TOOLS.has(name);
+};

package/dist/types/events.d.ts

@@ -0,0 +1,41 @@
+export type TTextEvent = {
+    type: "text";
+    content: string;
+};
+export type TThinkingEvent = {
+    type: "thinking";
+    content: string;
+};
+export type TToolUseEvent = {
+    type: "tool_use";
+    toolUseId: string;
+    toolName: string;
+    input: string;
+};
+export type TToolResultEvent = {
+    type: "tool_result";
+    toolUseId: string;
+    output: string;
+    isError: boolean;
+};
+export type TSessionMetaEvent = {
+    type: "session_meta";
+    sessionId: string;
+    model: string;
+    tools: string[];
+};
+export type TTurnCompleteEvent = {
+    type: "turn_complete";
+    sessionId?: string;
+    costUsd?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    contextWindow?: number;
+    durationMs?: number;
+};
+export type TErrorEvent = {
+    type: "error";
+    message: string;
+    sessionId?: string;
+};
+export type TRelayEvent = TTextEvent | TThinkingEvent | TToolUseEvent | TToolResultEvent | TSessionMetaEvent | TTurnCompleteEvent | TErrorEvent;

package/dist/types/events.js

@@ -0,0 +1 @@
+export {};

package/dist/types/options.d.ts

@@ -0,0 +1,41 @@
+import type { TToolDecision } from "../tools/handler.js";
+import type { TToolUseEvent } from "./events.js";
+import type { TCostSnapshot } from "./results.js";
+export interface IToolHandler {
+    allowed?: string[];
+    blocked?: string[];
+    onToolUse?: (tool: TToolUseEvent) => Promise<TToolDecision>;
+}
+export interface IClaudeOptions {
+    cwd?: string;
+    model?: "opus" | "sonnet" | "haiku" | (string & {});
+    systemPrompt?: string;
+    appendSystemPrompt?: string;
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    tools?: IToolHandler;
+    maxCostUsd?: number;
+    maxBudgetUsd?: number;
+    onCostUpdate?: (cost: TCostSnapshot) => void;
+    signal?: AbortSignal;
+    resume?: string;
+    verbose?: boolean;
+    mcpConfig?: string;
+    continueSession?: boolean;
+    permissionMode?: "default" | "plan" | "auto" | "bypassPermissions" | "acceptEdits" | "dontAsk" | (string & {});
+    configDir?: string;
+    env?: Record<string, string>;
+    addDirs?: string[];
+    effort?: "low" | "medium" | "high" | "max";
+    includeHookEvents?: boolean;
+    includePartialMessages?: boolean;
+    bare?: boolean;
+    jsonSchema?: string;
+    forkSession?: boolean;
+    noSessionPersistence?: boolean;
+    sessionId?: string;
+    settingSources?: string;
+    disableSlashCommands?: boolean;
+}
+export interface ISessionOptions extends IClaudeOptions {
+}

package/dist/types/options.js

@@ -0,0 +1 @@
+export {};

package/dist/types/protocol.d.ts

@@ -0,0 +1,42 @@
+export type TModelUsageEntry = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens?: number;
+    cacheCreationInputTokens?: number;
+    contextWindow: number;
+};
+export type TClaudeContentType = "text" | "thinking" | "tool_use" | "tool_result" | (string & {});
+export type TClaudeContent = {
+    type: TClaudeContentType;
+    text?: string;
+    thinking?: string;
+    id?: string;
+    name?: string;
+    input?: unknown;
+    content?: unknown;
+    tool_use_id?: string;
+    is_error?: boolean;
+};
+export type TClaudeMessage = {
+    content: TClaudeContent[];
+    role?: string;
+    stop_reason?: string;
+};
+export type TClaudeEventType = "system" | "assistant" | "user" | "result" | "progress" | "rate_limit_event" | (string & {});
+export type TClaudeEvent = {
+    type: TClaudeEventType;
+    subtype?: string;
+    message?: TClaudeMessage;
+    result?: unknown;
+    session_id?: string;
+    model?: string;
+    tools?: string[];
+    duration_ms?: number;
+    duration_api_ms?: number;
+    cost_usd?: number;
+    total_cost_usd?: number;
+    is_error?: boolean;
+    num_turns?: number;
+    modelUsage?: Record<string, TModelUsageEntry>;
+    usage?: unknown;
+};

package/dist/types/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/types/results.d.ts

@@ -0,0 +1,17 @@
+import type { TRelayEvent } from "./events.js";
+export type TCostSnapshot = {
+    totalUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+};
+export type TAskResult = {
+    text: string;
+    costUsd: number;
+    tokens: {
+        input: number;
+        output: number;
+    };
+    duration: number;
+    sessionId?: string;
+    events: TRelayEvent[];
+};

package/dist/types/results.js

@@ -0,0 +1 @@
+export {};

package/dist/writer.d.ts

@@ -0,0 +1,7 @@
+export declare const writer: {
+    user: (content: string) => string;
+    approve: (toolUseId: string) => string;
+    deny: (toolUseId: string) => string;
+    toolResult: (toolUseId: string, content: string) => string;
+    abort: () => string;
+};

package/dist/writer.js

@@ -0,0 +1,26 @@
+import { ClaudeError } from "./errors.js";
+const ABORT_LINE = `${JSON.stringify({ type: "abort" })}\n`;
+const requireNonEmpty = (value, name) => {
+    if (!value) {
+        throw new ClaudeError(`${name} must be a non-empty string`);
+    }
+};
+export const writer = {
+    user: (content) => {
+        requireNonEmpty(content, "content");
+        return `${JSON.stringify({ type: "user", message: { role: "user", content } })}\n`;
+    },
+    approve: (toolUseId) => {
+        requireNonEmpty(toolUseId, "toolUseId");
+        return `${JSON.stringify({ type: "approve", tool_use_id: toolUseId })}\n`;
+    },
+    deny: (toolUseId) => {
+        requireNonEmpty(toolUseId, "toolUseId");
+        return `${JSON.stringify({ type: "deny", tool_use_id: toolUseId })}\n`;
+    },
+    toolResult: (toolUseId, content) => {
+        requireNonEmpty(toolUseId, "toolUseId");
+        return `${JSON.stringify({ type: "tool_result", tool_use_id: toolUseId, content })}\n`;
+    },
+    abort: () => ABORT_LINE,
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@pivanov/claude-wire",
+  "version": "0.0.2",
+  "description": "Run Claude Code programmatically. Typed SDK for spawning, streaming, and controlling the CLI.",
+  "type": "module",
+  "engines": {
+    "node": ">=22",
+    "bun": ">=1.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "license": "MIT",
+  "author": "Pavel Ivanov <iweb.ivanov@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pivanov/claude-wire",
+    "directory": "packages/claude-wire"
+  },
+  "homepage": "https://pivanov.github.io/claude-wire/",
+  "bugs": {
+    "url": "https://github.com/pivanov/claude-wire/issues"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "sdk",
+    "stream-json",
+    "ndjson",
+    "streaming",
+    "typescript",
+    "cli",
+    "agent",
+    "ai",
+    "tool-use",
+    "process-management",
+    "async-iterable"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "knip": "knip-bun",
+    "prepublishOnly": "cp ../../README.md ./README.md && bun run build"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.12",
+    "knip": "^6.4.1",
+    "typescript": "^6.0.2"
+  }
+}