@alexjbarnes/cockpit 0.2.0 → 0.3.0

package/dist/src/server/claude-settings.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.prepareHookSettings = prepareHookSettings;
+exports.cleanupHookSettings = cleanupHookSettings;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../server/paths");
+const hook_bridge_path_1 = require("./hook-bridge-path");
+const HOOK_EVENTS = [
+    "PreToolUse",
+    "PostToolUse",
+    "Stop",
+    "StopFailure",
+    "UserPromptSubmit",
+    "UserPromptExpansion",
+    "SubagentStart",
+    "SubagentStop",
+    "Notification",
+    "PermissionRequest",
+    "PreCompact",
+    "PostCompact",
+];
+const PERMISSION_HOOK_TIMEOUT_SEC = 86400;
+/**
+ * Build and write the per-session claude settings file. The file lives in
+ * `~/.cache/cockpit/hook-settings/<sessionId>.json` (or `$TMPDIR` if HOME
+ * is not writable). Call `cleanupHookSettings` on session destroy.
+ */
+async function prepareHookSettings(opts) {
+    const bridge = (0, hook_bridge_path_1.resolveHookBridgePath)();
+    const base = await loadUserSettings();
+    const hooks = buildHooksBlock(bridge);
+    const existingHooks = (base.hooks ?? {});
+    for (const [event, entries] of Object.entries(existingHooks)) {
+        if (Array.isArray(entries) && entries.length > 0) {
+            if (hooks[event]) {
+                hooks[event] = [...entries, ...hooks[event]];
+            }
+        }
+    }
+    const baseAllow = Array.isArray(base.permissions?.allow)
+        ? base.permissions.allow
+        : [];
+    const baseDeny = Array.isArray(base.permissions?.deny)
+        ? base.permissions.deny
+        : [];
+    const settings = {
+        ...base,
+        hooks,
+        permissions: {
+            ...(base.permissions ?? {}),
+            allow: [...baseAllow, ...(opts.allowList ?? [])],
+            deny: [...baseDeny, ...(opts.denyList ?? [])],
+        },
+        // cockpit drives the CLI programmatically and owns the bypass-mode UX
+        // itself (flipping bypass on is a deliberate cockpit UI action). The CLI's
+        // interactive "WARNING: Bypass Permissions mode" dialog has nowhere to go
+        // when there's no human at the TUI, so suppress it here.
+        skipDangerousModePermissionPrompt: true,
+    };
+    const dir = await resolveSettingsDir();
+    const settingsPath = node_path_1.default.join(dir, `${opts.sessionId}.json`);
+    await (0, promises_1.writeFile)(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+    return {
+        settingsPath,
+        env: {
+            COCKPIT_HOOK_URL: opts.hookUrl,
+            COCKPIT_HOOK_TOKEN: opts.hookToken,
+            COCKPIT_SESSION_ID: opts.sessionId,
+        },
+    };
+}
+async function cleanupHookSettings(sessionId) {
+    const dir = await resolveSettingsDir();
+    const settingsPath = node_path_1.default.join(dir, `${sessionId}.json`);
+    await (0, promises_1.rm)(settingsPath, { force: true });
+}
+function buildHooksBlock(bridgePath) {
+    const block = {};
+    for (const event of HOOK_EVENTS) {
+        const cmd = {
+            type: "command",
+            command: `node ${shellQuote(bridgePath)} ${event}`,
+        };
+        if (event === "PermissionRequest") {
+            cmd.timeout = PERMISSION_HOOK_TIMEOUT_SEC;
+        }
+        block[event] = [{ matcher: "", hooks: [cmd] }];
+    }
+    return block;
+}
+function shellQuote(p) {
+    if (!/[\s"'\\$`]/.test(p))
+        return p;
+    return `'${p.replace(/'/g, "'\\''")}'`;
+}
+function userSettingsPaths() {
+    return [node_path_1.default.join((0, paths_1.getClaudeDir)(), "settings.json"), node_path_1.default.join((0, paths_1.getClaudeDir)(), "settings.local.json")];
+}
+async function loadUserSettings() {
+    let merged = {};
+    for (const p of userSettingsPaths()) {
+        try {
+            const raw = await (0, promises_1.readFile)(p, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                merged = deepMerge(merged, parsed);
+            }
+        }
+        catch {
+            // file missing or malformed
+        }
+    }
+    return merged;
+}
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const tVal = target[key];
+        const sVal = source[key];
+        if (isPlainObject(tVal) && isPlainObject(sVal)) {
+            result[key] = deepMerge(tVal, sVal);
+        }
+        else {
+            result[key] = sVal;
+        }
+    }
+    return result;
+}
+function isPlainObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+let settingsDirCache = null;
+async function resolveSettingsDir() {
+    if (settingsDirCache)
+        return settingsDirCache;
+    const primary = node_path_1.default.join((0, paths_1.getCockpitCacheDir)(), "hook-settings");
+    try {
+        await (0, promises_1.mkdir)(primary, { recursive: true });
+        settingsDirCache = primary;
+        return primary;
+    }
+    catch {
+        const fallback = node_path_1.default.join((0, node_os_1.tmpdir)(), "cockpit-hook-settings");
+        await (0, promises_1.mkdir)(fallback, { recursive: true });
+        settingsDirCache = fallback;
+        return fallback;
+    }
+}

package/dist/src/server/cli-init-fetch.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCliInitData = fetchCliInitData;
+const node_child_process_1 = require("node:child_process");
+const FETCH_TIMEOUT_MS = 30_000;
+/**
+ * Spawn a one-shot `claude -p --output-format stream-json` process and extract
+ * the system/init event. Kills the process as soon as init is received (before
+ * any API call for the prompt), so this costs zero tokens.
+ */
+function fetchCliInitData(opts) {
+    const bin = opts.bin ?? "claude";
+    const args = ["-p", "--verbose", "--output-format", "stream-json", "hi"];
+    return new Promise((resolve) => {
+        let resolved = false;
+        const done = (result) => {
+            if (resolved)
+                return;
+            resolved = true;
+            try {
+                proc.kill();
+            }
+            catch { }
+            resolve(result);
+        };
+        console.log(`[cli-init-fetch] spawning: ${bin} ${args.join(" ")} (cwd=${opts.cwd})`);
+        const proc = (0, node_child_process_1.spawn)(bin, args, {
+            cwd: opts.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let buffer = "";
+        let stderrBuf = "";
+        proc.stdout.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === "system" && event.subtype === "init") {
+                        const initData = parseInitEvent(event);
+                        console.log(`[cli-init-fetch] got init: ${initData.slashCommands.length} commands, ${initData.skills.length} skills`);
+                        done(initData);
+                        return;
+                    }
+                }
+                catch {
+                    // not JSON, skip
+                }
+            }
+        });
+        proc.stderr?.on("data", (chunk) => {
+            stderrBuf += chunk.toString();
+            if (stderrBuf.length > 2048)
+                stderrBuf = stderrBuf.slice(-1024);
+        });
+        proc.on("close", (code) => {
+            console.log(`[cli-init-fetch] process exited code=${code}${stderrBuf ? ` stderr=${stderrBuf.slice(0, 200)}` : ""}`);
+            done(null);
+        });
+        proc.on("error", (err) => {
+            console.log(`[cli-init-fetch] spawn error: ${err.message}`);
+            done(null);
+        });
+        setTimeout(() => {
+            console.log("[cli-init-fetch] timeout reached, giving up");
+            done(null);
+        }, FETCH_TIMEOUT_MS);
+    });
+}
+function parseInitEvent(event) {
+    const slashCommands = (event.slash_commands || []);
+    const skills = (event.skills || []);
+    const rawAgents = (event.agents || []);
+    const agents = rawAgents.map((a) => typeof a === "string" ? { name: a } : { name: (a.name || ""), description: a.description });
+    const version = (event.claude_code_version || "");
+    const model = (event.model || "");
+    const rawServers = (event.mcp_servers || []);
+    const mcpServers = rawServers.map((s) => ({
+        name: (s.name || ""),
+        status: (s.status || ""),
+    }));
+    return { slashCommands, skills, agents, version, model, mcpServers };
+}

