@pivanov/claude-wire 0.0.2

package/dist/process.js

@@ -0,0 +1,179 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { BINARY } from "./constants.js";
+import { assertPositiveNumber, errorMessage, KnownError, ProcessError } from "./errors.js";
+import { fileExists, spawnProcess, whichSync } from "./runtime.js";
+import { writer } from "./writer.js";
+const resolveBinaryPath = () => {
+    const found = whichSync("claude");
+    if (found) {
+        return found;
+    }
+    for (const p of BINARY.commonPaths) {
+        if (fileExists(p)) {
+            return p;
+        }
+    }
+    return BINARY.name;
+};
+const ALIAS_PATTERN = /(?:alias\s+claude\s*=|export\s+).*CLAUDE_CONFIG_DIR=["']?\$?(?:HOME|\{HOME\}|~)\/?([^\s"']+?)["']?(?:\s|\/|$)/;
+const resolveConfigDirFromAlias = () => {
+    const home = homedir();
+    const rcFiles = [".zshrc", ".bashrc", ".zprofile", ".bash_profile", ".aliases"];
+    for (const rcFile of rcFiles) {
+        try {
+            const content = readFileSync(join(home, rcFile), "utf-8");
+            const match = content.match(ALIAS_PATTERN);
+            if (match?.[1]) {
+                return join(home, match[1]);
+            }
+        }
+        catch {
+            // file doesn't exist or can't be read
+        }
+    }
+    return undefined;
+};
+let cached;
+export const resetBinaryCache = () => {
+    cached = undefined;
+};
+const resolve = () => {
+    if (!cached) {
+        cached = {
+            binaryPath: resolveBinaryPath(),
+            aliasConfigDir: resolveConfigDirFromAlias(),
+        };
+    }
+    return cached;
+};
+export const buildArgs = (options, binaryPath) => {
+    const args = [binaryPath, "-p", "--output-format", "stream-json", "--input-format", "stream-json"];
+    if (options.verbose !== false) {
+        args.push("--verbose");
+    }
+    if (options.model) {
+        args.push("--model", options.model);
+    }
+    if (options.systemPrompt) {
+        args.push("--system-prompt", options.systemPrompt);
+    }
+    if (options.appendSystemPrompt) {
+        args.push("--append-system-prompt", options.appendSystemPrompt);
+    }
+    if (options.allowedTools) {
+        if (options.allowedTools.length === 0) {
+            args.push("--tools", "");
+        }
+        else {
+            args.push("--allowedTools", options.allowedTools.join(","));
+        }
+    }
+    if (options.disallowedTools && options.disallowedTools.length > 0) {
+        args.push("--disallowedTools", options.disallowedTools.join(","));
+    }
+    if (options.maxBudgetUsd !== undefined) {
+        args.push("--max-budget-usd", String(options.maxBudgetUsd));
+    }
+    if (options.resume) {
+        args.push("--resume", options.resume);
+    }
+    if (options.mcpConfig) {
+        args.push("--mcp-config", options.mcpConfig);
+    }
+    if (options.continueSession) {
+        args.push("--continue");
+    }
+    if (options.permissionMode) {
+        args.push("--permission-mode", options.permissionMode);
+    }
+    if (options.addDirs && options.addDirs.length > 0) {
+        for (const dir of options.addDirs) {
+            args.push("--add-dir", dir);
+        }
+    }
+    if (options.effort) {
+        args.push("--effort", options.effort);
+    }
+    if (options.includeHookEvents) {
+        args.push("--include-hook-events");
+    }
+    if (options.includePartialMessages) {
+        args.push("--include-partial-messages");
+    }
+    if (options.bare) {
+        args.push("--bare");
+    }
+    if (options.jsonSchema) {
+        args.push("--json-schema", options.jsonSchema);
+    }
+    if (options.forkSession) {
+        args.push("--fork-session");
+    }
+    if (options.noSessionPersistence) {
+        args.push("--no-session-persistence");
+    }
+    if (options.sessionId) {
+        args.push("--session-id", options.sessionId);
+    }
+    if (options.settingSources !== undefined) {
+        args.push("--setting-sources", options.settingSources);
+    }
+    if (options.disableSlashCommands) {
+        args.push("--disable-slash-commands");
+    }
+    return args;
+};
+export const spawnClaude = (options) => {
+    assertPositiveNumber(options.maxBudgetUsd, "maxBudgetUsd");
+    const resolved = resolve();
+    const args = buildArgs(options, resolved.binaryPath);
+    try {
+        const needsEnv = resolved.aliasConfigDir || options.configDir || options.env;
+        let spawnEnv;
+        if (needsEnv) {
+            spawnEnv = { ...process.env };
+            if (options.env) {
+                Object.assign(spawnEnv, options.env);
+            }
+            if (resolved.aliasConfigDir) {
+                spawnEnv.CLAUDE_CONFIG_DIR = resolved.aliasConfigDir;
+            }
+            if (options.configDir) {
+                spawnEnv.CLAUDE_CONFIG_DIR = options.configDir;
+            }
+        }
+        const rawProc = spawnProcess(args, { cwd: options.cwd, env: spawnEnv });
+        rawProc.exited.catch(() => { });
+        const claudeProc = {
+            write: (msg) => {
+                rawProc.stdin.write(msg);
+            },
+            kill: () => {
+                rawProc.kill();
+            },
+            exited: rawProc.exited,
+            stdout: rawProc.stdout,
+            stderr: rawProc.stderr,
+            pid: rawProc.pid,
+        };
+        if (options.prompt) {
+            try {
+                rawProc.stdin.write(writer.user(options.prompt));
+            }
+            catch {
+                rawProc.kill();
+                throw new ProcessError("Failed to write initial prompt to process");
+            }
+        }
+        return claudeProc;
+    }
+    catch (error) {
+        const msg = errorMessage(error);
+        if (msg.includes("ENOENT") || msg.includes("not found")) {
+            throw new KnownError("binary-not-found", "Claude CLI not found. Install it from https://claude.ai/download");
+        }
+        throw new ProcessError(`Failed to spawn claude: ${msg}`);
+    }
+};

