@alexjbarnes/cockpit 0.1.1 → 0.3.0

package/dist/src/server/providers.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProviders = getProviders;
+exports.getProvider = getProvider;
+exports.addProvider = addProvider;
+exports.updateProvider = updateProvider;
+exports.deleteProvider = deleteProvider;
+exports.setProviders = setProviders;
+exports.resolveProviderModel = resolveProviderModel;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const uuid_1 = require("uuid");
+const models_1 = require("../lib/models");
+const paths_1 = require("../server/paths");
+function prefsDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function providersFile() {
+    return (0, node_path_1.join)(prefsDir(), "providers.json");
+}
+function validateProvider(p) {
+    for (const m of p.models) {
+        if (!Array.isArray(m.contextSizes) || m.contextSizes.length === 0) {
+            throw new Error(`provider${p.id ? ` ${p.id}` : ""}: model ${m.modelId} has empty contextSizes`);
+        }
+    }
+}
+function buildAnthropicProvider() {
+    return {
+        id: "anthropic",
+        name: "Anthropic",
+        envVars: {},
+        models: (0, models_1.toProviderModels)(),
+        isBuiltin: true,
+    };
+}
+let cache = null;
+function loadCustom() {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(providersFile(), "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveCustom(providers) {
+    try {
+        (0, node_fs_1.mkdirSync)(prefsDir(), { recursive: true });
+        (0, node_fs_1.writeFileSync)(providersFile(), JSON.stringify(providers, null, 2) + "\n");
+    }
+    catch {
+        // best effort
+    }
+}
+function getProviders() {
+    if (!cache) {
+        cache = [buildAnthropicProvider(), ...loadCustom()];
+    }
+    return cache;
+}
+function getProvider(id) {
+    return getProviders().find((p) => p.id === id);
+}
+function addProvider(provider) {
+    const newProvider = { ...provider, id: (0, uuid_1.v4)() };
+    validateProvider(newProvider);
+    const all = getProviders();
+    const custom = all.filter((p) => !p.isBuiltin);
+    custom.push(newProvider);
+    saveCustom(custom);
+    cache = [buildAnthropicProvider(), ...custom];
+    return newProvider;
+}
+function updateProvider(id, partial) {
+    if (id === "anthropic")
+        throw new Error("Cannot modify built-in provider");
+    const all = getProviders();
+    const custom = all.filter((p) => !p.isBuiltin);
+    const idx = custom.findIndex((p) => p.id === id);
+    if (idx === -1)
+        throw new Error(`Provider not found: ${id}`);
+    const merged = { ...custom[idx], ...partial, id };
+    validateProvider(merged);
+    custom[idx] = merged;
+    saveCustom(custom);
+    cache = [buildAnthropicProvider(), ...custom];
+    return custom[idx];
+}
+function deleteProvider(id) {
+    if (id === "anthropic")
+        throw new Error("Cannot delete built-in provider");
+    const all = getProviders();
+    const custom = all.filter((p) => !p.isBuiltin && p.id !== id);
+    if (custom.length === all.filter((p) => !p.isBuiltin).length) {
+        throw new Error(`Provider not found: ${id}`);
+    }
+    saveCustom(custom);
+    cache = [buildAnthropicProvider(), ...custom];
+}
+function setProviders(providers) {
+    const custom = providers.filter((p) => !p.isBuiltin);
+    for (const p of custom)
+        validateProvider(p);
+    saveCustom(custom);
+    cache = [buildAnthropicProvider(), ...custom];
+}
+function resolveProviderModel(modelId) {
+    if (!modelId)
+        return null;
+    const colon = modelId.indexOf(":");
+    if (colon > 0) {
+        const providerId = modelId.slice(0, colon);
+        const bareModel = modelId.slice(colon + 1);
+        const provider = getProvider(providerId);
+        if (provider) {
+            const model = provider.models.find((m) => m.modelId === bareModel);
+            if (model)
+                return { provider, model };
+        }
+        return null;
+    }
+    for (const provider of getProviders()) {
+        const model = provider.models.find((m) => m.modelId === modelId);
+        if (model)
+            return { provider, model };
+    }
+    return null;
+}

package/dist/src/server/pty-runtime.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PtyRuntime = void 0;
+const uuid_1 = require("uuid");
+const claude_settings_1 = require("./claude-settings");
+const cli_init_fetch_1 = require("./cli-init-fetch");
+const hook_event_translator_1 = require("./hook-event-translator");
+const pty_session_1 = require("./pty-session");
+/**
+ * Owns a claude PTY process plus its HookRouter registration. Translates
+ * hook payloads into ParsedEvents and pumps them through opts.onEvents so
+ * SessionManager's existing stream-processor pipeline drives status, todos,
+ * pending permissions, etc.
+ *
+ * PermissionRequest hooks block the PTY until cockpit responds. We hold the
+ * resolver in `pendingPermissions` and the caller calls
+ * `notifyPermissionDecision` from its UI-facing respondToPermission path.
+ */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: strip ANSI escape sequences
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+class PtyRuntime {
+    opts;
+    pty = null;
+    settingsPath = null;
+    pendingPermissions = new Map();
+    exited = false;
+    cleaned = false;
+    ptyOutputBuffer = "";
+    errorDebounce = null;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get pid() {
+        return this.pty?.pid ?? -1;
+    }
+    get isAlive() {
+        return !!this.pty && !this.exited;
+    }
+    async start(initialText) {
+        const { sessionId, cwd, hookRouter } = this.opts;
+        const token = hookRouter.register(sessionId, this.buildHandler());
+        const { settingsPath, env } = await (0, claude_settings_1.prepareHookSettings)({
+            sessionId,
+            hookUrl: hookRouter.getUrl(),
+            hookToken: token,
+            allowList: this.opts.allowList,
+            denyList: this.opts.denyList,
+        });
+        this.settingsPath = settingsPath;
+        this.pty = new pty_session_1.PtySession({
+            cwd,
+            settingsPath,
+            env: { ...env, ...(this.opts.extraEnv ?? {}) },
+            extraArgs: this.opts.extraArgs,
+            bin: this.opts.claudeBin,
+            onData: (chunk) => {
+                this.scanForErrors(chunk);
+                this.opts.onPtyData?.(chunk);
+            },
+            onExit: (info) => {
+                this.exited = true;
+                this.opts.onExit(info);
+                this.cleanup().catch(() => { });
+            },
+        });
+        try {
+            await this.pty.start();
+        }
+        catch (err) {
+            await this.cleanup();
+            throw err;
+        }
+        if (initialText) {
+            await this.pty.sendText(initialText);
+        }
+        this.fetchInitData();
+    }
+    fetchInitData() {
+        const sid = this.opts.sessionId.slice(0, 8);
+        console.log(`[pty-runtime] fetching CLI init data for session ${sid}`);
+        (0, cli_init_fetch_1.fetchCliInitData)({ cwd: this.opts.cwd, bin: this.opts.claudeBin })
+            .then((initData) => {
+            if (initData && !this.exited) {
+                console.log(`[pty-runtime] emitting init event for session ${sid}: ${initData.slashCommands.length} commands`);
+                this.emit([{ type: "init", initData }]);
+            }
+            else {
+                console.log(`[pty-runtime] init fetch returned ${initData ? "data but session exited" : "null"} for session ${sid}`);
+            }
+        })
+            .catch((err) => {
+            console.log(`[pty-runtime] init fetch failed for session ${sid}: ${err}`);
+        });
+    }
+    async sendText(text) {
+        if (!this.pty)
+            throw new Error("PtyRuntime not started");
+        await this.pty.sendText(text);
+    }
+    sendSlash(command) {
+        if (!this.pty)
+            throw new Error("PtyRuntime not started");
+        this.pty.sendSlash(command);
+    }
+    sendKey(key) {
+        if (!this.pty)
+            throw new Error("PtyRuntime not started");
+        this.pty.sendKey(key);
+    }
+    /** Sends Esc to claude — the interactive REPL treats it as interrupt. */
+    interrupt() {
+        if (!this.pty)
+            return;
+        this.pty.sendKey("\x1b");
+        for (const [, resolve] of this.pendingPermissions) {
+            resolve({ behavior: "deny", message: "interrupted" });
+        }
+        this.pendingPermissions.clear();
+    }
+    resize(cols, rows) {
+        this.pty?.resize(cols, rows);
+    }
+    async kill(signal) {
+        this.cancelErrorDebounce();
+        if (this.pty) {
+            this.pty.kill(signal);
+            this.pty = null;
+        }
+        // Resolve any in-flight permission promises so the bridge subprocess can exit.
+        for (const [, resolve] of this.pendingPermissions) {
+            resolve({ behavior: "deny", message: "session ended" });
+        }
+        this.pendingPermissions.clear();
+        await this.cleanup();
+    }
+    /** Called by SessionManager.respondToPermission when this session is on the pty runtime. */
+    notifyPermissionDecision(requestId, decision) {
+        const resolver = this.pendingPermissions.get(requestId);
+        if (!resolver)
+            return false;
+        this.pendingPermissions.delete(requestId);
+        resolver(decision);
+        return true;
+    }
+    buildHandler() {
+        return {
+            onPreToolUse: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                const toolName = typeof payload.tool_name === "string" ? payload.tool_name : "unknown";
+                const cliSession = typeof payload.session_id === "string" ? payload.session_id.slice(0, 8) : "none";
+                const toolUseId = typeof payload.tool_use_id === "string" ? payload.tool_use_id.slice(0, 12) : "none";
+                console.log(`[pty-runtime] PreToolUse: tool=${toolName} cli_session=${cliSession} tool_use_id=${toolUseId}`);
+                this.emit((0, hook_event_translator_1.translateHookEvent)("PreToolUse", payload));
+            },
+            onPostToolUse: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                const toolName = typeof payload.tool_name === "string" ? payload.tool_name : "unknown";
+                const cliSession = typeof payload.session_id === "string" ? payload.session_id.slice(0, 8) : "none";
+                const toolUseId = typeof payload.tool_use_id === "string" ? payload.tool_use_id.slice(0, 12) : "none";
+                console.log(`[pty-runtime] PostToolUse: tool=${toolName} cli_session=${cliSession} tool_use_id=${toolUseId}`);
+                this.emit((0, hook_event_translator_1.translateHookEvent)("PostToolUse", payload));
+            },
+            onStop: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                console.log(`[pty-runtime] Stop hook received for session ${this.opts.sessionId.slice(0, 8)}`);
+                const events = (0, hook_event_translator_1.translateHookEvent)("Stop", payload);
+                console.log(`[pty-runtime] Stop translated to ${events.length} events: [${events.map((e) => e.type).join(", ")}]`);
+                this.emit(events);
+            },
+            onStopFailure: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                const errorType = typeof payload.error_type === "string" ? payload.error_type : "unknown";
+                const errorMessage = typeof payload.error_message === "string" ? payload.error_message : "Unknown error";
+                console.log(`[pty-runtime] StopFailure hook for session ${this.opts.sessionId.slice(0, 8)}: ${errorType} - ${errorMessage}`);
+                this.emit((0, hook_event_translator_1.translateHookEvent)("StopFailure", payload));
+                this.opts.onError(`${errorMessage} (${errorType})`);
+            },
+            onUserPromptSubmit: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                this.emit((0, hook_event_translator_1.translateHookEvent)("UserPromptSubmit", payload));
+            },
+            onUserPromptExpansion: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                const cmd = typeof payload.command_name === "string" ? payload.command_name : "unknown";
+                const sid = this.opts.sessionId.slice(0, 8);
+                console.log(`[pty-runtime] UserPromptExpansion: command=${cmd}, session=${sid}`);
+                this.emit((0, hook_event_translator_1.translateHookEvent)("UserPromptExpansion", payload));
+            },
+            onSubagentStart: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                const cliSession = typeof payload.session_id === "string" ? payload.session_id.slice(0, 8) : "none";
+                const toolUseId = typeof payload.tool_use_id === "string" ? payload.tool_use_id.slice(0, 12) : "none";
+                const agentType = typeof payload.agent_type === "string" ? payload.agent_type : "unknown";
+                const desc = typeof payload.description === "string" ? payload.description.slice(0, 80) : "";
+                console.log(`[pty-runtime] SubagentStart: cli_session=${cliSession} tool_use_id=${toolUseId} type=${agentType} desc="${desc}"`);
+                console.log(`[pty-runtime] SubagentStart full payload keys: ${Object.keys(payload).join(", ")}`);
+                this.emit((0, hook_event_translator_1.translateHookEvent)("SubagentStart", payload));
+            },
+            onSubagentStop: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                const cliSession = typeof payload.session_id === "string" ? payload.session_id.slice(0, 8) : "none";
+                const toolUseId = typeof payload.tool_use_id === "string" ? payload.tool_use_id.slice(0, 12) : "none";
+                const agentType = typeof payload.agent_type === "string" ? payload.agent_type : "unknown";
+                console.log(`[pty-runtime] SubagentStop: cli_session=${cliSession} tool_use_id=${toolUseId} type=${agentType}`);
+                console.log(`[pty-runtime] SubagentStop full payload keys: ${Object.keys(payload).join(", ")}`);
+                this.emit((0, hook_event_translator_1.translateHookEvent)("SubagentStop", payload));
+            },
+            onPreCompact: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                console.log(`[pty-runtime] PreCompact for session ${this.opts.sessionId.slice(0, 8)}`);
+                this.emit((0, hook_event_translator_1.translateHookEvent)("PreCompact", payload));
+            },
+            onPostCompact: (payload) => {
+                this.cancelErrorDebounce();
+                this.ptyOutputBuffer = "";
+                console.log(`[pty-runtime] PostCompact for session ${this.opts.sessionId.slice(0, 8)}`);
+                this.emit((0, hook_event_translator_1.translateHookEvent)("PostCompact", payload));
+            },
+            onNotification: (payload) => {
+                this.cancelErrorDebounce();
+                this.emit((0, hook_event_translator_1.translateHookEvent)("Notification", payload));
+            },
+            onPermissionRequest: (payload) => this.handlePermissionRequest(payload),
+        };
+    }
+    handlePermissionRequest(payload) {
+        const requestId = (0, hook_event_translator_1.newPermissionRequestId)();
+        const toolName = typeof payload.tool_name === "string" ? payload.tool_name : "unknown";
+        const toolInput = payload.tool_input;
+        const event = {
+            type: "permission_request",
+            requestId,
+            toolName,
+            toolInput: toolInput ? JSON.stringify(toolInput) : "",
+            rawToolInput: toolInput,
+        };
+        return new Promise((resolve) => {
+            this.pendingPermissions.set(requestId, resolve);
+            try {
+                this.opts.onEvents([event]);
+            }
+            catch (err) {
+                this.pendingPermissions.delete(requestId);
+                resolve({ behavior: "deny", message: `cockpit handler error: ${String(err)}` });
+            }
+        });
+    }
+    emit(events) {
+        if (events.length === 0)
+            return;
+        try {
+            this.opts.onEvents(events);
+        }
+        catch (err) {
+            console.error(`[pty-runtime] onEvents threw for session ${this.opts.sessionId.slice(0, 8)}:`, err);
+            this.opts.onError(err instanceof Error ? err.message : String(err));
+        }
+    }
+    cancelErrorDebounce() {
+        if (this.errorDebounce) {
+            clearTimeout(this.errorDebounce);
+            this.errorDebounce = null;
+        }
+    }
+    scanForErrors(chunk) {
+        this.ptyOutputBuffer += chunk;
+        if (this.ptyOutputBuffer.length > 8 * 1024) {
+            this.ptyOutputBuffer = this.ptyOutputBuffer.slice(-4 * 1024);
+        }
+        if (this.errorDebounce)
+            return;
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: strip terminal control chars
+        const clean = this.ptyOutputBuffer.replace(ANSI_RE, "").replace(/[\x00-\x1f]/g, "");
+        const match = clean.match(/API\s*Error:\s*(\d+)\s*([^✓✗❯]*)/) || clean.match(/APIError:\s*(\d+)\s*(.*)/);
+        if (!match)
+            return;
+        const httpCode = match[1];
+        const detail = match[2].trim().slice(0, 200);
+        const errMsg = detail ? `${detail} (HTTP ${httpCode})` : `API Error (HTTP ${httpCode})`;
+        this.errorDebounce = setTimeout(() => {
+            this.errorDebounce = null;
+            this.ptyOutputBuffer = "";
+            console.log(`[pty-runtime] API error detected for session ${this.opts.sessionId.slice(0, 8)}: ${errMsg}`);
+            const doneEvent = {
+                type: "message_done",
+                message: {
+                    id: (0, uuid_1.v4)(),
+                    role: "assistant",
+                    content: "",
+                    toolUses: [],
+                    blocks: [],
+                    timestamp: Date.now(),
+                },
+            };
+            try {
+                this.opts.onEvents([doneEvent]);
+            }
+            catch {
+                // best-effort
+            }
+            this.opts.onError(errMsg);
+        }, 10_000);
+    }
+    async cleanup() {
+        if (this.cleaned)
+            return;
+        this.cleaned = true;
+        this.opts.hookRouter.unregister(this.opts.sessionId);
+        if (this.settingsPath) {
+            await (0, claude_settings_1.cleanupHookSettings)(this.opts.sessionId).catch(() => { });
+            this.settingsPath = null;
+        }
+    }
+}
+exports.PtyRuntime = PtyRuntime;

