@alexjbarnes/cockpit 0.1.1 → 0.3.0

package/dist/src/server/auth.js

@@ -18,13 +18,17 @@ exports.clearSessionCookie = clearSessionCookie;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = require("node:fs");
 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");
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
-const COCKPIT_DIR = node_path_1.default.join((0, node_os_1.homedir)(), ".cockpit");
-const PASSWORD_FILE = node_path_1.default.join(COCKPIT_DIR, "password.json");
+function cockpitDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function passwordFile() {
+    return node_path_1.default.join(cockpitDir(), "password.json");
+}
 const SCRYPT_KEYLEN = 64;
 const SALT_BYTES = 32;
 // ---------------------------------------------------------------------------
@@ -41,16 +45,22 @@ function scryptHash(password, salt) {
     });
 }
 function readPasswordFile() {
-    if (!(0, node_fs_1.existsSync)(PASSWORD_FILE))
+    if (!(0, node_fs_1.existsSync)(passwordFile()))
         return null;
     try {
-        const raw = require("node:fs").readFileSync(PASSWORD_FILE, "utf-8");
+        const raw = require("node:fs").readFileSync(passwordFile(), "utf-8");
+        if (!raw.trim()) {
+            console.warn("[auth] password.json exists but is empty (likely corrupted by interrupted write)");
+            return null;
+        }
         const data = JSON.parse(raw);
         if (data.hash && data.salt)
             return data;
+        console.warn("[auth] password.json missing hash/salt fields");
         return null;
     }
-    catch {
+    catch (err) {
+        console.error("[auth] failed to read password.json:", err);
         return null;
     }
 }
@@ -62,17 +72,25 @@ function getStoredPassword() {
     return cachedPassword;
 }
 function needsSetup() {
+    if (process.env.COCKPIT_TOKEN)
+        return false;
     return getStoredPassword() === null;
 }
 async function setupPassword(password) {
-    await (0, promises_1.mkdir)(COCKPIT_DIR, { recursive: true });
+    await (0, promises_1.mkdir)(cockpitDir(), { recursive: true });
     const salt = node_crypto_1.default.randomBytes(SALT_BYTES);
     const hash = await scryptHash(password, salt);
     const data = {
         hash: hash.toString("hex"),
         salt: salt.toString("hex"),
     };
-    await (0, promises_1.writeFile)(PASSWORD_FILE, JSON.stringify(data), "utf-8");
+    const pwFile = passwordFile();
+    const tmpFile = `${pwFile}.tmp.${process.pid}.${Date.now()}`;
+    const fh = await (0, promises_1.open)(tmpFile, "w");
+    await fh.writeFile(JSON.stringify(data), "utf-8");
+    await fh.sync();
+    await fh.close();
+    await (0, promises_1.rename)(tmpFile, pwFile);
     cachedPassword = data;
 }
 async function verifyPassword(password) {
@@ -87,8 +105,9 @@ async function verifyPassword(password) {
     return node_crypto_1.default.timingSafeEqual(hash, storedHash);
 }
 async function deletePasswordFile() {
-    if ((0, node_fs_1.existsSync)(PASSWORD_FILE)) {
-        await (0, promises_1.unlink)(PASSWORD_FILE);
+    const pwFile = passwordFile();
+    if ((0, node_fs_1.existsSync)(pwFile)) {
+        await (0, promises_1.unlink)(pwFile);
     }
     cachedPassword = undefined;
 }
@@ -115,6 +134,9 @@ function validateSession(token) {
     const key = getSigningKey();
     if (!key)
         return false;
+    // Allow bypass via COCKPIT_TOKEN for e2e tests
+    if (process.env.COCKPIT_TOKEN && token === process.env.COCKPIT_TOKEN)
+        return true;
     const dot = token.indexOf(".");
     if (dot === -1)
         return false;

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,11 +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 };
@@ -30,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}`);
+}