package/dist/reader.d.ts

@@ -0,0 +1,13 @@
+import type { ITranslator } from "./parser/translator.js";
+import type { IClaudeProcess } from "./process.js";
+import type { IToolHandlerInstance } from "./tools/handler.js";
+import type { TRelayEvent } from "./types/events.js";
+export interface IReaderOptions {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    translator: ITranslator;
+    toolHandler?: IToolHandlerInstance;
+    proc?: IClaudeProcess;
+    signal?: AbortSignal;
+}
+export declare function readNdjsonEvents(opts: IReaderOptions): AsyncGenerator<TRelayEvent>;
+export type { TRelayEvent };

package/dist/reader.js

@@ -0,0 +1,94 @@
+import { LIMITS, TIMEOUTS } from "./constants.js";
+import { AbortError, ClaudeError, TimeoutError } from "./errors.js";
+import { parseLine } from "./parser/ndjson.js";
+import { dispatchToolDecision } from "./pipeline.js";
+export async function* readNdjsonEvents(opts) {
+    const { reader, translator, signal } = opts;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let timeoutId;
+    let turnComplete = false;
+    const abortHandler = signal
+        ? () => {
+            if (opts.proc) {
+                try {
+                    opts.proc.write('{"type":"abort"}\n');
+                }
+                catch {
+                    // stdin closed
+                }
+                opts.proc.kill();
+            }
+        }
+        : undefined;
+    if (signal && abortHandler) {
+        if (signal.aborted) {
+            throw new AbortError();
+        }
+        signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                throw new AbortError();
+            }
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    reject(new TimeoutError(`No data received within ${TIMEOUTS.defaultAbortMs}ms`));
+                }, TIMEOUTS.defaultAbortMs);
+            });
+            const readResult = await Promise.race([reader.read(), timeoutPromise]);
+            clearTimeout(timeoutId);
+            const { done, value } = readResult;
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            if (buffer.length > LIMITS.ndjsonMaxLineChars) {
+                throw new ClaudeError(`NDJSON buffer exceeded ${LIMITS.ndjsonMaxLineChars} chars`);
+            }
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const raw = parseLine(line);
+                if (!raw) {
+                    continue;
+                }
+                const events = translator.translate(raw);
+                for (const event of events) {
+                    if (event.type === "tool_use" && opts.toolHandler && opts.proc) {
+                        await dispatchToolDecision(opts.proc, opts.toolHandler, event);
+                    }
+                    yield event;
+                    if (event.type === "turn_complete") {
+                        turnComplete = true;
+                    }
+                }
+            }
+            if (turnComplete) {
+                break;
+            }
+        }
+        if (buffer.trim()) {
+            const raw = parseLine(buffer);
+            if (raw) {
+                const events = translator.translate(raw);
+                for (const event of events) {
+                    if (event.type === "tool_use" && opts.toolHandler && opts.proc && !turnComplete) {
+                        await dispatchToolDecision(opts.proc, opts.toolHandler, event);
+                    }
+                    yield event;
+                    if (event.type === "turn_complete") {
+                        turnComplete = true;
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        clearTimeout(timeoutId);
+        if (signal && abortHandler) {
+            signal.removeEventListener("abort", abortHandler);
+        }
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,18 @@
+export interface IRawProcess {
+    stdin: {
+        write: (data: string) => void;
+        end: () => void;
+    };
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    kill: () => void;
+    exited: Promise<number>;
+    pid: number;
+}
+export interface ISpawnOpts {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}
+export declare const spawnProcess: (args: string[], opts: ISpawnOpts) => IRawProcess;
+export declare const whichSync: (name: string) => string | undefined;
+export declare const fileExists: (path: string) => boolean;

package/dist/runtime.js

@@ -0,0 +1,136 @@
+import { execFileSync, spawn as nodeSpawn } from "node:child_process";
+import { accessSync, constants, statSync } from "node:fs";
+import { Readable } from "node:stream";
+const isBun = typeof globalThis.Bun !== "undefined";
+export const spawnProcess = (args, opts) => {
+    if (isBun) {
+        return spawnBun(args, opts);
+    }
+    return spawnNode(args, opts);
+};
+export const whichSync = (name) => {
+    if (isBun) {
+        try {
+            const result = Bun.spawnSync(["which", name], { stdout: "pipe", stderr: "pipe" });
+            const path = new TextDecoder().decode(result.stdout).trim();
+            if (path) {
+                return path;
+            }
+        }
+        catch {
+            // fall through
+        }
+        return undefined;
+    }
+    try {
+        return execFileSync("which", [name], { encoding: "utf-8" }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const fileExists = (path) => {
+    if (isBun) {
+        try {
+            accessSync(path, constants.X_OK);
+            return statSync(path).size > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        accessSync(path, constants.X_OK);
+        return statSync(path).size > 0;
+    }
+    catch {
+        return false;
+    }
+};
+const spawnBun = (args, opts) => {
+    const proc = Bun.spawn(args, {
+        cwd: opts.cwd,
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        env: opts.env,
+    });
+    return {
+        stdin: {
+            write: (data) => {
+                proc.stdin.write(data);
+            },
+            end: () => {
+                proc.stdin.end();
+            },
+        },
+        stdout: proc.stdout,
+        stderr: proc.stderr,
+        kill: () => {
+            proc.kill();
+        },
+        exited: proc.exited,
+        pid: proc.pid,
+    };
+};
+const nodeReadableToWeb = (readable) => {
+    return new ReadableStream({
+        start(controller) {
+            let closed = false;
+            readable.on("data", (chunk) => {
+                if (!closed) {
+                    controller.enqueue(new Uint8Array(chunk));
+                }
+            });
+            readable.on("end", () => {
+                if (!closed) {
+                    closed = true;
+                    controller.close();
+                }
+            });
+            readable.on("error", (err) => {
+                if (!closed) {
+                    closed = true;
+                    controller.error(err);
+                }
+            });
+        },
+        cancel() {
+            readable.destroy();
+        },
+    });
+};
+const spawnNode = (args, opts) => {
+    const [cmd, ...rest] = args;
+    if (!cmd) {
+        throw new Error("No command specified");
+    }
+    const child = nodeSpawn(cmd, rest, {
+        cwd: opts.cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: opts.env,
+    });
+    const exited = new Promise((resolve, reject) => {
+        child.on("exit", (code) => {
+            resolve(code ?? 1);
+        });
+        child.on("error", reject);
+    });
+    return {
+        stdin: {
+            write: (data) => {
+                child.stdin?.write(data);
+            },
+            end: () => {
+                child.stdin?.end();
+            },
+        },
+        stdout: child.stdout ? nodeReadableToWeb(child.stdout) : new ReadableStream(),
+        stderr: child.stderr ? nodeReadableToWeb(child.stderr) : new ReadableStream(),
+        kill: () => {
+            child.kill();
+        },
+        exited,
+        pid: child.pid ?? 0,
+    };
+};

package/dist/session.d.ts

@@ -0,0 +1,8 @@
+import type { ISessionOptions } from "./types/options.js";
+import type { TAskResult } from "./types/results.js";
+export interface IClaudeSession extends AsyncDisposable {
+    ask: (prompt: string) => Promise<TAskResult>;
+    close: () => Promise<void>;
+    sessionId: string | undefined;
+}
+export declare const createSession: (options?: ISessionOptions) => IClaudeSession;

package/dist/session.js

@@ -0,0 +1,239 @@
+import { LIMITS, TIMEOUTS } from "./constants.js";
+import { createCostTracker } from "./cost.js";
+import { AbortError, BudgetExceededError, ClaudeError, isTransientError, KnownError, ProcessError, TimeoutError } from "./errors.js";
+import { createTranslator } from "./parser/translator.js";
+import { buildResult } from "./pipeline.js";
+import { spawnClaude } from "./process.js";
+import { readNdjsonEvents } from "./reader.js";
+import { createToolHandler } from "./tools/handler.js";
+import { writer } from "./writer.js";
+const gracefulKill = async (p) => {
+    p.kill();
+    let timer;
+    let timedOut = false;
+    try {
+        await Promise.race([
+            p.exited,
+            new Promise((r) => {
+                timer = setTimeout(() => {
+                    timedOut = true;
+                    r();
+                }, TIMEOUTS.gracefulExitMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+    if (timedOut) {
+        try {
+            p.kill();
+        }
+        catch {
+            // already dead
+        }
+    }
+};
+export const createSession = (options = {}) => {
+    let proc;
+    let currentSessionId;
+    let consecutiveCrashes = 0;
+    let turnCount = 0;
+    let costOffsets = { totalUsd: 0, inputTokens: 0, outputTokens: 0 };
+    const translator = createTranslator();
+    const costTracker = createCostTracker({
+        maxCostUsd: options.maxCostUsd,
+        onCostUpdate: options.onCostUpdate,
+    });
+    const toolHandler = options.tools ? createToolHandler(options.tools) : undefined;
+    let inFlight;
+    let reader;
+    const cleanupProcess = () => {
+        if (reader) {
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                // already released
+            }
+        }
+        reader = undefined;
+    };
+    let lastStderrChunks = [];
+    const drainStderr = (p) => {
+        const chunks = [];
+        lastStderrChunks = chunks;
+        const stderrReader = p.stderr.getReader();
+        const decoder = new TextDecoder();
+        (async () => {
+            try {
+                while (true) {
+                    const { done, value } = await stderrReader.read();
+                    if (done) {
+                        break;
+                    }
+                    chunks.push(decoder.decode(value, { stream: true }));
+                }
+            }
+            catch {
+                // process exited
+            }
+            finally {
+                stderrReader.releaseLock();
+            }
+        })().catch(() => { });
+    };
+    const getStderrText = () => lastStderrChunks.join("").trim();
+    const killProc = () => {
+        if (proc) {
+            proc.kill();
+            proc.exited.catch(() => { });
+        }
+        proc = undefined;
+        cleanupProcess();
+    };
+    const spawnFresh = (prompt, resumeId) => {
+        if (consecutiveCrashes >= LIMITS.maxRespawnAttempts) {
+            killProc();
+            throw new ProcessError(`Process crashed ${consecutiveCrashes} times, giving up`);
+        }
+        costOffsets = costTracker.snapshot();
+        killProc();
+        translator.reset();
+        const spawnOpts = resumeId ? { prompt, ...options, resume: resumeId } : { prompt, ...options };
+        proc = spawnClaude(spawnOpts);
+        reader = proc.stdout.getReader();
+        drainStderr(proc);
+    };
+    const readUntilTurnComplete = async (signal) => {
+        if (!proc || !reader) {
+            throw new ClaudeError("Session not started");
+        }
+        const events = [];
+        let gotTurnComplete = false;
+        for await (const event of readNdjsonEvents({
+            reader,
+            translator,
+            toolHandler,
+            proc,
+            signal,
+        })) {
+            if (event.type === "session_meta") {
+                currentSessionId = event.sessionId;
+            }
+            events.push(event);
+            if (event.type === "turn_complete") {
+                costTracker.update(costOffsets.totalUsd + (event.costUsd ?? 0), costOffsets.inputTokens + (event.inputTokens ?? 0), costOffsets.outputTokens + (event.outputTokens ?? 0));
+                costTracker.checkBudget();
+                gotTurnComplete = true;
+                break;
+            }
+        }
+        if (!gotTurnComplete) {
+            if (signal?.aborted) {
+                throw new AbortError();
+            }
+            const stderrMsg = getStderrText();
+            throw new ProcessError(stderrMsg || "Process exited without completing the turn");
+        }
+        return events;
+    };
+    const doAsk = async (prompt) => {
+        if (!proc) {
+            spawnFresh(prompt, currentSessionId);
+        }
+        else {
+            try {
+                proc.write(writer.user(prompt));
+            }
+            catch {
+                consecutiveCrashes++;
+                translator.reset();
+                spawnFresh(prompt, currentSessionId);
+            }
+        }
+        let events;
+        try {
+            events = await readUntilTurnComplete(options.signal);
+        }
+        catch (error) {
+            if (error instanceof AbortError || error instanceof TimeoutError) {
+                killProc();
+                throw error;
+            }
+            if (isTransientError(error) && consecutiveCrashes < LIMITS.maxRespawnAttempts) {
+                consecutiveCrashes++;
+                spawnFresh(prompt, currentSessionId);
+                try {
+                    events = await readUntilTurnComplete(options.signal);
+                }
+                catch (retryError) {
+                    killProc();
+                    translator.reset();
+                    throw retryError;
+                }
+            }
+            else {
+                killProc();
+                translator.reset();
+                throw error;
+            }
+        }
+        consecutiveCrashes = 0;
+        turnCount++;
+        if (turnCount >= LIMITS.sessionMaxTurnsBeforeRecycle) {
+            if (proc) {
+                await gracefulKill(proc);
+            }
+            proc = undefined;
+            cleanupProcess();
+            turnCount = 0;
+            consecutiveCrashes = 0;
+        }
+        return buildResult(events, costTracker, currentSessionId);
+    };
+    let closed = false;
+    const ask = (prompt) => {
+        if (closed) {
+            return Promise.reject(new ClaudeError("Session is closed"));
+        }
+        const prev = inFlight ?? Promise.resolve();
+        const run = prev
+            .catch((prevError) => {
+            if (prevError instanceof KnownError || prevError instanceof BudgetExceededError) {
+                throw prevError;
+            }
+        })
+            .then(() => doAsk(prompt));
+        inFlight = run;
+        return run;
+    };
+    const close = async () => {
+        closed = true;
+        if (inFlight) {
+            await inFlight.catch(() => { });
+            inFlight = undefined;
+        }
+        if (proc) {
+            try {
+                proc.write(writer.abort());
+            }
+            catch {
+                // stdin may already be closed
+            }
+            await gracefulKill(proc);
+            proc = undefined;
+        }
+        cleanupProcess();
+    };
+    return {
+        ask,
+        close,
+        get sessionId() {
+            return currentSessionId;
+        },
+        [Symbol.asyncDispose]: close,
+    };
+};

package/dist/stream.d.ts

@@ -0,0 +1,9 @@
+import type { TRelayEvent } from "./types/events.js";
+import type { IClaudeOptions } from "./types/options.js";
+import type { TAskResult, TCostSnapshot } from "./types/results.js";
+export interface IClaudeStream extends AsyncIterable<TRelayEvent>, AsyncDisposable {
+    text: () => Promise<string>;
+    cost: () => Promise<TCostSnapshot>;
+    result: () => Promise<TAskResult>;
+}
+export declare const createStream: (prompt: string, options?: IClaudeOptions) => IClaudeStream;