@alexjbarnes/cockpit 0.2.0 → 0.3.0

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

@@ -5,16 +5,21 @@ exports.setSessionPrefs = setSessionPrefs;
 exports.deleteSessionPrefs = deleteSessionPrefs;
 exports.findChainForCliSession = findChainForCliSession;
 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 PREFS_FILE = (0, node_path_1.join)(PREFS_DIR, "session-prefs.json");
+const models_1 = require("../lib/models");
+const paths_1 = require("../server/paths");
+function prefsDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function prefsFile() {
+    return (0, node_path_1.join)(prefsDir(), "session-prefs.json");
+}
 let cache = null;
 function load() {
     if (cache)
         return cache;
     try {
-        cache = JSON.parse((0, node_fs_1.readFileSync)(PREFS_FILE, "utf-8"));
+        cache = JSON.parse((0, node_fs_1.readFileSync)(prefsFile(), "utf-8"));
         return cache;
     }
     catch {
@@ -26,13 +31,33 @@ function save() {
     if (!cache)
         return;
     try {
-        (0, node_fs_1.mkdirSync)(PREFS_DIR, { recursive: true });
-        (0, node_fs_1.writeFileSync)(PREFS_FILE, JSON.stringify(cache, null, 2) + "\n");
+        (0, node_fs_1.mkdirSync)(prefsDir(), { recursive: true });
+        (0, node_fs_1.writeFileSync)(prefsFile(), JSON.stringify(cache, null, 2) + "\n");
     }
     catch {
         // best effort
     }
 }
+function normalize(raw) {
+    if (!raw)
+        return raw;
+    const next = { ...raw };
+    if (next.model?.includes("[")) {
+        const split = (0, models_1.splitLegacyModel)(next.model);
+        next.model = split.model;
+        if (next.contextSize === undefined)
+            next.contextSize = split.contextSize;
+    }
+    if (next.modelSlots?.main?.includes("[")) {
+        const split = (0, models_1.splitLegacyModel)(next.modelSlots.main);
+        next.modelSlots = {
+            ...next.modelSlots,
+            main: split.model,
+            mainContext: next.modelSlots.mainContext ?? split.contextSize,
+        };
+    }
+    return next;
+}
 function getSessionPrefs(sessionId) {
     const all = load();
     // Prefer chain resolution. The sidebar lists entries keyed by CLI id (one
@@ -42,8 +67,8 @@ function getSessionPrefs(sessionId) {
     // from before chain resolution was applied at write time.
     const chain = findChainForCliSession(sessionId);
     if (chain && all[chain.cockpitId])
-        return all[chain.cockpitId];
-    return all[sessionId];
+        return normalize(all[chain.cockpitId]);
+    return normalize(all[sessionId]);
 }
 function setSessionPrefs(sessionId, prefs) {
     const all = load();

package/dist/src/server/singleton.js

@@ -4,9 +4,15 @@ exports.getSessionManager = getSessionManager;
 exports.setSessionManager = setSessionManager;
 exports.getJobScheduler = getJobScheduler;
 exports.setJobScheduler = setJobScheduler;
+exports.getTerminalManager = getTerminalManager;
+exports.setTerminalManager = setTerminalManager;
+exports.getHookRouter = getHookRouter;
+exports.setHookRouter = setHookRouter;
 const session_manager_1 = require("./session-manager");
 const smKey = "__cockpit_session_manager__";
 const jsKey = "__cockpit_job_scheduler__";
+const tmKey = "__cockpit_terminal_manager__";
+const hrKey = "__cockpit_hook_router__";
 function getSessionManager() {
     const g = globalThis;
     if (!g[smKey]) {
@@ -23,3 +29,15 @@ function getJobScheduler() {
 function setJobScheduler(scheduler) {
     globalThis[jsKey] = scheduler;
 }
+function getTerminalManager() {
+    return globalThis[tmKey] || null;
+}
+function setTerminalManager(manager) {
+    globalThis[tmKey] = manager;
+}
+function getHookRouter() {
+    return globalThis[hrKey] || null;
+}
+function setHookRouter(router) {
+    globalThis[hrKey] = router;
+}

package/dist/src/server/stream-processor.js

@@ -128,7 +128,6 @@ function processEvents(events, state, options) {
         intermediateMessages: [],
         snapshot: null,
         permissionActions: [],
-        todoInputs: [],
         compactDone: false,
     };
     for (const event of events) {
@@ -198,9 +197,6 @@ function processEvents(events, state, options) {
                 status: "running",
             };
             const isAgent = tool.name === "Agent";
-            if (tool.name === "TodoWrite") {
-                result.todoInputs.push(tool.input);
-            }
             const isFromMainThread = event.assistantMessageId === state.currentAssistantMsgId;
             event.isMainThread = isFromMainThread;
             if (state.agentStack.length > 0 && !isFromMainThread) {
@@ -286,6 +282,7 @@ function processEvents(events, state, options) {
         }
         else if (event.type === "message_done" && event.message) {
             state.thinkingStartedAt = null;
+            console.log(`[stream-processor] message_done: interrupted=${!!event.interrupted}, pendingBlocks=${state.pendingBlocks.length}, pendingToolUses=${state.pendingToolUses.length}, currentMsgId=${state.currentAssistantMsgId?.slice(0, 8) ?? "null"}, clearPending=${!!event.clearPending}`);
             if (event.interrupted) {
                 if (state.currentAssistantMsgId) {
                     event.message.id = state.currentAssistantMsgId;
@@ -319,54 +316,67 @@ function processEvents(events, state, options) {
                 result.snapshot = null;
                 continue;
             }
-            if (state.currentAssistantMsgId) {
-                event.message.id = state.currentAssistantMsgId;
-            }
-            const hasStreamedText = state.pendingBlocks.some((b) => b.type === "text");
-            if (event.message.content && !hasStreamedText) {
-                state.pendingBlocks.push({ type: "text", text: event.message.content });
+            if (event.clearPending) {
+                // Transcript-loaded message: blocks are already correct; just clear pending state.
+                state.pendingToolUses.length = 0;
+                state.pendingBlocks.length = 0;
+                state.agentStack.length = 0;
+                state.currentAssistantMsgId = null;
+                result.statusChange = "idle";
+                if (options.compacting)
+                    result.compactDone = true;
+                state.flushedOnMessageDone = true;
             }
-            if (state.pendingToolUses.length === 0) {
-                const fullText = state.pendingBlocks
-                    .filter((b) => b.type === "text")
-                    .map((b) => b.text)
-                    .join("")
-                    .trim();
-                if (fullText === "No response requested.") {
-                    state.pendingBlocks.length = 0;
-                    state.currentAssistantMsgId = null;
-                    result.statusChange = "idle";
-                    state.flushedOnMessageDone = true;
-                    result.snapshot = null;
-                    continue;
+            else {
+                if (state.currentAssistantMsgId) {
+                    event.message.id = state.currentAssistantMsgId;
                 }
-                const apiErrMatch = fullText.match(/^API Error: (\d+)\s/);
-                if (apiErrMatch) {
-                    const msgMatch = fullText.match(/"message"\s*:\s*"([^"]+)"/);
-                    const errMsg = msgMatch ? `${msgMatch[1]} (HTTP ${apiErrMatch[1]})` : fullText.slice(0, 200);
-                    state.pendingBlocks.length = 0;
-                    state.pendingToolUses.length = 0;
-                    state.agentStack.length = 0;
-                    state.currentAssistantMsgId = null;
-                    result.statusChange = "idle";
-                    result.errors.push(errMsg);
-                    state.flushedOnMessageDone = true;
-                    result.snapshot = null;
-                    continue;
+                const hasStreamedText = state.pendingBlocks.some((b) => b.type === "text");
+                if (event.message.content && !hasStreamedText) {
+                    state.pendingBlocks.push({ type: "text", text: event.message.content });
                 }
+                if (state.pendingToolUses.length === 0) {
+                    const fullText = state.pendingBlocks
+                        .filter((b) => b.type === "text")
+                        .map((b) => b.text)
+                        .join("")
+                        .trim();
+                    if (fullText === "No response requested.") {
+                        state.pendingBlocks.length = 0;
+                        state.currentAssistantMsgId = null;
+                        result.statusChange = "idle";
+                        state.flushedOnMessageDone = true;
+                        result.snapshot = null;
+                        continue;
+                    }
+                    const apiErrMatch = fullText.match(/^API Error: (\d+)\s/);
+                    if (apiErrMatch) {
+                        const msgMatch = fullText.match(/"message"\s*:\s*"([^"]+)"/);
+                        const errMsg = msgMatch ? `${msgMatch[1]} (HTTP ${apiErrMatch[1]})` : fullText.slice(0, 200);
+                        state.pendingBlocks.length = 0;
+                        state.pendingToolUses.length = 0;
+                        state.agentStack.length = 0;
+                        state.currentAssistantMsgId = null;
+                        result.statusChange = "idle";
+                        result.errors.push(errMsg);
+                        state.flushedOnMessageDone = true;
+                        result.snapshot = null;
+                        continue;
+                    }
+                }
+                event.message.blocks = [...state.pendingBlocks];
+                if (event.message.toolUses.length === 0 && state.pendingToolUses.length > 0) {
+                    event.message.toolUses = [...state.pendingToolUses];
+                }
+                state.pendingToolUses.length = 0;
+                state.pendingBlocks.length = 0;
+                state.agentStack.length = 0;
+                state.currentAssistantMsgId = null;
+                result.statusChange = "idle";
+                if (options.compacting)
+                    result.compactDone = true;
+                state.flushedOnMessageDone = true;
             }
-            event.message.blocks = [...state.pendingBlocks];
-            if (event.message.toolUses.length === 0 && state.pendingToolUses.length > 0) {
-                event.message.toolUses = [...state.pendingToolUses];
-            }
-            state.pendingToolUses.length = 0;
-            state.pendingBlocks.length = 0;
-            state.agentStack.length = 0;
-            state.currentAssistantMsgId = null;
-            result.statusChange = "idle";
-            if (options.compacting)
-                result.compactDone = true;
-            state.flushedOnMessageDone = true;
         }
         if (event.type === "permission_request" && event.requestId) {
             const toolName = event.toolName || "";
@@ -418,5 +428,8 @@ function processEvents(events, state, options) {
         result.emit.push(event);
         result.snapshot = buildSnapshot(state);
     }
+    if (result.statusChange) {
+        console.log(`[stream-processor] statusChange=${result.statusChange}, emitting ${result.emit.length} events: [${result.emit.map((e) => e.type).join(", ")}]`);
+    }
     return result;
 }

package/dist/src/server/terminal-manager.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalManager = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = __importDefault(require("node:os"));
+const node_pty_1 = require("node-pty");
+const uuid_1 = require("uuid");
+const MAX_BUFFER = 100 * 1024;
+function getLoginShell() {
+    if (process.platform === "win32") {
+        return process.env.COMSPEC || "cmd.exe";
+    }
+    try {
+        const entry = (0, node_child_process_1.execSync)(`getent passwd ${node_os_1.default.userInfo().username}`, { encoding: "utf8" }).trim();
+        const shell = entry.split(":").pop();
+        if (shell)
+            return shell;
+    }
+    catch {
+        // getent not available (macOS)
+    }
+    try {
+        const shell = (0, node_child_process_1.execSync)(`dscl . -read /Users/${node_os_1.default.userInfo().username} UserShell`, { encoding: "utf8" });
+        const match = shell.match(/UserShell:\s*(.+)/);
+        if (match)
+            return match[1].trim();
+    }
+    catch {
+        // not macOS
+    }
+    return process.env.SHELL || "/bin/bash";
+}
+class TerminalManager {
+    terminals = new Map();
+    constructor() {
+        setInterval(() => {
+            for (const [id, term] of this.terminals) {
+                try {
+                    process.kill(term.pty.pid, 0);
+                }
+                catch {
+                    this.terminals.delete(id);
+                }
+            }
+        }, 15000);
+    }
+    createTerminal(cwd, shell, cols = 120, rows = 40) {
+        const id = (0, uuid_1.v4)();
+        const resolvedShell = shell || getLoginShell();
+        const pty = (0, node_pty_1.spawn)(resolvedShell, ["-l"], {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd,
+            env: process.env,
+        });
+        const instance = { id, pty, cwd, cols, rows, buffer: "", detachOffset: 0, client: null };
+        this.terminals.set(id, instance);
+        pty.onData((data) => {
+            instance.buffer += data;
+            if (instance.buffer.length > MAX_BUFFER) {
+                instance.buffer = instance.buffer.slice(-MAX_BUFFER);
+                if (instance.detachOffset > 0) {
+                    instance.detachOffset = Math.max(0, instance.detachOffset - (instance.buffer.length - MAX_BUFFER));
+                }
+            }
+            if (instance.client) {
+                instance.client(data);
+            }
+        });
+        pty.onExit(() => {
+            instance.client = null;
+            this.terminals.delete(id);
+        });
+        return id;
+    }
+    attachClient(id, sendFn) {
+        const term = this.terminals.get(id);
+        if (!term)
+            return false;
+        console.log(`[terminal] attachClient ${id.slice(0, 8)} buffer=${term.buffer.length}b detachOffset=${term.detachOffset} cols=${term.cols} rows=${term.rows}`);
+        term.client = sendFn;
+        return true;
+    }
+    getBuffer(id) {
+        return this.terminals.get(id)?.buffer ?? "";
+    }
+    getDelta(id) {
+        const term = this.terminals.get(id);
+        if (!term)
+            return "";
+        if (term.detachOffset >= term.buffer.length)
+            return "";
+        return term.buffer.slice(term.detachOffset);
+    }
+    detachClient(id) {
+        const term = this.terminals.get(id);
+        if (term) {
+            term.detachOffset = term.buffer.length;
+            term.client = null;
+        }
+    }
+    getTerminal(id) {
+        return this.terminals.get(id);
+    }
+    writeToTerminal(id, data) {
+        const term = this.terminals.get(id);
+        if (!term)
+            return false;
+        term.pty.write(data);
+        return true;
+    }
+    resizeTerminal(id, cols, rows) {
+        const term = this.terminals.get(id);
+        if (!term)
+            return false;
+        if (term.cols === cols && term.rows === rows) {
+            console.log(`[terminal] resize ${id.slice(0, 8)} no-op (already ${cols}x${rows})`);
+            return true;
+        }
+        const colsChanged = term.cols !== cols;
+        console.log(`[terminal] resize ${id.slice(0, 8)} ${term.cols}x${term.rows} -> ${cols}x${rows}${colsChanged ? " (cols changed, clearing buffer)" : ""}`);
+        if (colsChanged) {
+            term.buffer = "";
+            term.detachOffset = 0;
+        }
+        term.pty.resize(cols, rows);
+        term.cols = cols;
+        term.rows = rows;
+        return true;
+    }
+    destroyTerminal(id) {
+        const term = this.terminals.get(id);
+        if (!term)
+            return false;
+        term.client = null;
+        try {
+            term.pty.kill();
+        }
+        catch {
+            // already dead
+        }
+        this.terminals.delete(id);
+        return true;
+    }
+    listTerminals() {
+        return Array.from(this.terminals.values()).map((t) => ({ id: t.id, cwd: t.cwd }));
+    }
+}
+exports.TerminalManager = TerminalManager;

package/dist/src/server/todo-watcher.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TodoWatcher = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const paths_1 = require("../server/paths");
+const DEBOUNCE_MS = 300;
+const POLL_INTERVAL_MS = 1000;
+/**
+ * Watches both ~/.claude/todos/<sessionId>-agent-*.json (TodoWrite) and
+ * ~/.claude/tasks/<sessionId>/*.json (TaskCreate/TaskUpdate) for changes,
+ * normalizes them to TodoItem[], and calls onUpdate when the list changes.
+ */
+class TodoWatcher {
+    cliSessionId;
+    onUpdate;
+    watchers = [];
+    polling = false;
+    timer = null;
+    lastJson = "";
+    stopped = false;
+    todosDir;
+    tasksDir;
+    constructor(cliSessionId, onUpdate) {
+        this.cliSessionId = cliSessionId;
+        this.onUpdate = onUpdate;
+        const base = (0, paths_1.getClaudeDir)();
+        this.todosDir = (0, node_path_1.join)(base, "todos");
+        this.tasksDir = (0, node_path_1.join)(base, "tasks", cliSessionId);
+    }
+    start() {
+        this.watchDir(this.todosDir);
+        this.watchDir(this.tasksDir);
+        this.reload();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        for (const w of this.watchers) {
+            w.close();
+        }
+        this.watchers = [];
+        if (this.polling) {
+            try {
+                (0, node_fs_1.unwatchFile)(this.todosDir);
+            }
+            catch {
+                /* noop */
+            }
+            try {
+                (0, node_fs_1.unwatchFile)(this.tasksDir);
+            }
+            catch {
+                /* noop */
+            }
+            this.polling = false;
+        }
+    }
+    watchDir(dir) {
+        if (!(0, node_fs_1.existsSync)(dir)) {
+            this.pollDir(dir);
+            return;
+        }
+        try {
+            const w = (0, node_fs_1.watch)(dir, () => this.scheduleReload());
+            this.watchers.push(w);
+        }
+        catch {
+            this.pollDir(dir);
+        }
+    }
+    pollDir(dir) {
+        this.polling = true;
+        (0, node_fs_1.watchFile)(dir, { interval: POLL_INTERVAL_MS }, () => {
+            if (this.stopped)
+                return;
+            if ((0, node_fs_1.existsSync)(dir)) {
+                (0, node_fs_1.unwatchFile)(dir);
+                try {
+                    const w = (0, node_fs_1.watch)(dir, () => this.scheduleReload());
+                    this.watchers.push(w);
+                }
+                catch {
+                    /* stay on poll */
+                }
+            }
+            this.scheduleReload();
+        });
+    }
+    scheduleReload() {
+        if (this.stopped)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => this.reload(), DEBOUNCE_MS);
+    }
+    readOnce() {
+        const todos = this.readTodos();
+        const tasks = this.readTasks();
+        return todos.length > 0 ? todos : tasks;
+    }
+    reload() {
+        const todos = this.readTodos();
+        const tasks = this.readTasks();
+        const merged = todos.length > 0 ? todos : tasks;
+        if (merged.length === 0 && this.lastJson === "")
+            return;
+        const json = JSON.stringify(merged);
+        if (json !== this.lastJson) {
+            this.lastJson = json;
+            this.onUpdate(merged);
+        }
+    }
+    readTodos() {
+        try {
+            if (!(0, node_fs_1.existsSync)(this.todosDir))
+                return [];
+            const prefix = `${this.cliSessionId}-agent-`;
+            const files = (0, node_fs_1.readdirSync)(this.todosDir).filter((f) => f.startsWith(prefix) && f.endsWith(".json"));
+            if (files.length === 0)
+                return [];
+            const latest = files.sort().pop();
+            const raw = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(this.todosDir, latest), "utf-8"));
+            if (!Array.isArray(raw))
+                return [];
+            return raw
+                .filter((t) => t.content && t.status)
+                .map((t) => ({
+                content: t.content,
+                status: t.status,
+                activeForm: t.activeForm || undefined,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    readTasks() {
+        try {
+            if (!(0, node_fs_1.existsSync)(this.tasksDir))
+                return [];
+            const files = (0, node_fs_1.readdirSync)(this.tasksDir).filter((f) => f.endsWith(".json"));
+            if (files.length === 0)
+                return [];
+            const tasks = [];
+            for (const file of files) {
+                try {
+                    const raw = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(this.tasksDir, file), "utf-8"));
+                    if (raw.status === "deleted")
+                        continue;
+                    tasks.push({
+                        content: raw.subject || raw.description || "",
+                        status: mapTaskStatus(raw.status),
+                        activeForm: raw.activeForm || undefined,
+                    });
+                }
+                catch {
+                    // skip malformed file
+                }
+            }
+            return tasks;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.TodoWatcher = TodoWatcher;
+function mapTaskStatus(status) {
+    if (status === "in_progress")
+        return "in_progress";
+    if (status === "completed")
+        return "completed";
+    return "pending";
+}

package/dist/src/server/transcript-watcher.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranscriptWatcher = void 0;
+const node_fs_1 = require("node:fs");
+const transcript_1 = require("./transcript");
+const DEBOUNCE_MS = 250;
+const POLL_INTERVAL_MS = 500;
+class TranscriptWatcher {
+    sessionId;
+    cwd;
+    onUpdate;
+    watcher = null;
+    polling = false;
+    timer = null;
+    lastSize = 0;
+    stopped = false;
+    filePath;
+    constructor(sessionId, cwd, onUpdate) {
+        this.sessionId = sessionId;
+        this.cwd = cwd;
+        this.onUpdate = onUpdate;
+        this.filePath = (0, transcript_1.getTranscriptPath)(sessionId, cwd);
+    }
+    start() {
+        if ((0, node_fs_1.existsSync)(this.filePath)) {
+            this.watchWithInotify();
+        }
+        else {
+            this.watchWithPoll();
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.polling) {
+            (0, node_fs_1.unwatchFile)(this.filePath);
+            this.polling = false;
+        }
+        await this.reload();
+    }
+    watchWithInotify() {
+        try {
+            this.watcher = (0, node_fs_1.watch)(this.filePath, () => this.scheduleReload());
+        }
+        catch {
+            this.watchWithPoll();
+        }
+    }
+    watchWithPoll() {
+        this.polling = true;
+        (0, node_fs_1.watchFile)(this.filePath, { interval: POLL_INTERVAL_MS }, () => {
+            if (this.stopped)
+                return;
+            if (!this.watcher && (0, node_fs_1.existsSync)(this.filePath)) {
+                (0, node_fs_1.unwatchFile)(this.filePath);
+                this.polling = false;
+                this.watchWithInotify();
+            }
+            this.scheduleReload();
+        });
+    }
+    scheduleReload() {
+        if (this.stopped)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => this.reload(), DEBOUNCE_MS);
+    }
+    async reload() {
+        try {
+            const result = await (0, transcript_1.loadTranscript)(this.sessionId, this.cwd, { tailLines: 150 });
+            if (result.totalSize !== this.lastSize) {
+                this.lastSize = result.totalSize;
+                this.onUpdate(result.messages, result.lastUsage);
+            }
+        }
+        catch {
+            if (!this.stopped) {
+                this.timer = setTimeout(() => this.reload(), 100);
+            }
+        }
+    }
+}
+exports.TranscriptWatcher = TranscriptWatcher;