@alexjbarnes/cockpit 0.2.0 → 0.3.1

package/dist/src/server/job-storage.js

@@ -11,21 +11,36 @@ exports.pruneAllRuns = pruneAllRuns;
 exports.getLatestRun = getLatestRun;
 exports.getRecentFailureCount = getRecentFailureCount;
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
-const PREFS_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".cockpit");
-const JOBS_FILE = (0, node_path_1.join)(PREFS_DIR, "scheduled-jobs.json");
-const RUNS_DIR = (0, node_path_1.join)(PREFS_DIR, "job-runs");
+const models_1 = require("../lib/models");
+const paths_1 = require("../server/paths");
+function prefsDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function jobsFile() {
+    return (0, node_path_1.join)(prefsDir(), "scheduled-jobs.json");
+}
+function runsDir() {
+    return (0, node_path_1.join)(prefsDir(), "job-runs");
+}
 function ensureDir(dir) {
     (0, node_fs_1.mkdirSync)(dir, { recursive: true });
 }
 function runsFile(jobId) {
-    return (0, node_path_1.join)(RUNS_DIR, `${jobId}.json`);
+    return (0, node_path_1.join)(runsDir(), `${jobId}.json`);
+}
+function normalizeJob(raw) {
+    if (raw.model?.includes("[")) {
+        const split = (0, models_1.splitLegacyModel)(raw.model);
+        return { ...raw, model: split.model, contextSize: raw.contextSize ?? split.contextSize };
+    }
+    return raw;
 }
 function loadJobs() {
     try {
-        const data = JSON.parse((0, node_fs_1.readFileSync)(JOBS_FILE, "utf-8"));
-        return data.jobs || [];
+        const data = JSON.parse((0, node_fs_1.readFileSync)(jobsFile(), "utf-8"));
+        const jobs = data.jobs || [];
+        return jobs.map(normalizeJob);
     }
     catch {
         return [];
@@ -43,16 +58,16 @@ function saveJob(job) {
     else {
         jobs.push(job);
     }
-    ensureDir(PREFS_DIR);
-    (0, node_fs_1.writeFileSync)(JOBS_FILE, JSON.stringify({ jobs }, null, 2) + "\n");
+    ensureDir(prefsDir());
+    (0, node_fs_1.writeFileSync)(jobsFile(), JSON.stringify({ jobs }, null, 2) + "\n");
 }
 function deleteJob(id) {
     const jobs = loadJobs();
     const filtered = jobs.filter((j) => j.id !== id);
     if (filtered.length === jobs.length)
         return false;
-    ensureDir(PREFS_DIR);
-    (0, node_fs_1.writeFileSync)(JOBS_FILE, JSON.stringify({ jobs: filtered }, null, 2) + "\n");
+    ensureDir(prefsDir());
+    (0, node_fs_1.writeFileSync)(jobsFile(), JSON.stringify({ jobs: filtered }, null, 2) + "\n");
     const rf = runsFile(id);
     try {
         if ((0, node_fs_1.existsSync)(rf)) {
@@ -87,7 +102,7 @@ function saveRun(run) {
     const job = getJob(run.jobId);
     const maxAgeDays = job?.retentionDays ?? 90;
     pruneRuns(runs, 500, maxAgeDays);
-    ensureDir(RUNS_DIR);
+    ensureDir(runsDir());
     (0, node_fs_1.writeFileSync)(runsFile(run.jobId), JSON.stringify({ runs }, null, 2) + "\n");
 }
 function pruneRuns(runs, maxCount, maxAgeDays) {
@@ -109,7 +124,7 @@ function pruneAllRuns() {
         const before = runs.length;
         pruneRuns(runs, 500, job.retentionDays ?? 90);
         if (runs.length < before) {
-            ensureDir(RUNS_DIR);
+            ensureDir(runsDir());
             (0, node_fs_1.writeFileSync)(runsFile(job.id), JSON.stringify({ runs }, null, 2) + "\n");
         }
     }

package/dist/src/server/notification-settings.js

@@ -4,16 +4,20 @@ exports.getNotificationSettings = getNotificationSettings;
 exports.setNotificationSettings = setNotificationSettings;
 exports.updateNotificationSettings = updateNotificationSettings;
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
-const CONFIG_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".cockpit");
-const CONFIG_FILE = (0, node_path_1.join)(CONFIG_DIR, "notifications.json");
+const paths_1 = require("../server/paths");
+function configDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function configFile() {
+    return (0, node_path_1.join)(configDir(), "notifications.json");
+}
 const fallback = {
     providers: [],
 };
 function getNotificationSettings() {
     try {
-        return { ...fallback, ...JSON.parse((0, node_fs_1.readFileSync)(CONFIG_FILE, "utf-8")) };
+        return { ...fallback, ...JSON.parse((0, node_fs_1.readFileSync)(configFile(), "utf-8")) };
     }
     catch {
         return { ...fallback };
@@ -21,8 +25,8 @@ function getNotificationSettings() {
 }
 function setNotificationSettings(settings) {
     try {
-        (0, node_fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
-        (0, node_fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(settings, null, 2) + "\n");
+        (0, node_fs_1.mkdirSync)(configDir(), { recursive: true });
+        (0, node_fs_1.writeFileSync)(configFile(), JSON.stringify(settings, null, 2) + "\n");
     }
     catch {
         // best effort
@@ -32,8 +36,8 @@ function setNotificationSettings(settings) {
 function updateNotificationSettings(partial) {
     const current = getNotificationSettings();
     const updated = { ...current, ...partial };
-    if (!(0, node_fs_1.existsSync)(CONFIG_DIR))
-        (0, node_fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
-    (0, node_fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(updated, null, 2) + "\n");
+    if (!(0, node_fs_1.existsSync)(configDir()))
+        (0, node_fs_1.mkdirSync)(configDir(), { recursive: true });
+    (0, node_fs_1.writeFileSync)(configFile(), JSON.stringify(updated, null, 2) + "\n");
     return updated;
 }

package/dist/src/server/paths.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCockpitDir = getCockpitDir;
+exports.getCockpitCacheDir = getCockpitCacheDir;
+exports.getClaudeDir = getClaudeDir;
+exports.getClaudeUserConfigFile = getClaudeUserConfigFile;
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+function getCockpitDir() {
+    return process.env.COCKPIT_CONFIG_DIR ?? node_path_1.default.join((0, node_os_1.homedir)(), ".cockpit");
+}
+function getCockpitCacheDir() {
+    return process.env.COCKPIT_CACHE_DIR ?? node_path_1.default.join((0, node_os_1.homedir)(), ".cache", "cockpit");
+}
+function getClaudeDir() {
+    return process.env.CLAUDE_CONFIG_DIR ?? node_path_1.default.join((0, node_os_1.homedir)(), ".claude");
+}
+function getClaudeUserConfigFile() {
+    return node_path_1.default.join(process.env.CLAUDE_CONFIG_DIR ?? (0, node_os_1.homedir)(), ".claude.json");
+}

package/dist/src/server/plans.js

@@ -3,24 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findLatestPlanFile = findLatestPlanFile;
 exports.readPlanFile = readPlanFile;
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
-const PLANS_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "plans");
+const paths_1 = require("../server/paths");
+function plansDir() {
+    return (0, node_path_1.join)((0, paths_1.getClaudeDir)(), "plans");
+}
 function findLatestPlanFile() {
     try {
-        const files = (0, node_fs_1.readdirSync)(PLANS_DIR).filter((f) => f.endsWith(".md") && !f.includes("-agent-"));
+        const dir = plansDir();
+        const files = (0, node_fs_1.readdirSync)(dir).filter((f) => f.endsWith(".md") && !f.includes("-agent-"));
         if (files.length === 0)
             return undefined;
         let latest = files[0];
         let latestMtime = 0;
         for (const f of files) {
-            const mtime = (0, node_fs_1.statSync)((0, node_path_1.join)(PLANS_DIR, f)).mtimeMs;
+            const mtime = (0, node_fs_1.statSync)((0, node_path_1.join)(dir, f)).mtimeMs;
             if (mtime > latestMtime) {
                 latestMtime = mtime;
                 latest = f;
             }
         }
-        return (0, node_path_1.join)(PLANS_DIR, latest);
+        return (0, node_path_1.join)(dir, latest);
     }
     catch {
         return undefined;

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;