@alexjbarnes/cockpit 0.2.0 → 0.3.1

package/dist/src/server/hook-event-translator.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateHookEvent = translateHookEvent;
+exports.newPermissionRequestId = newPermissionRequestId;
+const uuid_1 = require("uuid");
+/**
+ * Convert a single hook payload from claude into ParsedEvent objects that
+ * the existing stream-processor / session emitter pipeline can consume.
+ *
+ * Pure function: no state, no side effects. The session manager owns
+ * status tracking, permission request bookkeeping, and emission.
+ *
+ * Returns an empty array for events that don't map to a ParsedEvent
+ * (e.g. UserPromptSubmit, which only affects status).
+ */
+function translateHookEvent(eventName, payload) {
+    switch (eventName) {
+        case "PreToolUse":
+            return translatePreToolUse(payload);
+        case "PostToolUse":
+            return translatePostToolUse(payload);
+        case "Stop":
+            return translateStop(payload);
+        case "StopFailure":
+            return translateStopFailure(payload);
+        case "PermissionRequest":
+            return translatePermissionRequest(payload);
+        case "Notification":
+            return translateNotification(payload);
+        case "SubagentStart":
+            return translateSubagentStart(payload);
+        case "SubagentStop":
+            return translateSubagentStop(payload);
+        case "PreCompact":
+            return translatePreCompact(payload);
+        case "PostCompact":
+            return translatePostCompact(payload);
+        case "UserPromptSubmit":
+        case "UserPromptExpansion":
+            return [];
+    }
+}
+/** PermissionRequest payloads don't carry a request ID; cockpit synthesises one. */
+function newPermissionRequestId() {
+    return (0, uuid_1.v4)();
+}
+function translatePreToolUse(payload) {
+    const toolName = stringOr(payload.tool_name, "unknown");
+    const toolInput = payload.tool_input;
+    const toolId = stringOr(payload.tool_use_id, "");
+    const events = [
+        {
+            type: "system_message",
+            text: "__tool_use_start",
+        },
+        {
+            type: "tool_use_start",
+            toolName,
+            toolId: toolId || undefined,
+            toolInput: toolInput ? JSON.stringify(toolInput) : "",
+        },
+    ];
+    if (toolName === "EnterPlanMode") {
+        events.push({ type: "system_message", text: "__permission_mode::plan" });
+    }
+    return events;
+}
+function translatePostToolUse(payload) {
+    const toolName = stringOr(payload.tool_name, "unknown");
+    const toolId = stringOr(payload.tool_use_id, "");
+    const toolInput = payload.tool_input;
+    const response = payload.tool_response;
+    const output = extractToolOutput(response);
+    const filePath = extractFilePath(toolInput);
+    const events = [
+        {
+            type: "tool_result",
+            toolId: toolId || undefined,
+            toolOutput: output,
+            filePath,
+        },
+    ];
+    if (toolName === "ExitPlanMode") {
+        events.push({ type: "system_message", text: "__permission_mode::standard" });
+    }
+    return events;
+}
+function translateStop(payload) {
+    const text = stringOr(payload.last_assistant_message, "");
+    const message = {
+        id: (0, uuid_1.v4)(),
+        role: "assistant",
+        content: text,
+        toolUses: [],
+        blocks: [],
+        timestamp: Date.now(),
+    };
+    return [{ type: "message_done", message }];
+}
+function translateStopFailure(payload) {
+    const errorType = stringOr(payload.error_type, "unknown");
+    const errorMessage = stringOr(payload.error_message, "Unknown error");
+    const message = {
+        id: (0, uuid_1.v4)(),
+        role: "assistant",
+        content: "",
+        toolUses: [],
+        blocks: [],
+        timestamp: Date.now(),
+    };
+    return [
+        { type: "message_done", message },
+        { type: "system_message", text: `__stop_failure::${errorType}::${errorMessage}` },
+    ];
+}
+function translatePermissionRequest(payload) {
+    const toolName = stringOr(payload.tool_name, "unknown");
+    const toolInput = payload.tool_input;
+    return [
+        {
+            type: "permission_request",
+            requestId: newPermissionRequestId(),
+            toolName,
+            toolInput: toolInput ? JSON.stringify(toolInput) : "",
+            rawToolInput: toolInput,
+        },
+    ];
+}
+function translateSubagentStart(payload) {
+    const sessionId = stringOr(payload.session_id, (0, uuid_1.v4)());
+    const agentId = stringOr(payload.agent_id, "");
+    const agentType = stringOr(payload.agent_type, "");
+    const description = stringOr(payload.description, "");
+    return [
+        {
+            type: "task_update",
+            taskInfo: {
+                taskId: sessionId,
+                toolUseId: agentId,
+                status: "running",
+                title: agentType || "Agent",
+                description: description || agentType || "Subagent running",
+            },
+        },
+    ];
+}
+function translateSubagentStop(payload) {
+    const sessionId = stringOr(payload.session_id, "");
+    const agentId = stringOr(payload.agent_id, "");
+    const agentType = stringOr(payload.agent_type, "");
+    const lastMessage = stringOr(payload.last_assistant_message, "");
+    const description = stringOr(payload.description, "");
+    return [
+        {
+            type: "task_update",
+            taskInfo: {
+                taskId: sessionId,
+                toolUseId: agentId,
+                status: "completed",
+                title: agentType || "Agent",
+                description: description || agentType || "Subagent completed",
+                summary: lastMessage.slice(0, 500) || undefined,
+            },
+        },
+    ];
+}
+function translatePreCompact(_payload) {
+    return [{ type: "system_message", text: "__compact::hook_start" }];
+}
+function translatePostCompact(_payload) {
+    return [{ type: "system_message", text: "__compact::hook_done" }];
+}
+function translateNotification(payload) {
+    const message = stringOr(payload.message, "");
+    if (!message)
+        return [];
+    return [{ type: "system_message", text: `__notification::${message}` }];
+}
+function stringOr(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}
+function extractToolOutput(response) {
+    if (response == null)
+        return "";
+    if (typeof response === "string")
+        return response;
+    if (typeof response === "object") {
+        const obj = response;
+        if (typeof obj.stdout === "string") {
+            let out = obj.stdout;
+            if (typeof obj.stderr === "string" && obj.stderr.length > 0)
+                out += `\n${obj.stderr}`;
+            return out;
+        }
+        if (typeof obj.content === "string")
+            return obj.content;
+        return JSON.stringify(response);
+    }
+    return String(response);
+}
+function extractFilePath(toolInput) {
+    if (!toolInput)
+        return undefined;
+    if (typeof toolInput.file_path === "string")
+        return toolInput.file_path;
+    if (typeof toolInput.filePath === "string")
+        return toolInput.filePath;
+    if (typeof toolInput.path === "string")
+        return toolInput.path;
+    return undefined;
+}

