flanders 0.0.1

package/lib/Claude.d.ts

@@ -0,0 +1,129 @@
+import type { ClaudeContext, TimeContext } from "./contexts";
+export type ClaudeResult = Readonly<{
+    text: string;
+    sessionId: string | null;
+    inputTokens: number;
+    outputTokens: number;
+}>;
+export type ClaudeContentBlock = Readonly<{
+    type?: string;
+    text?: string;
+    thinking?: string;
+    name?: string;
+    id?: string;
+    input?: Readonly<Record<string, unknown>>;
+    tool_use_id?: string;
+    content?: string | ReadonlyArray<Readonly<{
+        type?: string;
+        text?: string;
+    }>>;
+    is_error?: boolean;
+}>;
+export type ClaudeDelta = Readonly<{
+    type?: string;
+    text?: string;
+    partial_json?: string;
+}>;
+export type ClaudeControlRequestBody = Readonly<{
+    subtype?: string;
+    request_id?: string;
+    tool_name?: string;
+    input?: unknown;
+    tool_input?: unknown;
+}>;
+export type ClaudeEvent = Readonly<{
+    type?: string;
+    subtype?: string;
+    is_error?: boolean;
+    api_error_status?: number | null;
+    session_id?: string;
+    index?: number;
+    request_id?: string;
+    request?: ClaudeControlRequestBody;
+    message?: Readonly<{
+        role?: string;
+        content?: ReadonlyArray<ClaudeContentBlock>;
+        usage?: Readonly<{
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        }>;
+    }>;
+    content_block?: ClaudeContentBlock;
+    delta?: ClaudeDelta;
+    event?: ClaudeEvent;
+    error?: Readonly<{
+        message?: string;
+    }>;
+    result?: string;
+    usage?: Readonly<{
+        input_tokens?: number;
+        output_tokens?: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+    }>;
+    rate_limit_info?: Readonly<{
+        status?: string;
+        resetsAt?: number;
+        rateLimitType?: string;
+        isUsingOverage?: boolean;
+        overageStatus?: string;
+        overageResetsAt?: number;
+        utilization?: number;
+        surpassedThreshold?: number;
+    }>;
+}>;
+export type PermissionRequest = Readonly<{
+    request_id: string;
+    tool_name: string;
+    tool_input: unknown;
+}>;
+export type PermissionResponse = Readonly<{
+    behavior: "allow";
+    updatedInput?: unknown;
+    updated_permissions?: readonly unknown[];
+}> | Readonly<{
+    behavior: "deny";
+    message: string;
+    interrupt?: boolean;
+}>;
+export type ClaudeRunOptions = Readonly<{
+    prompt: string;
+    cwd?: string;
+    initialSessionId?: string | null;
+    forkFromSessionId?: string | null;
+    onEvent?(event: ClaudeEvent): void;
+    onStderr?(chunk: string): void;
+    onPermissionRequest?(req: PermissionRequest): Promise<PermissionResponse>;
+    onLongWaitStart?(kind: "rate-limit", endTimeMs: number): void;
+    onLongWaitEnd?(): void;
+}>;
+export declare class NonRetryableError extends Error {
+    constructor(message: string);
+}
+export declare class Claude {
+    readonly options: ClaudeRunOptions;
+    private _context;
+    private _time;
+    private _disposed;
+    private _process;
+    private _waitAbort;
+    private _runPromise;
+    private _sessionId;
+    private _forkFromSessionId;
+    private _killTimer;
+    private _transientAttempt;
+    constructor(options: ClaudeRunOptions, _context: ClaudeContext, _time: TimeContext);
+    result(): Promise<ClaudeResult>;
+    sendUserMessage(content: string): void;
+    sendControlResponse(requestId: string, response: PermissionResponse): void;
+    endSession(): void;
+    private _writeStdin;
+    private _run;
+    private _runOnce;
+    private _attachStreamParser;
+    private _scheduleWait;
+    private _handleControlRequest;
+    dispose(): Promise<void>;
+}

