@alexjbarnes/cockpit 0.1.1 → 0.3.0

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

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInboxMessages = getInboxMessages;
+exports.getUnreadCount = getUnreadCount;
+exports.addInboxMessage = addInboxMessage;
+exports.markRead = markRead;
+exports.markAllRead = markAllRead;
+exports.deleteInboxMessage = deleteInboxMessage;
+exports.clearInbox = clearInbox;
+exports.parseInboxBlock = parseInboxBlock;
+exports.parseErrorBlock = parseErrorBlock;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const uuid_1 = require("uuid");
+const paths_1 = require("../server/paths");
+const notifications_1 = require("./notifications");
+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)(inboxDir()))
+        (0, node_fs_1.mkdirSync)(inboxDir(), { recursive: true });
+}
+function readAll() {
+    if (!(0, node_fs_1.existsSync)(inboxFile()))
+        return [];
+    const raw = (0, node_fs_1.readFileSync)(inboxFile(), "utf-8");
+    const messages = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            messages.push(JSON.parse(line));
+        }
+        catch { }
+    }
+    return messages;
+}
+function writeAll(messages) {
+    ensureDir();
+    (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);
+}
+function getUnreadCount() {
+    return readAll().filter((m) => !m.read).length;
+}
+function addInboxMessage(msg) {
+    const messages = readAll();
+    const entry = {
+        id: (0, uuid_1.v4)(),
+        title: msg.title,
+        body: msg.body,
+        priority: msg.priority || "info",
+        jobId: msg.jobId,
+        jobName: msg.jobName,
+        runId: msg.runId,
+        createdAt: Date.now(),
+        read: false,
+    };
+    messages.push(entry);
+    writeAll(messages);
+    (0, notifications_1.dispatchNotification)({
+        title: entry.title,
+        body: entry.body,
+        priority: entry.priority,
+        source: "inbox",
+        url: `/inbox/${entry.id}`,
+        providerIds: msg.notifyProviders,
+    });
+    return entry;
+}
+function markRead(id, read = true) {
+    const messages = readAll();
+    const msg = messages.find((m) => m.id === id);
+    if (!msg)
+        return false;
+    msg.read = read;
+    writeAll(messages);
+    return true;
+}
+function markAllRead() {
+    const messages = readAll();
+    for (const m of messages)
+        m.read = true;
+    writeAll(messages);
+}
+function deleteInboxMessage(id) {
+    const messages = readAll();
+    const idx = messages.findIndex((m) => m.id === id);
+    if (idx === -1)
+        return false;
+    messages.splice(idx, 1);
+    writeAll(messages);
+    return true;
+}
+function clearInbox() {
+    writeAll([]);
+}
+const INBOX_BLOCK_RE = /```cockpit-inbox\s*\n([\s\S]*?)\n```/;
+function parseInboxBlock(text) {
+    const match = INBOX_BLOCK_RE.exec(text);
+    if (!match)
+        return null;
+    try {
+        const parsed = JSON.parse(match[1]);
+        if (typeof parsed.title !== "string" || typeof parsed.body !== "string")
+            return null;
+        return { title: parsed.title, body: parsed.body, priority: parsed.priority };
+    }
+    catch {
+        return null;
+    }
+}
+const ERROR_BLOCK_RE = /```cockpit-error\s*\n([\s\S]*?)\n```/;
+function parseErrorBlock(text) {
+    const match = ERROR_BLOCK_RE.exec(text);
+    if (!match)
+        return null;
+    try {
+        const parsed = JSON.parse(match[1]);
+        if (typeof parsed.error !== "string")
+            return null;
+        return { error: parsed.error, details: parsed.details };
+    }
+    catch {
+        return null;
+    }
+}

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 { }
+        }
+    }
+}