@alexjbarnes/cockpit 0.2.0 → 0.3.0

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));

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

@@ -11,21 +11,36 @@ exports.pruneAllRuns = pruneAllRuns;
 exports.getLatestRun = getLatestRun;
 exports.getRecentFailureCount = getRecentFailureCount;
 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 JOBS_FILE = (0, node_path_1.join)(PREFS_DIR, "scheduled-jobs.json");
-const RUNS_DIR = (0, node_path_1.join)(PREFS_DIR, "job-runs");
+const models_1 = require("../lib/models");
+const paths_1 = require("../server/paths");
+function prefsDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function jobsFile() {
+    return (0, node_path_1.join)(prefsDir(), "scheduled-jobs.json");
+}
+function runsDir() {
+    return (0, node_path_1.join)(prefsDir(), "job-runs");
+}
 function ensureDir(dir) {
     (0, node_fs_1.mkdirSync)(dir, { recursive: true });
 }
 function runsFile(jobId) {
-    return (0, node_path_1.join)(RUNS_DIR, `${jobId}.json`);
+    return (0, node_path_1.join)(runsDir(), `${jobId}.json`);
+}
+function normalizeJob(raw) {
+    if (raw.model?.includes("[")) {
+        const split = (0, models_1.splitLegacyModel)(raw.model);
+        return { ...raw, model: split.model, contextSize: raw.contextSize ?? split.contextSize };
+    }
+    return raw;
 }
 function loadJobs() {
     try {
-        const data = JSON.parse((0, node_fs_1.readFileSync)(JOBS_FILE, "utf-8"));
-        return data.jobs || [];
+        const data = JSON.parse((0, node_fs_1.readFileSync)(jobsFile(), "utf-8"));
+        const jobs = data.jobs || [];
+        return jobs.map(normalizeJob);
     }
     catch {
         return [];
@@ -43,16 +58,16 @@ function saveJob(job) {
     else {
         jobs.push(job);
     }
-    ensureDir(PREFS_DIR);
-    (0, node_fs_1.writeFileSync)(JOBS_FILE, JSON.stringify({ jobs }, null, 2) + "\n");
+    ensureDir(prefsDir());
+    (0, node_fs_1.writeFileSync)(jobsFile(), JSON.stringify({ jobs }, null, 2) + "\n");
 }
 function deleteJob(id) {
     const jobs = loadJobs();
     const filtered = jobs.filter((j) => j.id !== id);
     if (filtered.length === jobs.length)
         return false;
-    ensureDir(PREFS_DIR);
-    (0, node_fs_1.writeFileSync)(JOBS_FILE, JSON.stringify({ jobs: filtered }, null, 2) + "\n");
+    ensureDir(prefsDir());
+    (0, node_fs_1.writeFileSync)(jobsFile(), JSON.stringify({ jobs: filtered }, null, 2) + "\n");
     const rf = runsFile(id);
     try {
         if ((0, node_fs_1.existsSync)(rf)) {
@@ -87,7 +102,7 @@ function saveRun(run) {
     const job = getJob(run.jobId);
     const maxAgeDays = job?.retentionDays ?? 90;
     pruneRuns(runs, 500, maxAgeDays);
-    ensureDir(RUNS_DIR);
+    ensureDir(runsDir());
     (0, node_fs_1.writeFileSync)(runsFile(run.jobId), JSON.stringify({ runs }, null, 2) + "\n");
 }
 function pruneRuns(runs, maxCount, maxAgeDays) {
@@ -109,7 +124,7 @@ function pruneAllRuns() {
         const before = runs.length;
         pruneRuns(runs, 500, job.retentionDays ?? 90);
         if (runs.length < before) {
-            ensureDir(RUNS_DIR);
+            ensureDir(runsDir());
             (0, node_fs_1.writeFileSync)(runsFile(job.id), JSON.stringify({ runs }, null, 2) + "\n");
         }
     }

package/dist/src/server/notification-settings.js

@@ -4,16 +4,20 @@ exports.getNotificationSettings = getNotificationSettings;
 exports.setNotificationSettings = setNotificationSettings;
 exports.updateNotificationSettings = updateNotificationSettings;
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
-const CONFIG_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".cockpit");
-const CONFIG_FILE = (0, node_path_1.join)(CONFIG_DIR, "notifications.json");
+const paths_1 = require("../server/paths");
+function configDir() {
+    return (0, paths_1.getCockpitDir)();
+}
+function configFile() {
+    return (0, node_path_1.join)(configDir(), "notifications.json");
+}
 const fallback = {
     providers: [],
 };
 function getNotificationSettings() {
     try {
-        return { ...fallback, ...JSON.parse((0, node_fs_1.readFileSync)(CONFIG_FILE, "utf-8")) };
+        return { ...fallback, ...JSON.parse((0, node_fs_1.readFileSync)(configFile(), "utf-8")) };
     }
     catch {
         return { ...fallback };
@@ -21,8 +25,8 @@ function getNotificationSettings() {
 }
 function setNotificationSettings(settings) {
     try {
-        (0, node_fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
-        (0, node_fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(settings, null, 2) + "\n");
+        (0, node_fs_1.mkdirSync)(configDir(), { recursive: true });
+        (0, node_fs_1.writeFileSync)(configFile(), JSON.stringify(settings, null, 2) + "\n");
     }
     catch {
         // best effort
@@ -32,8 +36,8 @@ function setNotificationSettings(settings) {
 function updateNotificationSettings(partial) {
     const current = getNotificationSettings();
     const updated = { ...current, ...partial };
-    if (!(0, node_fs_1.existsSync)(CONFIG_DIR))
-        (0, node_fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
-    (0, node_fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(updated, null, 2) + "\n");
+    if (!(0, node_fs_1.existsSync)(configDir()))
+        (0, node_fs_1.mkdirSync)(configDir(), { recursive: true });
+    (0, node_fs_1.writeFileSync)(configFile(), JSON.stringify(updated, null, 2) + "\n");
     return updated;
 }

package/dist/src/server/paths.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCockpitDir = getCockpitDir;
+exports.getCockpitCacheDir = getCockpitCacheDir;
+exports.getClaudeDir = getClaudeDir;
+exports.getClaudeUserConfigFile = getClaudeUserConfigFile;
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+function getCockpitDir() {
+    return process.env.COCKPIT_CONFIG_DIR ?? node_path_1.default.join((0, node_os_1.homedir)(), ".cockpit");
+}
+function getCockpitCacheDir() {
+    return process.env.COCKPIT_CACHE_DIR ?? node_path_1.default.join((0, node_os_1.homedir)(), ".cache", "cockpit");
+}
+function getClaudeDir() {
+    return process.env.CLAUDE_CONFIG_DIR ?? node_path_1.default.join((0, node_os_1.homedir)(), ".claude");
+}
+function getClaudeUserConfigFile() {
+    return node_path_1.default.join(process.env.CLAUDE_CONFIG_DIR ?? (0, node_os_1.homedir)(), ".claude.json");
+}

package/dist/src/server/plans.js

@@ -3,24 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findLatestPlanFile = findLatestPlanFile;
 exports.readPlanFile = readPlanFile;
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
-const PLANS_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "plans");
+const paths_1 = require("../server/paths");
+function plansDir() {
+    return (0, node_path_1.join)((0, paths_1.getClaudeDir)(), "plans");
+}
 function findLatestPlanFile() {
     try {
-        const files = (0, node_fs_1.readdirSync)(PLANS_DIR).filter((f) => f.endsWith(".md") && !f.includes("-agent-"));
+        const dir = plansDir();
+        const files = (0, node_fs_1.readdirSync)(dir).filter((f) => f.endsWith(".md") && !f.includes("-agent-"));
         if (files.length === 0)
             return undefined;
         let latest = files[0];
         let latestMtime = 0;
         for (const f of files) {
-            const mtime = (0, node_fs_1.statSync)((0, node_path_1.join)(PLANS_DIR, f)).mtimeMs;
+            const mtime = (0, node_fs_1.statSync)((0, node_path_1.join)(dir, f)).mtimeMs;
             if (mtime > latestMtime) {
                 latestMtime = mtime;
                 latest = f;
             }
         }
-        return (0, node_path_1.join)(PLANS_DIR, latest);
+        return (0, node_path_1.join)(dir, latest);
     }
     catch {
         return undefined;