package/dist/src/server/hook-router.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookRouter = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_http_1 = require("node:http");
+class HookRouter {
+    server = null;
+    port = 0;
+    sessions = new Map();
+    async start(host = "127.0.0.1", port = 0) {
+        this.server = (0, node_http_1.createServer)((req, res) => this.handle(req, res));
+        await new Promise((resolve, reject) => {
+            this.server.once("error", reject);
+            this.server.listen(port, host, () => {
+                const addr = this.server.address();
+                if (addr && typeof addr === "object")
+                    this.port = addr.port;
+                resolve();
+            });
+        });
+        return { host, port: this.port };
+    }
+    async stop() {
+        if (!this.server)
+            return;
+        await new Promise((resolve) => this.server.close(() => resolve()));
+        this.server = null;
+    }
+    getUrl(host = "127.0.0.1") {
+        return `http://${host}:${this.port}`;
+    }
+    register(sessionId, handler) {
+        const token = (0, node_crypto_1.randomBytes)(24).toString("hex");
+        this.sessions.set(sessionId, { token, handler, pendingResponses: new Set() });
+        return token;
+    }
+    unregister(sessionId) {
+        const registered = this.sessions.get(sessionId);
+        if (registered) {
+            for (const res of registered.pendingResponses) {
+                if (!res.writableEnded) {
+                    res.statusCode = 503;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ exitCode: 0, stderr: "session restarted" }));
+                }
+            }
+            registered.pendingResponses.clear();
+        }
+        this.sessions.delete(sessionId);
+    }
+    async handle(req, res) {
+        if (req.method !== "POST") {
+            res.statusCode = 405;
+            res.end();
+            return;
+        }
+        const url = req.url || "";
+        const match = url.match(/^\/hook\/([A-Za-z]+)(?:\?.*)?$/);
+        if (!match) {
+            res.statusCode = 404;
+            res.end();
+            return;
+        }
+        const eventName = match[1];
+        const sessionId = req.headers["x-cockpit-session"];
+        const token = req.headers["x-cockpit-token"];
+        if (typeof sessionId !== "string" || typeof token !== "string") {
+            res.statusCode = 400;
+            res.end("missing session or token header");
+            return;
+        }
+        const registered = this.sessions.get(sessionId);
+        if (!registered || registered.token !== token) {
+            res.statusCode = 403;
+            res.end("unauthorized");
+            return;
+        }
+        let body = "";
+        req.setEncoding("utf8");
+        for await (const chunk of req)
+            body += chunk;
+        let payload;
+        try {
+            payload = body ? JSON.parse(body) : {};
+        }
+        catch {
+            res.statusCode = 400;
+            res.end("invalid json");
+            return;
+        }
+        console.log(`[hook-router] received ${eventName} for session ${sessionId.slice(0, 8)}`);
+        registered.pendingResponses.add(res);
+        try {
+            const response = await this.dispatch(registered.handler, eventName, payload);
+            if (!res.writableEnded) {
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify(response));
+            }
+            console.log(`[hook-router] dispatched ${eventName} for session ${sessionId.slice(0, 8)} ok`);
+        }
+        catch (err) {
+            console.error(`[hook-router] dispatch ${eventName} for session ${sessionId.slice(0, 8)} THREW:`, err);
+            if (!res.writableEnded) {
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ exitCode: 1, stderr: String(err) }));
+            }
+        }
+        finally {
+            registered.pendingResponses.delete(res);
+        }
+    }
+    async dispatch(handler, eventName, payload) {
+        if (eventName === "PermissionRequest") {
+            if (!handler.onPermissionRequest) {
+                return { stdout: permissionAllowJson(), exitCode: 0 };
+            }
+            const decision = await handler.onPermissionRequest(payload);
+            return { stdout: permissionDecisionJson(decision), exitCode: 0 };
+        }
+        const handlerMap = {
+            PreToolUse: handler.onPreToolUse,
+            PostToolUse: handler.onPostToolUse,
+            Stop: handler.onStop,
+            StopFailure: handler.onStopFailure,
+            UserPromptSubmit: handler.onUserPromptSubmit,
+            UserPromptExpansion: handler.onUserPromptExpansion,
+            SubagentStart: handler.onSubagentStart,
+            SubagentStop: handler.onSubagentStop,
+            Notification: handler.onNotification,
+            PreCompact: handler.onPreCompact,
+            PostCompact: handler.onPostCompact,
+        };
+        const fn = handlerMap[eventName];
+        if (!fn) {
+            console.log(`[hook-router] no handler for ${eventName}, returning empty response`);
+            return {};
+        }
+        const result = await fn(payload);
+        return result || {};
+    }
+}
+exports.HookRouter = HookRouter;
+function permissionAllowJson() {
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } } });
+}
+function permissionDecisionJson(decision) {
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: "PermissionRequest", decision } });
+}