package/lib/Claude.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Claude = exports.NonRetryableError = void 0;
+const wait_1 = require("./wait");
+const RATE_LIMIT_CHUNK_MS = 60 * 60 * 1000;
+const INITIAL_TRANSIENT_WAIT_MS = 1_000;
+const TRANSIENT_WAIT_CAP_MS = 60_000;
+class RateLimitError extends Error {
+    retryAfterMs;
+    inputTokens;
+    outputTokens;
+    constructor(retryAfterMs, inputTokens = 0, outputTokens = 0) {
+        super(`rate_limit: retry after ${retryAfterMs}ms`);
+        this.retryAfterMs = retryAfterMs;
+        this.inputTokens = inputTokens;
+        this.outputTokens = outputTokens;
+    }
+}
+class RetryableTransientError extends Error {
+    inputTokens;
+    outputTokens;
+    constructor(inputTokens = 0, outputTokens = 0) {
+        super("retryable transient error");
+        this.inputTokens = inputTokens;
+        this.outputTokens = outputTokens;
+    }
+}
+class NonRetryableError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.NonRetryableError = NonRetryableError;
+class Claude {
+    options;
+    _context;
+    _time;
+    _disposed = false;
+    _process = null;
+    _waitAbort = null;
+    _runPromise;
+    _sessionId;
+    _forkFromSessionId;
+    _killTimer = null;
+    _transientAttempt = 0;
+    constructor(options, _context, _time) {
+        this.options = options;
+        this._context = _context;
+        this._time = _time;
+        this._sessionId = options.initialSessionId ?? null;
+        this._forkFromSessionId = options.forkFromSessionId ?? null;
+        this._runPromise = this._run();
+        this._runPromise.catch(() => { });
+    }
+    result() {
+        return this._runPromise;
+    }
+    sendUserMessage(content) {
+        this._writeStdin({ type: "user", message: { role: "user", content } });
+    }
+    sendControlResponse(requestId, response) {
+        this._writeStdin({
+            type: "control_response",
+            response: {
+                subtype: "success",
+                request_id: requestId,
+                response
+            }
+        });
+    }
+    endSession() {
+        if (this._disposed) {
+            return;
+        }
+        this._process?.stdin?.end();
+    }
+    _writeStdin(payload) {
+        if (this._disposed) {
+            return;
+        }
+        const stdin = this._process?.stdin;
+        if (!stdin) {
+            return;
+        }
+        stdin.write(JSON.stringify(payload) + "\n");
+    }
+    async _run() {
+        if (this._sessionId != null && this._forkFromSessionId != null) {
+            throw new Error("Cannot specify both forkFromSessionId and initialSessionId");
+        }
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        for (;;) {
+            if (this._disposed) {
+                throw new Error("Claude disposed");
+            }
+            try {
+                const result = await this._runOnce();
+                totalInputTokens += result.inputTokens;
+                totalOutputTokens += result.outputTokens;
+                this._transientAttempt = 0;
+                return { ...result, inputTokens: totalInputTokens, outputTokens: totalOutputTokens };
+            }
+            catch (e) {
+                if (e instanceof RateLimitError) {
+                    totalInputTokens += e.inputTokens;
+                    totalOutputTokens += e.outputTokens;
+                    if (this._disposed) {
+                        throw new Error("Claude disposed");
+                    }
+                    this.options.onLongWaitStart?.("rate-limit", this._time.now() + e.retryAfterMs);
+                    try {
+                        await this._scheduleWait(e.retryAfterMs, RATE_LIMIT_CHUNK_MS);
+                    }
+                    finally {
+                        this.options.onLongWaitEnd?.();
+                    }
+                    if (this._disposed) {
+                        throw new Error("Claude disposed");
+                    }
+                    continue;
+                }
+                if (e instanceof RetryableTransientError) {
+                    totalInputTokens += e.inputTokens;
+                    totalOutputTokens += e.outputTokens;
+                    this._transientAttempt++;
+                    const waitMs = Math.min(TRANSIENT_WAIT_CAP_MS, INITIAL_TRANSIENT_WAIT_MS * 2 ** (this._transientAttempt - 1));
+                    await this._scheduleWait(waitMs, waitMs);
+                    if (this._disposed) {
+                        throw new Error("Claude disposed");
+                    }
+                    continue;
+                }
+                throw e;
+            }
+        }
+    }
+    _runOnce() {
+        return new Promise((resolve, reject) => {
+            if (this._disposed) {
+                return reject(new Error("Claude disposed"));
+            }
+            const args = [];
+            if (this._sessionId) {
+                args.push("--resume", this._sessionId);
+            }
+            else if (this._forkFromSessionId) {
+                args.push("--resume", this._forkFromSessionId, "--fork-session");
+                this._forkFromSessionId = null;
+            }
+            args.push("--model=claude-opus-4-6", "--effort=xhigh", "--input-format=stream-json", "--output-format=stream-json", "--include-partial-messages", "--permission-prompt-tool=stdio", "--verbose", "-p");
+            const spawnOptions = {
+                stdio: "pipe",
+                ...(this.options.cwd ? { cwd: this.options.cwd } : null)
+            };
+            const proc = this._context.spawn("claude", args, spawnOptions);
+            this._process = proc;
+            const initialMessage = {
+                type: "user",
+                message: { role: "user", content: this.options.prompt }
+            };
+            proc.stdin?.write(JSON.stringify(initialMessage) + "\n");
+            const collected = {
+                text: "",
+                session: null,
+                rateLimit: null,
+                isRetryableError: false,
+                nonRetryableReason: null,
+                inputTokens: 0,
+                outputTokens: 0
+            };
+            this._attachStreamParser(proc, collected);
+            let settled = false;
+            const settle = (outcome) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                this._process = null;
+                if (outcome.ok) {
+                    resolve(outcome.value);
+                }
+                else {
+                    reject(outcome.error);
+                }
+            };
+            proc.on("error", e => {
+                settle({ ok: false, error: e instanceof Error ? e : new Error(String(e)) });
+            });
+            proc.on("exit", code => {
+                if (collected.session) {
+                    this._sessionId = collected.session;
+                }
+                if (this._disposed) {
+                    settle({ ok: false, error: new Error("Claude disposed") });
+                    return;
+                }
+                if (collected.rateLimit) {
+                    settle({ ok: false, error: new RateLimitError(collected.rateLimit.retryAfterMs, collected.inputTokens, collected.outputTokens) });
+                    return;
+                }
+                if (collected.isRetryableError) {
+                    settle({ ok: false, error: new RetryableTransientError(collected.inputTokens, collected.outputTokens) });
+                    return;
+                }
+                if (collected.nonRetryableReason) {
+                    settle({ ok: false, error: new NonRetryableError(collected.nonRetryableReason) });
+                    return;
+                }
+                if (code === 0 || code === null) {
+                    settle({ ok: true, value: { text: collected.text, sessionId: collected.session, inputTokens: collected.inputTokens, outputTokens: collected.outputTokens } });
+                }
+                else {
+                    settle({ ok: false, error: new NonRetryableError(`Claude process exited with code ${code}`) });
+                }
+            });
+        });
+    }
+    _attachStreamParser(proc, collected) {
+        let buffer = "";
+        const handleLine = (line) => {
+            if (!line) {
+                return;
+            }
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (!parsed) {
+                return;
+            }
+            if (parsed.session_id && !collected.session) {
+                collected.session = parsed.session_id;
+            }
+            if (parsed.type === "rate_limit_event" && parsed.rate_limit_info?.status === "rejected") {
+                const info = parsed.rate_limit_info;
+                const target = info.isUsingOverage && typeof info.overageResetsAt === "number"
+                    ? info.overageResetsAt
+                    : info.resetsAt;
+                if (typeof target === "number") {
+                    const retryAfterMs = Math.max(0, target * 1000 - this._time.now());
+                    collected.rateLimit = new RateLimitError(retryAfterMs);
+                }
+            }
+            else if (parsed.type === "result") {
+                if (typeof parsed.result === "string") {
+                    collected.text = parsed.result;
+                }
+                const u = parsed.usage;
+                if (u) {
+                    collected.inputTokens = (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+                    collected.outputTokens = u.output_tokens ?? 0;
+                }
+                if (parsed.is_error) {
+                    const subtype = parsed.subtype;
+                    const status = parsed.api_error_status;
+                    if (subtype === "error_max_turns" || subtype === "error_max_budget_usd" || subtype === "error_max_structured_output_retries") {
+                        collected.nonRetryableReason = subtype;
+                    }
+                    else if ((typeof status === "number" && (status >= 500 || status === 408 || status === 425)) ||
+                        status === null ||
+                        subtype === "error_during_execution") {
+                        collected.isRetryableError = true;
+                    }
+                    else {
+                        collected.nonRetryableReason = typeof status === "number" ? `HTTP ${status}` : "unknown error";
+                    }
+                }
+            }
+            else if (parsed.type === "assistant" && parsed.message?.content) {
+                let text = "";
+                for (const block of parsed.message.content) {
+                    if (block.type === "text" && typeof block.text === "string") {
+                        text += block.text;
+                    }
+                }
+                if (text) {
+                    collected.text = text;
+                }
+            }
+            else if (parsed.type === "control_request" || parsed.type === "sdk_control_request") {
+                this._handleControlRequest(parsed);
+            }
+            try {
+                this.options.onEvent?.(parsed);
+            }
+            catch (e) {
+                if (this.options.onStderr) {
+                    this.options.onStderr(`onEvent handler threw: ${String(e)}\n`);
+                }
+            }
+        };
+        proc.stdout?.on("data", chunk => {
+            buffer += String(chunk);
+            for (;;) {
+                const nl = buffer.indexOf("\n");
+                if (nl < 0) {
+                    break;
+                }
+                const line = buffer.slice(0, nl).replace(/\r$/, "");
+                buffer = buffer.slice(nl + 1);
+                handleLine(line);
+            }
+        });
+        proc.stderr?.on("data", chunk => {
+            if (this.options.onStderr) {
+                this.options.onStderr(String(chunk));
+            }
+        });
+    }
+    _scheduleWait(totalMs, chunkMs) {
+        const abort = new AbortController();
+        this._waitAbort = abort;
+        return (0, wait_1.wait)(totalMs, chunkMs, this._time, abort.signal).then(() => {
+            if (this._waitAbort === abort) {
+                this._waitAbort = null;
+            }
+        });
+    }
+    _handleControlRequest(parsed) {
+        const req = parsed.request;
+        if (!req) {
+            return;
+        }
+        if (req.subtype !== "can_use_tool" && req.subtype !== "permission") {
+            return;
+        }
+        const requestId = parsed.request_id ?? req.request_id;
+        if (typeof requestId !== "string" || requestId.length === 0) {
+            return;
+        }
+        const toolName = req.tool_name;
+        if (typeof toolName !== "string") {
+            return;
+        }
+        const toolInput = req.input ?? req.tool_input;
+        const handler = this.options.onPermissionRequest;
+        const responsePromise = handler
+            ? handler({ request_id: requestId, tool_name: toolName, tool_input: toolInput })
+            : Promise.resolve({
+                behavior: "allow",
+                updatedInput: typeof toolInput === "object" && toolInput !== null ? toolInput : {}
+            });
+        responsePromise.then(response => {
+            this.sendControlResponse(requestId, response);
+        }, err => {
+            this.sendControlResponse(requestId, {
+                behavior: "deny",
+                message: err instanceof Error ? err.message : String(err)
+            });
+        });
+    }
+    async dispose() {
+        if (this._disposed) {
+            try {
+                await this._runPromise;
+            }
+            catch {
+            }
+            return;
+        }
+        this._disposed = true;
+        this._waitAbort?.abort();
+        const proc = this._process;
+        if (proc) {
+            const exitWaiter = new Promise(resolve => {
+                proc.on("exit", () => resolve());
+            });
+            proc.stdin?.end();
+            proc.kill("SIGINT");
+            this._killTimer = this._time.setTimeout(() => {
+                this._killTimer = null;
+                proc.kill("SIGTERM");
+            }, 5000);
+            await exitWaiter;
+            this._killTimer?.cancel();
+            this._killTimer = null;
+        }
+        try {
+            await this._runPromise;
+        }
+        catch {
+        }
+    }
+}
+exports.Claude = Claude;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Claude.js","sourceRoot":"","sources":["../src/Claude.ts"],"names":[],"mappings":"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"}

