@alexjbarnes/cockpit 0.1.1 → 0.3.0

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

@@ -5,19 +5,67 @@ 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 SCRATCHPAD_DIR = node_path_1.default.join((0, node_os_1.homedir)(), ".cockpit", "jobs");
-const JOB_PROMPT_PREFIX = [
+const transcript_1 = require("./transcript");
+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.",
-    "Complete the task fully, then stop. If you cannot complete the task, explain why in your final message.",
+    "Complete the task fully, then stop.",
+    "",
+    "Error reporting: If you cannot complete the task due to permission errors, tool failures, missing data, or any other reason,",
+    "your final message MUST include a cockpit-error block explaining the failure.",
+    "Format it as a fenced code block tagged cockpit-error containing a JSON object:",
     "",
-    "Task:",
+    "```cockpit-error",
+    '{"error":"Brief description of what went wrong","details":"Longer explanation of which tools failed and why"}',
+    "```",
 ].join("\n");
+function buildJobPrompt(job) {
+    const parts = [JOB_PROMPT_HEADER, ""];
+    if (job.bypassPermissions) {
+        parts.push("Permissions: All tools and MCP servers are available.");
+    }
+    else {
+        const tools = job.allowedTools || [];
+        const servers = job.mcpServers || [];
+        parts.push("Permissions: Only the tools and MCP servers listed below are allowed. Do not attempt to use any others.");
+        if (tools.length > 0)
+            parts.push(`Allowed tools: ${tools.join(", ")}`);
+        if (servers.length > 0)
+            parts.push(`Allowed MCP servers: ${servers.join(", ")}`);
+        if (tools.length === 0 && servers.length === 0)
+            parts.push("No tools or MCP servers are allowed.");
+    }
+    if (job.cwd) {
+        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.");
+    }
+    if (job.inboxOutput) {
+        parts.push("");
+        parts.push("Output: When you have results to report, include a cockpit-inbox block in your final message.");
+        parts.push("If there is nothing to report (e.g. no new data to process), do NOT include an inbox block.");
+        parts.push("Format it as a fenced code block tagged cockpit-inbox containing a JSON object:");
+        parts.push("");
+        parts.push("```cockpit-inbox");
+        parts.push(JSON.stringify({ title: "Short descriptive title", body: "Markdown body with your full output", priority: "info" }));
+        parts.push("```");
+        parts.push("");
+        parts.push('The body field supports full markdown. Set priority to "info", "warning", or "error" as appropriate.');
+    }
+    parts.push("", "Task:", job.prompt);
+    return parts.join("\n");
+}
 const SHELL_OPERATORS = /(?:;|&&|\|\||>|<|`|\$\(|<\()/;
 const BACKGROUND_AMPERSAND = /(?:^|[^|])&(?!&)/;
 function hasShellOperators(cmd) {
@@ -53,33 +101,41 @@ function isToolAllowed(toolName, toolInput, rules) {
     }
     return false;
 }
+function normalizeMcpName(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, "_");
+}
 function isMcpToolAllowed(toolName, toolInput, enabledServers, mcpToolFilters) {
-    const match = toolName.match(/^mcp__([^_]+)__(.+)$/);
-    if (!match)
+    if (!toolName.startsWith("mcp__"))
         return null;
-    const [, server, tool] = match;
-    if (!enabledServers.has(server))
-        return false;
-    if (!mcpToolFilters || !(server in mcpToolFilters))
-        return true;
-    const filters = mcpToolFilters[server];
-    for (const filter of filters) {
-        if (filter === tool)
+    const remainder = toolName.slice(5);
+    for (const serverName of enabledServers) {
+        const normalized = normalizeMcpName(serverName);
+        const prefix = `${normalized}__`;
+        if (!remainder.startsWith(prefix))
+            continue;
+        const tool = remainder.slice(prefix.length);
+        if (!mcpToolFilters || !(serverName in mcpToolFilters))
             return true;
-        if (filter.includes(":")) {
-            let parsed;
-            try {
-                parsed = JSON.parse(toolInput);
-            }
-            catch {
-                continue;
-            }
-            const [filterServer, filterTool] = filter.split(":", 2);
-            if (parsed.server === filterServer) {
-                if (filterTool === "*" || parsed.tool === filterTool)
-                    return true;
+        const filters = mcpToolFilters[serverName];
+        for (const filter of filters) {
+            if (filter === tool)
+                return true;
+            if (filter.includes(":")) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(toolInput);
+                }
+                catch {
+                    continue;
+                }
+                const [filterServer, filterTool] = filter.split(":", 2);
+                if (parsed.server === filterServer) {
+                    if (filterTool === "*" || parsed.tool === filterTool)
+                        return true;
+                }
             }
         }
+        return false;
     }
     return false;
 }
@@ -102,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() {
@@ -118,18 +177,23 @@ 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)();
         for (const job of jobs) {
             const latest = (0, job_storage_1.getLatestRun)(job.id);
             if (latest) {
                 this.lastFiredAt.set(job.id, new Date(latest.startedAt));
-                if (latest.status === "running") {
-                    latest.status = "failure";
-                    latest.error = "Server restarted while job was running";
-                    latest.completedAt = Date.now();
-                    latest.durationMs = latest.completedAt - latest.startedAt;
-                    (0, job_storage_1.saveRun)(latest);
+            }
+            for (const run of (0, job_storage_1.loadRuns)(job.id)) {
+                if (run.status === "running") {
+                    run.status = "failure";
+                    run.error = "Server restarted while job was running";
+                    run.completedAt = now;
+                    run.durationMs = now - run.startedAt;
+                    (0, job_storage_1.saveRun)(run);
+                    (0, job_lock_1.forceReleaseJobLock)(job.id);
                 }
             }
         }
@@ -142,6 +206,20 @@ class JobScheduler {
             this.lastPruneAt = nowMs;
             (0, job_storage_1.pruneAllRuns)();
         }
+        for (const [jobId, run] of this.runningJobs) {
+            if (!this.sessionManager.hasRunningProcess(run.sessionId)) {
+                console.log(`[scheduler] run ${run.id} for job ${jobId} has no running process, marking as failure`);
+                run.status = "failure";
+                run.error = "Session process exited unexpectedly";
+                run.completedAt = Date.now();
+                run.durationMs = run.completedAt - run.startedAt;
+                if (run.cwd)
+                    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)();
         for (const job of jobs) {
             if (!job.enabled)
@@ -175,11 +253,16 @@ class JobScheduler {
     }
     async executeJob(job) {
         const runId = (0, uuid_1.v4)();
-        const jobCwd = job.cwd || SCRATCHPAD_DIR;
-        if (!job.cwd) {
-            (0, node_fs_1.mkdirSync)(SCRATCHPAD_DIR, { 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 sessionInfo = this.sessionManager.createSession(jobCwd, `[job] ${job.name}`);
+        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 = {
             id: runId,
@@ -195,6 +278,8 @@ class JobScheduler {
         (0, job_storage_1.saveRun)(run);
         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, {
@@ -215,14 +300,29 @@ class JobScheduler {
             }
             else if (event.type === "message_done") {
                 run.messageCount++;
+                if (event.message) {
+                    let text = event.message.content;
+                    if (!text && event.message.blocks) {
+                        text = event.message.blocks
+                            .filter((b) => b.type === "text")
+                            .map((b) => b.text)
+                            .join("\n");
+                    }
+                    if (text)
+                        lastAssistantText = text;
+                }
             }
             else if (event.type === "permission_request" && event.requestId) {
-                if (!job.bypassPermissions) {
+                if (job.bypassPermissions) {
+                    this.sessionManager.respondToPermission(sessionId, event.requestId, true, event.rawToolInput);
+                }
+                else {
                     const toolName = event.toolName || "unknown";
                     const inputStr = event.toolInput || "";
                     const mcpResult = isMcpToolAllowed(toolName, inputStr, enabledServers, job.mcpToolFilters);
                     const allowed = mcpResult !== null ? mcpResult : isToolAllowed(toolName, inputStr, job.allowedTools || []);
-                    this.sessionManager.respondToPermission(sessionId, event.requestId, allowed);
+                    console.log(`[scheduler] permission: ${toolName} mcpResult=${mcpResult} allowed=${allowed} servers=[${[...enabledServers]}]`);
+                    this.sessionManager.respondToPermission(sessionId, event.requestId, allowed, allowed ? (event.rawToolInput ?? {}) : undefined);
                     const permEntry = {
                         name: toolName,
                         input: inputStr,
@@ -234,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)) {
@@ -243,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);
@@ -272,18 +371,46 @@ class JobScheduler {
                 unsubStatus?.();
                 unsubError?.();
                 initCleanup?.();
-                run.status = finalStatus;
                 run.completedAt = Date.now();
                 run.durationMs = run.completedAt - run.startedAt;
                 if (finalStatus === "timeout") {
                     run.error = `Exceeded max duration of ${job.maxDurationMinutes || 30} minutes`;
                     this.sessionManager.destroySession(sessionId);
                 }
+                if (finalStatus === "success" && lastAssistantText) {
+                    const errorBlock = (0, inbox_1.parseErrorBlock)(lastAssistantText);
+                    if (errorBlock) {
+                        finalStatus = "failure";
+                        run.error = errorBlock.details ? `${errorBlock.error}: ${errorBlock.details}` : errorBlock.error;
+                    }
+                }
+                run.status = finalStatus;
+                const transcriptCount = (0, transcript_1.countTranscriptMessages)(sessionId, jobCwd);
+                if (transcriptCount > run.messageCount)
+                    run.messageCount = transcriptCount;
                 (0, job_storage_1.saveRun)(run);
+                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 });
+                    }
+                }
+                if (finalStatus === "failure" || finalStatus === "timeout") {
+                    (0, inbox_1.addInboxMessage)({
+                        title: `Job failed: ${job.name}`,
+                        body: `**Status:** ${finalStatus}\n\n${run.error || "Job failed with no error message"}`,
+                        priority: "error",
+                        jobId: job.id,
+                        jobName: job.name,
+                        runId: run.id,
+                        notifyProviders: job.notifyProviders,
+                    });
+                }
                 this.runningJobs.delete(job.id);
+                (0, job_lock_1.releaseJobLock)(job.id);
                 resolve(run);
             };
-            this.sessionManager.sendMessage(sessionId, `${JOB_PROMPT_PREFIX}\n${job.prompt}`);
+            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");
         }
     }
@@ -120,16 +135,13 @@ function getLatestRun(jobId) {
         return undefined;
     return runs.reduce((latest, r) => (r.startedAt > latest.startedAt ? r : latest));
 }
-function getRecentFailureCount(withinMs = 24 * 60 * 60 * 1000) {
+function getRecentFailureCount() {
     const jobs = loadJobs();
-    const cutoff = Date.now() - withinMs;
     let count = 0;
     for (const job of jobs) {
-        const runs = loadRuns(job.id);
-        for (const run of runs) {
-            if (run.startedAt >= cutoff && (run.status === "failure" || run.status === "timeout")) {
-                count++;
-            }
+        const latest = getLatestRun(job.id);
+        if (latest && (latest.status === "failure" || latest.status === "timeout")) {
+            count++;
         }
     }
     return count;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNotificationSettings = getNotificationSettings;
+exports.setNotificationSettings = setNotificationSettings;
+exports.updateNotificationSettings = updateNotificationSettings;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+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)(configFile(), "utf-8")) };
+    }
+    catch {
+        return { ...fallback };
+    }
+}
+function setNotificationSettings(settings) {
+    try {
+        (0, node_fs_1.mkdirSync)(configDir(), { recursive: true });
+        (0, node_fs_1.writeFileSync)(configFile(), JSON.stringify(settings, null, 2) + "\n");
+    }
+    catch {
+        // best effort
+    }
+    return settings;
+}
+function updateNotificationSettings(partial) {
+    const current = getNotificationSettings();
+    const updated = { ...current, ...partial };
+    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/notifications.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchNotification = dispatchNotification;
+exports.sendTestNotification = sendTestNotification;
+const notification_settings_1 = require("./notification-settings");
+function buildFullUrl(path, baseUrl) {
+    if (!path)
+        return undefined;
+    if (baseUrl)
+        return `${baseUrl.replace(/\/$/, "")}${path}`;
+    return path;
+}
+function formatPlainMessage(payload, baseUrl) {
+    const priorityTag = payload.priority === "error" ? "[ERROR]" : payload.priority === "warning" ? "[WARN]" : "";
+    const prefix = priorityTag ? `${priorityTag} ` : "";
+    const url = buildFullUrl(payload.url, baseUrl);
+    const link = url ? `\n\n${url}` : "";
+    return `${prefix}${payload.title}\n\n${payload.body}${link}`;
+}
+const telegramProvider = {
+    async send(payload, config, baseUrl) {
+        const text = formatPlainMessage(payload, baseUrl);
+        const url = `https://api.telegram.org/bot${config.botToken}/sendMessage`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                chat_id: config.chatId,
+                text,
+                disable_web_page_preview: true,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`Telegram API ${res.status}: ${body}`);
+        }
+    },
+};
+const ntfyProvider = {
+    async send(payload, config, baseUrl) {
+        const serverUrl = (config.serverUrl || "https://ntfy.sh").replace(/\/$/, "");
+        const url = `${serverUrl}/${config.topic}`;
+        const fullUrl = buildFullUrl(payload.url, baseUrl);
+        const headers = {
+            Title: payload.title,
+            Priority: payload.priority === "error" ? "urgent" : payload.priority === "warning" ? "high" : "default",
+        };
+        if (config.token) {
+            headers.Authorization = `Bearer ${config.token}`;
+        }
+        if (fullUrl) {
+            headers.Click = fullUrl;
+        }
+        const res = await fetch(url, {
+            method: "POST",
+            headers,
+            body: payload.body,
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`ntfy ${res.status}: ${body}`);
+        }
+    },
+};
+function getProvider(type) {
+    switch (type) {
+        case "telegram":
+            return telegramProvider;
+        case "ntfy":
+            return ntfyProvider;
+        default:
+            return null;
+    }
+}
+function matchesFilter(entry, payload) {
+    if (!entry.filter)
+        return true;
+    if (entry.filter.priorities?.length && !entry.filter.priorities.includes(payload.priority)) {
+        return false;
+    }
+    if (entry.filter.sources?.length && !entry.filter.sources.includes(payload.source)) {
+        return false;
+    }
+    return true;
+}
+function dispatchNotification(payload) {
+    const settings = (0, notification_settings_1.getNotificationSettings)();
+    for (const entry of settings.providers) {
+        if (!entry.enabled)
+            continue;
+        if (payload.providerIds) {
+            if (!payload.providerIds.includes(entry.id))
+                continue;
+        }
+        else {
+            if (!matchesFilter(entry, payload))
+                continue;
+        }
+        const provider = getProvider(entry.type);
+        if (!provider)
+            continue;
+        provider.send(payload, entry.config, settings.baseUrl).catch((err) => {
+            console.error(`[notifications] ${entry.type}/${entry.name} failed:`, err);
+        });
+    }
+}
+async function sendTestNotification(entry, baseUrl) {
+    const provider = getProvider(entry.type);
+    if (!provider)
+        return `Unknown provider type: ${entry.type}`;
+    const payload = {
+        title: "Cockpit Test Notification",
+        body: "This is a test notification from Cockpit.",
+        priority: "info",
+        source: "test",
+        url: "/inbox",
+    };
+    try {
+        await provider.send(payload, entry.config, baseUrl);
+        return "ok";
+    }
+    catch (err) {
+        return `Failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}

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;