package/dist/src/server/inbox.js

@@ -13,20 +13,24 @@ exports.clearInbox = clearInbox;
 exports.parseInboxBlock = parseInboxBlock;
 exports.parseErrorBlock = parseErrorBlock;
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const uuid_1 = require("uuid");
+const paths_1 = require("../server/paths");
 const notifications_1 = require("./notifications");
-const INBOX_DIR = node_path_1.default.join((0, node_os_1.homedir)(), ".cockpit");
-const INBOX_FILE = node_path_1.default.join(INBOX_DIR, "inbox.jsonl");
+function inboxDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function inboxFile() {
+    return node_path_1.default.join(inboxDir(), "inbox.jsonl");
+}
 function ensureDir() {
-    if (!(0, node_fs_1.existsSync)(INBOX_DIR))
-        (0, node_fs_1.mkdirSync)(INBOX_DIR, { recursive: true });
+    if (!(0, node_fs_1.existsSync)(inboxDir()))
+        (0, node_fs_1.mkdirSync)(inboxDir(), { recursive: true });
 }
 function readAll() {
-    if (!(0, node_fs_1.existsSync)(INBOX_FILE))
+    if (!(0, node_fs_1.existsSync)(inboxFile()))
         return [];
-    const raw = (0, node_fs_1.readFileSync)(INBOX_FILE, "utf-8");
+    const raw = (0, node_fs_1.readFileSync)(inboxFile(), "utf-8");
     const messages = [];
     for (const line of raw.split("\n")) {
         if (!line.trim())
@@ -40,7 +44,7 @@ function readAll() {
 }
 function writeAll(messages) {
     ensureDir();
-    (0, node_fs_1.writeFileSync)(INBOX_FILE, messages.map((m) => JSON.stringify(m)).join("\n") + "\n");
+    (0, node_fs_1.writeFileSync)(inboxFile(), messages.map((m) => JSON.stringify(m)).join("\n") + "\n");
 }
 function getInboxMessages() {
     return readAll().sort((a, b) => b.createdAt - a.createdAt);
@@ -73,12 +77,12 @@ function addInboxMessage(msg) {
     });
     return entry;
 }
-function markRead(id) {
+function markRead(id, read = true) {
     const messages = readAll();
     const msg = messages.find((m) => m.id === id);
     if (!msg)
         return false;
-    msg.read = true;
+    msg.read = read;
     writeAll(messages);
     return true;
 }

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireJobLock = acquireJobLock;
+exports.releaseJobLock = releaseJobLock;
+exports.forceReleaseJobLock = forceReleaseJobLock;
+exports.clearStaleLocks = clearStaleLocks;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const paths_1 = require("../server/paths");
+function locksDir() {
+    return (0, node_path_1.join)((0, paths_1.getCockpitDir)(), "job-locks");
+}
+function lockPath(jobId) {
+    return (0, node_path_1.join)(locksDir(), `${jobId}.lock`);
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readLock(jobId) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(lockPath(jobId), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function acquireJobLock(jobId, runId) {
+    (0, node_fs_1.mkdirSync)(locksDir(), { recursive: true });
+    const fp = lockPath(jobId);
+    const data = { pid: process.pid, runId, acquiredAt: Date.now() };
+    try {
+        (0, node_fs_1.writeFileSync)(fp, JSON.stringify(data) + "\n", { flag: "wx" });
+        return true;
+    }
+    catch (err) {
+        if (err.code !== "EEXIST")
+            return false;
+    }
+    const existing = readLock(jobId);
+    if (!existing) {
+        try {
+            (0, node_fs_1.writeFileSync)(fp, JSON.stringify(data) + "\n", { flag: "wx" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (isPidAlive(existing.pid)) {
+        return false;
+    }
+    console.log(`[scheduler] clearing stale lock for job ${jobId} (pid ${existing.pid} is dead)`);
+    try {
+        (0, node_fs_1.unlinkSync)(fp);
+    }
+    catch { }
+    try {
+        (0, node_fs_1.writeFileSync)(fp, JSON.stringify(data) + "\n", { flag: "wx" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseJobLock(jobId) {
+    try {
+        const existing = readLock(jobId);
+        if (existing && existing.pid === process.pid) {
+            (0, node_fs_1.unlinkSync)(lockPath(jobId));
+        }
+    }
+    catch { }
+}
+function forceReleaseJobLock(jobId) {
+    try {
+        (0, node_fs_1.unlinkSync)(lockPath(jobId));
+    }
+    catch { }
+}
+function clearStaleLocks() {
+    if (!(0, node_fs_1.existsSync)(locksDir()))
+        return;
+    const { readdirSync } = require("node:fs");
+    for (const file of readdirSync(locksDir())) {
+        if (!file.endsWith(".lock"))
+            continue;
+        const jobId = file.slice(0, -5);
+        const lock = readLock(jobId);
+        if (lock && !isPidAlive(lock.pid)) {
+            console.log(`[scheduler] removing stale lock for job ${jobId} (pid ${lock.pid})`);
+            try {
+                (0, node_fs_1.unlinkSync)(lockPath(jobId));
+            }
+            catch { }
+        }
+    }
+}

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

@@ -5,14 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JobScheduler = void 0;
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const uuid_1 = require("uuid");
+const paths_1 = require("../server/paths");
 const cron_utils_1 = require("./cron-utils");
 const inbox_1 = require("./inbox");
+const job_lock_1 = require("./job-lock");
 const job_storage_1 = require("./job-storage");
 const transcript_1 = require("./transcript");
-const SCRATCHPAD_DIR = node_path_1.default.join((0, node_os_1.homedir)(), ".cockpit", "jobs");
+function scratchpadDir() {
+    return node_path_1.default.join((0, paths_1.getCockpitDir)(), "jobs");
+}
 const JOB_PROMPT_HEADER = [
     "You are running as an autonomous scheduled job. There is no human operator in this session.",
     "Do not ask clarifying questions. Do not wait for user input. Make reasonable assumptions and proceed.",
@@ -43,7 +46,7 @@ function buildJobPrompt(job) {
             parts.push("No tools or MCP servers are allowed.");
     }
     if (job.cwd) {
-        const storageDir = node_path_1.default.join(SCRATCHPAD_DIR, job.id);
+        const storageDir = node_path_1.default.join(scratchpadDir(), job.id);
         parts.push("");
         parts.push(`Storage: If you need to persist any files between runs (state, cache, data), save them in ${storageDir}`);
         parts.push("Do not store persistent files in the working directory as it is a git repository.");
@@ -155,6 +158,9 @@ class JobScheduler {
             clearInterval(this.timer);
             this.timer = null;
         }
+        for (const jobId of this.runningJobs.keys()) {
+            (0, job_lock_1.releaseJobLock)(jobId);
+        }
         console.log("[scheduler] stopped");
     }
     reloadJobs() {
@@ -171,6 +177,7 @@ class JobScheduler {
         return this.executeJob(job);
     }
     recoverState() {
+        (0, job_lock_1.clearStaleLocks)();
         (0, job_storage_1.pruneAllRuns)();
         const now = Date.now();
         const jobs = (0, job_storage_1.loadJobs)();
@@ -186,6 +193,7 @@ class JobScheduler {
                     run.completedAt = now;
                     run.durationMs = now - run.startedAt;
                     (0, job_storage_1.saveRun)(run);
+                    (0, job_lock_1.forceReleaseJobLock)(job.id);
                 }
             }
         }
@@ -209,6 +217,7 @@ class JobScheduler {
                     run.messageCount = (0, transcript_1.countTranscriptMessages)(run.sessionId, run.cwd);
                 (0, job_storage_1.saveRun)(run);
                 this.runningJobs.delete(jobId);
+                (0, job_lock_1.releaseJobLock)(jobId);
             }
         }
         const jobs = (0, job_storage_1.loadJobs)();
@@ -244,10 +253,15 @@ class JobScheduler {
     }
     async executeJob(job) {
         const runId = (0, uuid_1.v4)();
-        const jobCwd = job.cwd || node_path_1.default.join(SCRATCHPAD_DIR, job.id);
-        (0, node_fs_1.mkdirSync)(node_path_1.default.join(SCRATCHPAD_DIR, job.id), { recursive: true });
+        if (!(0, job_lock_1.acquireJobLock)(job.id, runId)) {
+            console.log(`[scheduler] skipping job ${job.name}: another process holds the lock`);
+            throw new Error("Could not acquire job lock - another process is running this job");
+        }
+        const jobCwd = job.cwd || node_path_1.default.join(scratchpadDir(), job.id);
+        (0, node_fs_1.mkdirSync)(node_path_1.default.join(scratchpadDir(), job.id), { recursive: true });
         const sessionInfo = this.sessionManager.createSession(jobCwd, `[job] ${job.name}`, {
             bypassPermissions: !!job.bypassPermissions,
+            runtime: job.runtime,
         });
         const sessionId = sessionInfo.id;
         const run = {
@@ -265,6 +279,7 @@ class JobScheduler {
         this.runningJobs.set(job.id, run);
         const toolTracker = new Map();
         let lastAssistantText = "";
+        const enabledServers = new Set(job.mcpServers || []);
         const unsubEvent = this.sessionManager.subscribe(sessionId, (event) => {
             if (event.type === "tool_use_start" && event.toolId) {
                 toolTracker.set(event.toolId, {
@@ -319,7 +334,6 @@ class JobScheduler {
                 }
             }
         });
-        const enabledServers = new Set(job.mcpServers || []);
         const initCleanup = this.sessionManager.onInit(sessionId, (initData) => {
             for (const server of initData.mcpServers) {
                 if (!enabledServers.has(server.name)) {
@@ -328,7 +342,7 @@ class JobScheduler {
             }
         });
         if (job.model) {
-            this.sessionManager.setModel(sessionId, job.model);
+            this.sessionManager.setModel(sessionId, job.model, job.contextSize);
         }
         if (job.thinkingLevel) {
             this.sessionManager.setThinkingLevel(sessionId, job.thinkingLevel);
@@ -375,7 +389,7 @@ class JobScheduler {
                 if (transcriptCount > run.messageCount)
                     run.messageCount = transcriptCount;
                 (0, job_storage_1.saveRun)(run);
-                if (job.inboxOutput && lastAssistantText) {
+                if (job.inboxOutput && lastAssistantText && finalStatus === "success") {
                     const inbox = (0, inbox_1.parseInboxBlock)(lastAssistantText);
                     if (inbox) {
                         (0, inbox_1.addInboxMessage)({ ...inbox, jobId: job.id, jobName: job.name, runId: run.id, notifyProviders: job.notifyProviders });
@@ -393,6 +407,7 @@ class JobScheduler {
                     });
                 }
                 this.runningJobs.delete(job.id);
+                (0, job_lock_1.releaseJobLock)(job.id);
                 resolve(run);
             };
             this.sessionManager.sendMessage(sessionId, buildJobPrompt(job));