package/dist/src/server/cron-utils.js

@@ -43,6 +43,8 @@ function parseCron(expression) {
         dayOfMonth: parseField(parts[2], 1, 31),
         month: parseField(parts[3], 1, 12),
         dayOfWeek: parseField(parts[4], 0, 6),
+        domWild: parts[2] === "*",
+        dowWild: parts[4] === "*",
     };
 }
 function matchesCron(expression, date) {
@@ -52,11 +54,20 @@ function matchesCron(expression, date) {
     const dom = date.getDate();
     const month = date.getMonth() + 1;
     const dow = date.getDay();
-    return (fields.minute.includes(minute) &&
-        fields.hour.includes(hour) &&
-        fields.dayOfMonth.includes(dom) &&
-        fields.month.includes(month) &&
-        fields.dayOfWeek.includes(dow));
+    let dayMatch;
+    if (fields.domWild && fields.dowWild) {
+        dayMatch = true;
+    }
+    else if (fields.domWild) {
+        dayMatch = fields.dayOfWeek.includes(dow);
+    }
+    else if (fields.dowWild) {
+        dayMatch = fields.dayOfMonth.includes(dom);
+    }
+    else {
+        dayMatch = fields.dayOfMonth.includes(dom) || fields.dayOfWeek.includes(dow);
+    }
+    return fields.minute.includes(minute) && fields.hour.includes(hour) && dayMatch && fields.month.includes(month);
 }
 function simpleScheduleToCron(schedule) {
     const time = schedule.time || "00:00";

package/dist/src/server/debug-logger.js

@@ -12,8 +12,8 @@ exports.logDiag = logDiag;
 exports.isDebugEnabled = isDebugEnabled;
 exports.debugLog = debugLog;
 const promises_1 = require("node:fs/promises");
-const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../server/paths");
 const enabled = process.env.COCKPIT_DEBUG === "1";
 const MAX_SIZE_BYTES = 50 * 1024 * 1024; // 50 MB
 const CHECK_INTERVAL = 500; // check size every N writes
@@ -25,7 +25,7 @@ let rotating = false;
 function init() {
     if (ready)
         return ready;
-    const dir = node_path_1.default.join((0, node_os_1.homedir)(), ".cockpit");
+    const dir = (0, paths_1.getCockpitDir)();
     logPath = node_path_1.default.join(dir, "debug.jsonl");
     prevPath = node_path_1.default.join(dir, "debug.prev.jsonl");
     ready = (0, promises_1.mkdir)(dir, { recursive: true }).then(() => { });

package/dist/src/server/defaults.js

@@ -3,10 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDefaults = getDefaults;
 exports.setDefaults = setDefaults;
 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 DEFAULTS_FILE = (0, node_path_1.join)(PREFS_DIR, "defaults.json");
+const paths_1 = require("../server/paths");
+function prefsDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function defaultsFile() {
+    return (0, node_path_1.join)(prefsDir(), "defaults.json");
+}
 const fallback = {
     thinkingLevel: "high",
     bypassAllPermissions: false,
@@ -16,13 +20,18 @@ const fallback = {
     readExpanded: false,
     editExpanded: false,
     toolCallsExpanded: false,
-    model: "sonnet",
+    modelSlots: { main: "sonnet" },
     messageStitching: true,
     reviewsEnabled: true,
 };
 function getDefaults() {
     try {
-        return { ...fallback, ...JSON.parse((0, node_fs_1.readFileSync)(DEFAULTS_FILE, "utf-8")) };
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(defaultsFile(), "utf-8"));
+        if (raw.model && !raw.modelSlots) {
+            raw.modelSlots = { main: raw.model };
+            delete raw.model;
+        }
+        return { ...fallback, ...raw };
     }
     catch {
         return { ...fallback };
@@ -32,8 +41,8 @@ function setDefaults(partial) {
     const current = getDefaults();
     const updated = { ...current, ...partial };
     try {
-        (0, node_fs_1.mkdirSync)(PREFS_DIR, { recursive: true });
-        (0, node_fs_1.writeFileSync)(DEFAULTS_FILE, JSON.stringify(updated, null, 2) + "\n");
+        (0, node_fs_1.mkdirSync)(prefsDir(), { recursive: true });
+        (0, node_fs_1.writeFileSync)(defaultsFile(), JSON.stringify(updated, null, 2) + "\n");
     }
     catch {
         // best effort

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchCwd = watchCwd;
+const node_fs_1 = require("node:fs");
+const watches = new Map();
+const DEBOUNCE_MS = 500;
+const IGNORE_RE = /(?:^|[\\/])(?:\.git[\\/](?!HEAD$|refs[\\/])|\.next[\\/]|node_modules[\\/])/;
+function startWatch(cwd) {
+    let timer = null;
+    const entry = {
+        watcher: (0, node_fs_1.watch)(cwd, { recursive: true }, (_event, filename) => {
+            if (filename && IGNORE_RE.test(filename))
+                return;
+            if (timer)
+                return;
+            timer = setTimeout(() => {
+                timer = null;
+                for (const fn of entry.listeners)
+                    fn();
+            }, DEBOUNCE_MS);
+        }),
+        listeners: new Set(),
+    };
+    entry.watcher.on("error", (err) => {
+        console.log(`[fs-watcher] error on ${cwd}: ${err.message}`);
+        cleanupWatch(cwd);
+    });
+    return entry;
+}
+function cleanupWatch(cwd) {
+    const entry = watches.get(cwd);
+    if (!entry)
+        return;
+    entry.watcher.close();
+    watches.delete(cwd);
+}
+function watchCwd(cwd, listener) {
+    let entry = watches.get(cwd);
+    if (!entry) {
+        entry = startWatch(cwd);
+        watches.set(cwd, entry);
+    }
+    entry.listeners.add(listener);
+    return () => {
+        entry.listeners.delete(listener);
+        if (entry.listeners.size === 0) {
+            cleanupWatch(cwd);
+        }
+    };
+}

package/dist/src/server/hook-bridge-path.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHookBridgePath = resolveHookBridgePath;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+let cached = null;
+/**
+ * Resolve the absolute path to `bin/cockpit-hook-bridge.mjs`.
+ *
+ * cockpit always runs from its package root: in dev `tsx` runs from the repo
+ * root; in prod `bin/cockpit.js` chdirs to the package root before importing
+ * `dist/server.js`. So `bin/cockpit-hook-bridge.mjs` lives at
+ * `process.cwd()/bin/cockpit-hook-bridge.mjs` in both cases.
+ *
+ * Allow override via COCKPIT_HOOK_BRIDGE_BIN for tests and packaging quirks.
+ */
+function resolveHookBridgePath() {
+    if (cached)
+        return cached;
+    const override = process.env.COCKPIT_HOOK_BRIDGE_BIN;
+    if (override && (0, node_fs_1.existsSync)(override)) {
+        cached = override;
+        return override;
+    }
+    const candidate = node_path_1.default.resolve(process.cwd(), "bin", "cockpit-hook-bridge.mjs");
+    if ((0, node_fs_1.existsSync)(candidate)) {
+        cached = candidate;
+        return candidate;
+    }
+    throw new Error(`cockpit-hook-bridge.mjs not found at ${candidate}`);
+}

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