@alexjbarnes/cockpit 0.3.1 → 0.4.1

package/dist/src/lib/paste-detect.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTextFiles = extractTextFiles;
+exports.shouldCollapsePaste = shouldCollapsePaste;
+exports.extensionForLabel = extensionForLabel;
+exports.detectLanguage = detectLanguage;
+const FILE_TAG_RE = /<file\s+path="([^"]+)">\n([\s\S]*?)\n<\/file>/g;
+function extractTextFiles(text) {
+    const textFiles = [];
+    const cleaned = text
+        .replace(FILE_TAG_RE, (_match, name, content) => {
+        textFiles.push({ name, content });
+        return "";
+    })
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    return { cleaned, textFiles };
+}
+const MIN_LINES = 10;
+// Map Magika content type labels to file extensions for naming and syntax highlighting.
+const LABEL_TO_EXT = {
+    asm: "asm",
+    awk: "awk",
+    batch: "bat",
+    c: "c",
+    clojure: "clj",
+    cmake: "cmake",
+    cobol: "cob",
+    coffeescript: "coffee",
+    cpp: "cpp",
+    cs: "cs",
+    css: "css",
+    csv: "csv",
+    dart: "dart",
+    diff: "diff",
+    dockerfile: "dockerfile",
+    elixir: "ex",
+    erlang: "erl",
+    fortran: "f90",
+    gleam: "gleam",
+    go: "go",
+    gradle: "gradle",
+    groovy: "groovy",
+    h: "h",
+    handlebars: "hbs",
+    haskell: "hs",
+    hcl: "tf",
+    hpp: "hpp",
+    html: "html",
+    ini: "ini",
+    java: "java",
+    javascript: "js",
+    json: "json",
+    jsonc: "jsonc",
+    jsonl: "jsonl",
+    jsx: "jsx",
+    julia: "jl",
+    kotlin: "kt",
+    latex: "tex",
+    less: "less",
+    lisp: "lisp",
+    lua: "lua",
+    makefile: "makefile",
+    markdown: "md",
+    matlab: "m",
+    nim: "nim",
+    objectivec: "m",
+    ocaml: "ml",
+    odin: "odin",
+    pascal: "pas",
+    perl: "pl",
+    php: "php",
+    powershell: "ps1",
+    prolog: "pl",
+    proto: "proto",
+    python: "py",
+    r: "r",
+    rst: "rst",
+    ruby: "rb",
+    rust: "rs",
+    scala: "scala",
+    scheme: "scm",
+    scss: "scss",
+    shell: "sh",
+    solidity: "sol",
+    sql: "sql",
+    svelte: "svelte",
+    svg: "svg",
+    swift: "swift",
+    tcl: "tcl",
+    toml: "toml",
+    tsx: "tsx",
+    typescript: "ts",
+    vba: "vba",
+    verilog: "v",
+    vhdl: "vhdl",
+    vue: "vue",
+    xml: "xml",
+    yaml: "yaml",
+    yara: "yar",
+    zig: "zig",
+};
+function shouldCollapsePaste(content) {
+    return content.split(/\r?\n/).length >= MIN_LINES;
+}
+function extensionForLabel(label) {
+    return LABEL_TO_EXT[label];
+}
+// Lazy-loaded client-side Magika instance
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let magikaPromise = null;
+async function detectLanguage(text) {
+    try {
+        if (!magikaPromise) {
+            magikaPromise = Promise.resolve().then(() => __importStar(require("magika"))).then((m) => m.Magika.create());
+        }
+        const magika = await magikaPromise;
+        const bytes = new TextEncoder().encode(text.slice(0, 8192));
+        const result = await magika.identifyBytes(bytes);
+        const label = result.prediction.output.label;
+        if (label === "txt" || label === "unknown" || label === "empty")
+            return null;
+        return LABEL_TO_EXT[label] ? label : null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssistantSettings = getAssistantSettings;
+exports.updateAssistantSettings = updateAssistantSettings;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const paths_1 = require("../server/paths");
+const fallback = {
+    model: "sonnet",
+    thinkingLevel: "high",
+};
+function settingsFile() {
+    return (0, node_path_1.join)((0, paths_1.getCockpitDir)(), "assistant.json");
+}
+function getAssistantSettings() {
+    try {
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(settingsFile(), "utf-8"));
+        return { ...fallback, ...raw };
+    }
+    catch {
+        return { ...fallback };
+    }
+}
+function updateAssistantSettings(partial) {
+    const current = getAssistantSettings();
+    const updated = { ...current, ...partial };
+    try {
+        (0, node_fs_1.mkdirSync)((0, paths_1.getCockpitDir)(), { recursive: true });
+        (0, node_fs_1.writeFileSync)(settingsFile(), JSON.stringify(updated, null, 2) + "\n");
+    }
+    catch {
+        // best effort
+    }
+    return updated;
+}

package/dist/src/server/claude-bin.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClaudeBin = getClaudeBin;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+let resolvedClaudeBin = null;
+/**
+ * Resolve the `claude` executable path and cache it for the process.
+ *
+ * The cache is invalidated when the resolved absolute path no longer exists, so
+ * a `claude` self-update that deletes the old versioned binary out from under a
+ * long-running server is picked up on the next spawn instead of wedging every
+ * session with `execvp: No such file or directory` until a manual restart.
+ * `existsSync` follows symlinks, so a stable launcher symlink the updater
+ * repoints stays valid; only a cached path to a now-deleted binary re-resolves.
+ * The bare-name PATH fallback is left cached as-is — it has no fixed path to
+ * validate and exec-time PATH resolution handles it.
+ */
+function getClaudeBin() {
+    if (resolvedClaudeBin && (!(0, node_path_1.isAbsolute)(resolvedClaudeBin) || (0, node_fs_1.existsSync)(resolvedClaudeBin))) {
+        return resolvedClaudeBin;
+    }
+    const cmd = process.platform === "win32" ? "where" : "which";
+    try {
+        resolvedClaudeBin = (0, node_child_process_1.execFileSync)(cmd, ["claude"], { encoding: "utf-8" }).trim().split("\n")[0];
+    }
+    catch {
+        resolvedClaudeBin = "claude";
+    }
+    return resolvedClaudeBin;
+}

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

@@ -61,6 +61,9 @@ async function prepareHookSettings(opts) {
         // interactive "WARNING: Bypass Permissions mode" dialog has nowhere to go
         // when there's no human at the TUI, so suppress it here.
         skipDangerousModePermissionPrompt: true,
+        // Per-session thinking on/off. cockpit's selector is authoritative, so this
+        // overrides any user-global alwaysThinkingEnabled when explicitly provided.
+        ...(opts.thinkingEnabled !== undefined ? { alwaysThinkingEnabled: opts.thinkingEnabled } : {}),
     };
     const dir = await resolveSettingsDir();
     const settingsPath = node_path_1.default.join(dir, `${opts.sessionId}.json`);

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

@@ -7,10 +7,15 @@ 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.
+ *
+ * `--no-session-persistence` stops this throwaway probe from writing a session
+ * transcript to ~/.claude/projects. Without it the CLI persists the "hi" prompt
+ * at startup (before we can kill it), and that transcript then surfaces in the
+ * session history as a stray "hi" session, once per init fetch, per cwd. Keep it.
  */
 function fetchCliInitData(opts) {
     const bin = opts.bin ?? "claude";
-    const args = ["-p", "--verbose", "--output-format", "stream-json", "hi"];
+    const args = ["-p", "--no-session-persistence", "--verbose", "--output-format", "stream-json", "hi"];
     return new Promise((resolve) => {
         let resolved = false;
         const done = (result) => {

package/dist/src/server/inbox.js

@@ -86,10 +86,10 @@ function markRead(id, read = true) {
     writeAll(messages);
     return true;
 }
-function markAllRead() {
+function markAllRead(read = true) {
     const messages = readAll();
     for (const m of messages)
-        m.read = true;
+        m.read = read;
     writeAll(messages);
 }
 function deleteInboxMessage(id) {

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

@@ -9,6 +9,7 @@ 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 debug_logger_1 = require("./debug-logger");
 const inbox_1 = require("./inbox");
 const job_lock_1 = require("./job-lock");
 const job_storage_1 = require("./job-storage");
@@ -144,6 +145,7 @@ class JobScheduler {
     timer = null;
     lastFiredAt = new Map();
     runningJobs = new Map();
+    jobResolvers = new Map();
     lastPruneAt = 0;
     constructor(sessionManager) {
         this.sessionManager = sessionManager;
@@ -176,6 +178,48 @@ class JobScheduler {
             throw new Error(`Job not found: ${jobId}`);
         return this.executeJob(job);
     }
+    stopJob(jobId) {
+        const run = this.runningJobs.get(jobId);
+        if (!run)
+            throw new Error("Job is not currently running");
+        // Guard against the cleanup timeout having already fired.
+        // cleanup ALWAYS sets completedAt (line 469), so this is a race-free signal.
+        if (run.completedAt)
+            throw new Error("Job is no longer running");
+        // Set status BEFORE destroySession -- same object reference as closure's run
+        run.status = "stopped";
+        run.error = "Stopped by user";
+        run.completedAt = Date.now();
+        run.durationMs = run.completedAt - run.startedAt;
+        // Count transcript BEFORE destroySession -- destroySession stops the watcher
+        const transcriptCount = (0, transcript_1.countTranscriptMessages)(run.sessionId, run.cwd);
+        this.sessionManager.destroySession(run.sessionId);
+        if (transcriptCount > run.messageCount)
+            run.messageCount = transcriptCount;
+        (0, job_storage_1.saveRun)(run);
+        (0, inbox_1.addInboxMessage)({
+            title: `Job stopped: ${run.jobId}`,
+            body: `**Status:** stopped\n\nStopped by user after ${Math.round((run.durationMs ?? 0) / 1000)}s`,
+            priority: "info",
+            jobId: run.jobId,
+            runId: run.id,
+        });
+        this.runningJobs.delete(jobId);
+        (0, job_lock_1.releaseJobLock)(jobId);
+        // Resolve the executeJob Promise. If cleanup already resolved it
+        // (via the guard), this is a no-op (Promise can only settle once).
+        const resolve = this.jobResolvers.get(jobId);
+        if (resolve) {
+            resolve(run);
+            this.jobResolvers.delete(jobId);
+        }
+        (0, debug_logger_1.logDiag)(jobId, "job:stopped", {
+            runId: run.id,
+            messageCount: run.messageCount,
+            toolCount: run.toolsUsed.length,
+        });
+        return run;
+    }
     recoverState() {
         (0, job_lock_1.clearStaleLocks)();
         (0, job_storage_1.pruneAllRuns)();
@@ -253,10 +297,25 @@ class JobScheduler {
     }
     async executeJob(job) {
         const runId = (0, uuid_1.v4)();
+        (0, debug_logger_1.logDiag)(job.id, "job:execute-start", {
+            runId,
+            name: job.name,
+            runtime: job.runtime ?? "stream",
+            model: job.model,
+            thinkingLevel: job.thinkingLevel,
+            contextSize: job.contextSize,
+            mcpServers: job.mcpServers ?? [],
+            allowedTools: job.allowedTools ?? [],
+            bypassPermissions: !!job.bypassPermissions,
+            inboxOutput: !!job.inboxOutput,
+            maxDurationMinutes: job.maxDurationMinutes ?? 30,
+        });
         if (!(0, job_lock_1.acquireJobLock)(job.id, runId)) {
+            (0, debug_logger_1.logDiag)(job.id, "job:lock-failed", { 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");
         }
+        (0, debug_logger_1.logDiag)(job.id, "job:lock-acquired", { runId });
         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}`, {
@@ -264,6 +323,8 @@ class JobScheduler {
             runtime: job.runtime,
         });
         const sessionId = sessionInfo.id;
+        const jlog = (label, data) => (0, debug_logger_1.logDiag)(sessionId, `job:${label}`, { jobId: job.id, runId, ...data });
+        jlog("session-created", { cwd: jobCwd, runtime: sessionInfo.runtime });
         const run = {
             id: runId,
             jobId: job.id,
@@ -288,6 +349,7 @@ class JobScheduler {
                     output: "",
                     timestamp: Date.now(),
                 });
+                jlog("tool-start", { toolId: event.toolId, toolName: event.toolName ?? "unknown" });
             }
             else if (event.type === "tool_result" && event.toolId) {
                 const entry = toolTracker.get(event.toolId);
@@ -296,10 +358,12 @@ class JobScheduler {
                     entry.durationMs = Date.now() - entry.timestamp;
                     run.toolsUsed.push(entry);
                     toolTracker.delete(event.toolId);
+                    jlog("tool-result", { toolId: event.toolId, name: entry.name, durationMs: entry.durationMs, outputLen: entry.output.length });
                 }
             }
             else if (event.type === "message_done") {
                 run.messageCount++;
+                let textLen = 0;
                 if (event.message) {
                     let text = event.message.content;
                     if (!text && event.message.blocks) {
@@ -308,12 +372,16 @@ class JobScheduler {
                             .map((b) => b.text)
                             .join("\n");
                     }
-                    if (text)
+                    if (text) {
                         lastAssistantText = text;
+                        textLen = text.length;
+                    }
                 }
+                jlog("message-done", { count: run.messageCount, textLen });
             }
             else if (event.type === "permission_request" && event.requestId) {
                 if (job.bypassPermissions) {
+                    jlog("permission", { toolName: event.toolName ?? "unknown", requestId: event.requestId, bypass: true, allowed: true });
                     this.sessionManager.respondToPermission(sessionId, event.requestId, true, event.rawToolInput);
                 }
                 else {
@@ -321,7 +389,13 @@ class JobScheduler {
                     const inputStr = event.toolInput || "";
                     const mcpResult = isMcpToolAllowed(toolName, inputStr, enabledServers, job.mcpToolFilters);
                     const allowed = mcpResult !== null ? mcpResult : isToolAllowed(toolName, inputStr, job.allowedTools || []);
-                    console.log(`[scheduler] permission: ${toolName} mcpResult=${mcpResult} allowed=${allowed} servers=[${[...enabledServers]}]`);
+                    jlog("permission", {
+                        toolName,
+                        requestId: event.requestId,
+                        mcpResult,
+                        allowed,
+                        enabledServers: [...enabledServers],
+                    });
                     this.sessionManager.respondToPermission(sessionId, event.requestId, allowed, allowed ? (event.rawToolInput ?? {}) : undefined);
                     const permEntry = {
                         name: toolName,
@@ -335,37 +409,88 @@ class JobScheduler {
             }
         });
         const initCleanup = this.sessionManager.onInit(sessionId, (initData) => {
+            const disabling = [];
             for (const server of initData.mcpServers) {
                 if (!enabledServers.has(server.name)) {
+                    disabling.push(server.name);
                     this.sessionManager.mcpToggle(sessionId, server.name, false).catch(() => { });
                 }
             }
+            jlog("init", { available: initData.mcpServers.map((s) => s.name), disabling, enabled: [...enabledServers] });
         });
         if (job.model) {
             this.sessionManager.setModel(sessionId, job.model, job.contextSize);
+            jlog("set-model", { model: job.model, contextSize: job.contextSize });
         }
         if (job.thinkingLevel) {
             this.sessionManager.setThinkingLevel(sessionId, job.thinkingLevel);
+            jlog("set-thinking", { thinkingLevel: job.thinkingLevel });
         }
         return new Promise((resolve) => {
+            this.jobResolvers.set(job.id, resolve);
             const maxMs = (job.maxDurationMinutes || 30) * 60 * 1000;
+            const sentAt = Date.now();
+            let sawRunning = false;
+            let statusEvents = 0;
             const timeout = setTimeout(() => {
+                jlog("watchdog-fired", {
+                    maxMs,
+                    elapsedMs: Date.now() - sentAt,
+                    sawRunning,
+                    messageCount: run.messageCount,
+                    toolCount: run.toolsUsed.length,
+                });
                 cleanup("timeout");
             }, maxMs);
             const unsubStatus = this.sessionManager.onStatus(sessionId, (status) => {
+                statusEvents++;
+                if (status === "running")
+                    sawRunning = true;
+                // An "idle" that arrives while the process is still alive is the orphan
+                // signature: the run gets marked done but the PTY keeps going untracked.
+                const processAlive = this.sessionManager.hasRunningProcess(sessionId);
+                jlog("status-event", {
+                    status,
+                    n: statusEvents,
+                    elapsedMs: Date.now() - sentAt,
+                    sawRunning,
+                    processAlive,
+                    messageCount: run.messageCount,
+                    toolCount: run.toolsUsed.length,
+                });
                 if (status === "idle") {
                     cleanup("success");
                 }
             });
             const unsubError = this.sessionManager.onError(sessionId, (error) => {
+                jlog("error-event", { error, elapsedMs: Date.now() - sentAt });
                 run.error = error;
                 cleanup("failure");
             });
             let cleaned = false;
             const cleanup = (finalStatus) => {
-                if (cleaned)
+                if (cleaned) {
+                    jlog("cleanup-skipped", { requestedStatus: finalStatus, elapsedMs: Date.now() - sentAt });
+                    return;
+                }
+                if (run.status === "stopped") {
+                    cleaned = true;
+                    jlog("cleanup-guard-stopped", { elapsedMs: Date.now() - sentAt });
+                    clearTimeout(timeout);
+                    resolve(run);
+                    this.jobResolvers.delete(job.id);
                     return;
+                }
                 cleaned = true;
+                jlog("cleanup-begin", {
+                    finalStatus,
+                    elapsedMs: Date.now() - sentAt,
+                    sawRunning,
+                    statusEvents,
+                    messageCount: run.messageCount,
+                    toolCount: run.toolsUsed.length,
+                    lastTextLen: lastAssistantText.length,
+                });
                 clearTimeout(timeout);
                 unsubEvent?.();
                 unsubStatus?.();
@@ -382,15 +507,18 @@ class JobScheduler {
                     if (errorBlock) {
                         finalStatus = "failure";
                         run.error = errorBlock.details ? `${errorBlock.error}: ${errorBlock.details}` : errorBlock.error;
+                        jlog("error-block-detected", { error: run.error });
                     }
                 }
                 run.status = finalStatus;
                 const transcriptCount = (0, transcript_1.countTranscriptMessages)(sessionId, jobCwd);
+                jlog("transcript-count", { transcriptCount, runMessageCount: run.messageCount });
                 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);
+                    jlog("inbox-parse", { found: !!inbox });
                     if (inbox) {
                         (0, inbox_1.addInboxMessage)({ ...inbox, jobId: job.id, jobName: job.name, runId: run.id, notifyProviders: job.notifyProviders });
                     }
@@ -406,11 +534,25 @@ class JobScheduler {
                         notifyProviders: job.notifyProviders,
                     });
                 }
+                jlog("cleanup-done", {
+                    finalStatus,
+                    durationMs: run.durationMs,
+                    messageCount: run.messageCount,
+                    toolCount: run.toolsUsed.length,
+                    error: run.error,
+                });
+                // A one-shot job's PTY claude sits idle at the prompt after answering;
+                // without this it never exits and leaks ~310MB per run until the next
+                // server restart. Idempotent — a timeout already destroyed it above.
+                this.sessionManager.destroySession(sessionId);
                 this.runningJobs.delete(job.id);
                 (0, job_lock_1.releaseJobLock)(job.id);
                 resolve(run);
+                this.jobResolvers.delete(job.id);
             };
-            this.sessionManager.sendMessage(sessionId, buildJobPrompt(job));
+            const promptText = buildJobPrompt(job);
+            jlog("send-message", { promptLen: promptText.length, maxMs });
+            this.sessionManager.sendMessage(sessionId, promptText);
         });
     }
 }

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

@@ -6,6 +6,7 @@ exports.saveJob = saveJob;
 exports.deleteJob = deleteJob;
 exports.loadRuns = loadRuns;
 exports.getRun = getRun;
+exports.getJobSessionIds = getJobSessionIds;
 exports.saveRun = saveRun;
 exports.pruneAllRuns = pruneAllRuns;
 exports.getLatestRun = getLatestRun;
@@ -90,6 +91,38 @@ function loadRuns(jobId) {
 function getRun(jobId, runId) {
     return loadRuns(jobId).find((r) => r.id === runId);
 }
+/**
+ * Every session id recorded across all job runs. Used to hide scheduled-job
+ * sessions from the all-sessions feed: a job spawns a real CLI session whose
+ * transcript lands in the project dir like any other, so the run's recorded
+ * sessionId (which equals the transcript filename) is the only reliable join.
+ * A session reappears in the feed if its run record is pruned by retention.
+ */
+function getJobSessionIds() {
+    const ids = new Set();
+    let files;
+    try {
+        files = (0, node_fs_1.readdirSync)(runsDir());
+    }
+    catch {
+        return ids; // no runs dir yet
+    }
+    for (const file of files) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const data = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(runsDir(), file), "utf-8"));
+            for (const run of data.runs || []) {
+                if (run.sessionId)
+                    ids.add(run.sessionId);
+            }
+        }
+        catch {
+            // skip unreadable/corrupt run files
+        }
+    }
+    return ids;
+}
 function saveRun(run) {
     const runs = loadRuns(run.jobId);
     const idx = runs.findIndex((r) => r.id === run.id);

package/dist/src/server/mcp/cockpit-agent-prompt.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COCKPIT_AGENT_SYSTEM_PROMPT = exports.COCKPIT_AGENT_PROMPT_SENTINEL = void 0;
+exports.COCKPIT_AGENT_PROMPT_SENTINEL = "Cockpit Assistant";
+exports.COCKPIT_AGENT_SYSTEM_PROMPT = `You are the Cockpit Assistant, an AI agent embedded in Cockpit — a self-hosted web UI for running and managing Claude Code on this machine (sessions, scheduled jobs, model providers, MCP servers, app settings, and notifications). Your purpose is to let the user inspect and change Cockpit's configuration and operate its scheduled jobs through conversation instead of clicking the UI. You have a set of cockpit-config tools over MCP: read tools (names starting with list_ or get_) return current state and run automatically; write tools (create_/update_/delete_/add_/save_/run_) change state or trigger actions and are shown to the user as a proposal they approve or reject before taking effect — so state plainly what you are about to change. For scheduled jobs you can list jobs, inspect a job, create/update/delete jobs, run a job now (run_job), stop a running job (stop_job), and check which jobs are currently running (list_running_jobs). Providers, MCP servers, app settings, and notification settings can be listed and modified the same way. Be concise and direct, confirm intent before destructive changes, and prefer the job tools over guessing when asked what is running. You operate on the local single-user ${exports.COCKPIT_AGENT_PROMPT_SENTINEL} instance.`;