package/lib/ClaudeSession.d.ts

@@ -0,0 +1,34 @@
+import { ClaudeResult } from "./Claude";
+import type { AskContext, ClaudeContext, OutputContext, TimeContext } from "./contexts";
+export type ClaudeSessionOptions = Readonly<{
+    prompt: string;
+    cwd?: string;
+    initialSessionId?: string | null;
+    forkFromSessionId?: string | null;
+    onLongWaitStart?(kind: "rate-limit", endTimeMs: number): void;
+    onLongWaitEnd?(): void;
+}>;
+export type ClaudeSessionContexts = Readonly<{
+    claude: ClaudeContext;
+    time: TimeContext;
+    output: OutputContext;
+    ask: AskContext;
+}>;
+export declare class ClaudeSession {
+    private _options;
+    private _contexts;
+    private _disposed;
+    private _claude;
+    private _printedAnyOutputThisRun;
+    private _seenTextThisMessage;
+    private _textOpen;
+    constructor(_options: ClaudeSessionOptions, _contexts: ClaudeSessionContexts);
+    run(): Promise<ClaudeResult>;
+    dispose(): Promise<void>;
+    private _resetState;
+    private _onPermissionRequest;
+    private _handleAskUserQuestion;
+    private _onEvent;
+    private _emitText;
+    private _closeOpenTextLine;
+}