package/dist/src/server/pty-session.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PtySession = void 0;
+const node_fs_1 = require("node:fs");
+const node_pty_1 = require("node-pty");
+const TEXT_TO_ENTER_DELAY_MS = 300;
+const TRUST_DIALOG_WINDOW_MS = 5000;
+const REPL_READY_MIN_BYTES = 100;
+const REPL_READY_TIMEOUT_MS = 60_000;
+const REPL_SETTLE_MS = 2000;
+class PtySession {
+    pty = null;
+    buffer = "";
+    cols;
+    rows;
+    exited = false;
+    exitCode = null;
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+        this.cols = opts.cols ?? 160;
+        this.rows = opts.rows ?? 50;
+    }
+    get pid() {
+        return this.pty?.pid ?? -1;
+    }
+    async start() {
+        if (this.pty)
+            throw new Error("PtySession already started");
+        const bin = this.opts.bin ?? "claude";
+        const args = ["--verbose", "--settings", this.opts.settingsPath, ...(this.opts.extraArgs ?? [])];
+        const env = {
+            ...process.env,
+            ...(this.opts.env ?? {}),
+        };
+        delete env.CLAUDECODE;
+        delete env.CLAUDE_CODE_ENTRYPOINT;
+        const spawnFile = process.platform === "darwin" ? "/bin/zsh" : bin;
+        const spawnArgs = process.platform === "darwin" ? ["-l", "-c", `exec ${[bin, ...args].map(shellQuote).join(" ")}`] : args;
+        let diagInfo = `platform=${process.platform}, file=${spawnFile}, cwd=${this.opts.cwd}`;
+        try {
+            const exists = (0, node_fs_1.existsSync)(spawnFile);
+            diagInfo += `, exists=${exists}`;
+            if (exists) {
+                const real = (0, node_fs_1.realpathSync)(spawnFile);
+                const stat = (0, node_fs_1.statSync)(real);
+                const mode = `0${(stat.mode & 0o7777).toString(8)}`;
+                diagInfo += `, realpath=${real}, mode=${mode}, size=${stat.size}`;
+            }
+        }
+        catch (e) {
+            diagInfo += `, diagError=${e instanceof Error ? e.message : String(e)}`;
+        }
+        console.log(`[pty-session] spawn diagnostic: ${diagInfo}`);
+        console.log(`[pty-session] spawn args: ${JSON.stringify(spawnArgs).slice(0, 500)}`);
+        console.log(`[pty-session] PATH: ${env.PATH?.split(":").slice(0, 10).join(":")}`);
+        try {
+            this.pty = (0, node_pty_1.spawn)(spawnFile, spawnArgs, {
+                name: "xterm-256color",
+                cols: this.cols,
+                rows: this.rows,
+                cwd: this.opts.cwd,
+                env,
+            });
+        }
+        catch (err) {
+            console.error(`[pty-session] spawn failed: ${err instanceof Error ? err.message : String(err)}`);
+            console.error(`[pty-session] full diagnostic: ${diagInfo}`);
+            throw err;
+        }
+        this.pty.onData((data) => {
+            this.buffer += data;
+            if (this.buffer.length > 64 * 1024)
+                this.buffer = this.buffer.slice(-32 * 1024);
+            this.opts.onData?.(data);
+        });
+        this.pty.onExit((info) => {
+            this.exited = true;
+            this.exitCode = info.exitCode;
+            this.opts.onExit?.(info);
+            this.pty = null;
+        });
+        await this.handleTrustDialog();
+        await this.waitForReplReady();
+    }
+    async sendText(text) {
+        const pty = this.requirePty();
+        pty.write("\x15");
+        pty.write(text);
+        await sleep(TEXT_TO_ENTER_DELAY_MS);
+        pty.write("\r");
+    }
+    sendSlash(command) {
+        const c = command.startsWith("/") ? command : `/${command}`;
+        this.requirePty().write(`${c}\r`);
+    }
+    sendKey(key) {
+        this.requirePty().write(key);
+    }
+    resize(cols, rows) {
+        if (!this.pty)
+            return;
+        if (cols === this.cols && rows === this.rows)
+            return;
+        this.cols = cols;
+        this.rows = rows;
+        this.pty.resize(cols, rows);
+    }
+    kill(signal) {
+        if (!this.pty)
+            return;
+        try {
+            this.pty.kill(signal);
+        }
+        catch {
+            // already dead
+        }
+        this.pty = null;
+    }
+    requirePty() {
+        if (!this.pty)
+            throw new Error("PtySession not started or already exited");
+        return this.pty;
+    }
+    cleanOutput() {
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape sequences
+        const ansi = /\x1b\[[0-9;]*[a-zA-Z]/g;
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI extras
+        const extras = /\x1b[>=?][^\x1b]*/g;
+        return this.buffer.replace(ansi, "").replace(extras, "");
+    }
+    async handleTrustDialog() {
+        const deadline = Date.now() + TRUST_DIALOG_WINDOW_MS;
+        let accepted = false;
+        while (Date.now() < deadline) {
+            if (this.exited)
+                return;
+            const clean = this.cleanOutput();
+            if (clean.includes("trust") || clean.includes("Yes,")) {
+                this.requirePty().write("\r");
+                accepted = true;
+                break;
+            }
+            if (clean.length > REPL_READY_MIN_BYTES)
+                break;
+            await sleep(200);
+        }
+        if (accepted)
+            await sleep(2000);
+    }
+    async waitForReplReady() {
+        const deadline = Date.now() + REPL_READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (this.exited) {
+                throw new Error(`claude exited during startup (code=${this.exitCode}, output=${this.cleanOutput().slice(0, 200)})`);
+            }
+            if (this.cleanOutput().length >= REPL_READY_MIN_BYTES) {
+                await sleep(REPL_SETTLE_MS);
+                if (this.exited) {
+                    throw new Error(`claude exited during startup (code=${this.exitCode}, output=${this.cleanOutput().slice(0, 200)})`);
+                }
+                return;
+            }
+            await sleep(200);
+        }
+        const clean = this.cleanOutput();
+        throw new Error(`Timed out after ${REPL_READY_TIMEOUT_MS}ms waiting for claude REPL (got ${clean.length} bytes: ${clean.slice(0, 200)})`);
+    }
+}
+exports.PtySession = PtySession;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shellQuote(s) {
+    if (!/[\s"'\\$`!#&|;()<>]/.test(s))
+        return s;
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}