@alexjbarnes/cockpit 0.1.1 → 0.2.0

package/dist/server.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_http_1 = require("node:http");
+const node_os_1 = require("node:os");
 const node_url_1 = require("node:url");
 const next_1 = __importDefault(require("next"));
 const auth_1 = require("./src/server/auth");
@@ -16,6 +17,42 @@ const port = parseInt(process.env.PORT || "3001", 10);
 const host = process.env.HOST || "0.0.0.0";
 const app = (0, next_1.default)({ dev, hostname: host, port });
 const handle = app.getRequestHandler();
+function getLanAddresses() {
+    const addresses = [];
+    const ifaces = (0, node_os_1.networkInterfaces)();
+    for (const name of Object.keys(ifaces)) {
+        for (const iface of ifaces[name] || []) {
+            if (iface.family === "IPv4" && !iface.internal) {
+                addresses.push(iface.address);
+            }
+        }
+    }
+    return addresses;
+}
+function logStartupBanner() {
+    console.log(`Cockpit listening on ${host}:${port}`);
+    console.log("");
+    console.log("Connect via:");
+    const isWildcard = host === "0.0.0.0" || host === "::";
+    const isLoopback = host === "127.0.0.1" || host === "localhost" || host === "::1";
+    if (isWildcard) {
+        console.log(`  Local:    http://localhost:${port}`);
+        const network = getLanAddresses();
+        if (network.length > 0) {
+            console.log(`  Network:  http://${network[0]}:${port}`);
+            for (let i = 1; i < network.length; i++) {
+                console.log(`            http://${network[i]}:${port}`);
+            }
+        }
+    }
+    else if (isLoopback) {
+        console.log(`  Local:    http://localhost:${port}`);
+    }
+    else {
+        console.log(`  Network:  http://${host}:${port}`);
+    }
+    console.log("");
+}
 async function main() {
     // Handle password reset flag
     if (process.env.COCKPIT_RESET_PASSWORD === "true") {
@@ -34,7 +71,7 @@ async function main() {
     });
     (0, ws_handler_1.createWebSocketHandler)(server, sessionManager);
     server.listen(port, host, () => {
-        console.log(`Cockpit running on http://${host}:${port}`);
+        logStartupBanner();
         if ((0, auth_1.needsSetup)()) {
             console.log("No password set. Visit the UI to create one.");
         }

package/dist/src/server/defaults.js

@@ -17,6 +17,8 @@ const fallback = {
     editExpanded: false,
     toolCallsExpanded: false,
     model: "sonnet",
+    messageStitching: true,
+    reviewsEnabled: true,
 };
 function getDefaults() {
     try {

package/dist/src/server/inbox.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInboxMessages = getInboxMessages;
+exports.getUnreadCount = getUnreadCount;
+exports.addInboxMessage = addInboxMessage;
+exports.markRead = markRead;
+exports.markAllRead = markAllRead;
+exports.deleteInboxMessage = deleteInboxMessage;
+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 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 ensureDir() {
+    if (!(0, node_fs_1.existsSync)(INBOX_DIR))
+        (0, node_fs_1.mkdirSync)(INBOX_DIR, { recursive: true });
+}
+function readAll() {
+    if (!(0, node_fs_1.existsSync)(INBOX_FILE))
+        return [];
+    const raw = (0, node_fs_1.readFileSync)(INBOX_FILE, "utf-8");
+    const messages = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            messages.push(JSON.parse(line));
+        }
+        catch { }
+    }
+    return messages;
+}
+function writeAll(messages) {
+    ensureDir();
+    (0, node_fs_1.writeFileSync)(INBOX_FILE, messages.map((m) => JSON.stringify(m)).join("\n") + "\n");
+}
+function getInboxMessages() {
+    return readAll().sort((a, b) => b.createdAt - a.createdAt);
+}
+function getUnreadCount() {
+    return readAll().filter((m) => !m.read).length;
+}
+function addInboxMessage(msg) {
+    const messages = readAll();
+    const entry = {
+        id: (0, uuid_1.v4)(),
+        title: msg.title,
+        body: msg.body,
+        priority: msg.priority || "info",
+        jobId: msg.jobId,
+        jobName: msg.jobName,
+        runId: msg.runId,
+        createdAt: Date.now(),
+        read: false,
+    };
+    messages.push(entry);
+    writeAll(messages);
+    (0, notifications_1.dispatchNotification)({
+        title: entry.title,
+        body: entry.body,
+        priority: entry.priority,
+        source: "inbox",
+        url: `/inbox/${entry.id}`,
+        providerIds: msg.notifyProviders,
+    });
+    return entry;
+}
+function markRead(id) {
+    const messages = readAll();
+    const msg = messages.find((m) => m.id === id);
+    if (!msg)
+        return false;
+    msg.read = true;
+    writeAll(messages);
+    return true;
+}
+function markAllRead() {
+    const messages = readAll();
+    for (const m of messages)
+        m.read = true;
+    writeAll(messages);
+}
+function deleteInboxMessage(id) {
+    const messages = readAll();
+    const idx = messages.findIndex((m) => m.id === id);
+    if (idx === -1)
+        return false;
+    messages.splice(idx, 1);
+    writeAll(messages);
+    return true;
+}
+function clearInbox() {
+    writeAll([]);
+}
+const INBOX_BLOCK_RE = /```cockpit-inbox\s*\n([\s\S]*?)\n```/;
+function parseInboxBlock(text) {
+    const match = INBOX_BLOCK_RE.exec(text);
+    if (!match)
+        return null;
+    try {
+        const parsed = JSON.parse(match[1]);
+        if (typeof parsed.title !== "string" || typeof parsed.body !== "string")
+            return null;
+        return { title: parsed.title, body: parsed.body, priority: parsed.priority };
+    }
+    catch {
+        return null;
+    }
+}
+const ERROR_BLOCK_RE = /```cockpit-error\s*\n([\s\S]*?)\n```/;
+function parseErrorBlock(text) {
+    const match = ERROR_BLOCK_RE.exec(text);
+    if (!match)
+        return null;
+    try {
+        const parsed = JSON.parse(match[1]);
+        if (typeof parsed.error !== "string")
+            return null;
+        return { error: parsed.error, details: parsed.details };
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -9,15 +9,60 @@ const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const uuid_1 = require("uuid");
 const cron_utils_1 = require("./cron-utils");
+const inbox_1 = require("./inbox");
 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");
-const JOB_PROMPT_PREFIX = [
+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.",
     "",
-    "Task:",
+    "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:",
+    "",
+    "```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(SCRATCHPAD_DIR, 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 +98,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;
 }
@@ -119,17 +172,20 @@ class JobScheduler {
     }
     recoverState() {
         (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);
                 }
             }
         }
@@ -142,6 +198,19 @@ 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);
+            }
+        }
         const jobs = (0, job_storage_1.loadJobs)();
         for (const job of jobs) {
             if (!job.enabled)
@@ -175,11 +244,11 @@ 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 });
-        }
-        const sessionInfo = this.sessionManager.createSession(jobCwd, `[job] ${job.name}`);
+        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 });
+        const sessionInfo = this.sessionManager.createSession(jobCwd, `[job] ${job.name}`, {
+            bypassPermissions: !!job.bypassPermissions,
+        });
         const sessionId = sessionInfo.id;
         const run = {
             id: runId,
@@ -195,6 +264,7 @@ class JobScheduler {
         (0, job_storage_1.saveRun)(run);
         this.runningJobs.set(job.id, run);
         const toolTracker = new Map();
+        let lastAssistantText = "";
         const unsubEvent = this.sessionManager.subscribe(sessionId, (event) => {
             if (event.type === "tool_use_start" && event.toolId) {
                 toolTracker.set(event.toolId, {
@@ -215,14 +285,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,
@@ -272,18 +357,45 @@ 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) {
+                    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);
                 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

@@ -120,16 +120,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,39 @@
+"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_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 fallback = {
+    providers: [],
+};
+function getNotificationSettings() {
+    try {
+        return { ...fallback, ...JSON.parse((0, node_fs_1.readFileSync)(CONFIG_FILE, "utf-8")) };
+    }
+    catch {
+        return { ...fallback };
+    }
+}
+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");
+    }
+    catch {
+        // best effort
+    }
+    return 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");
+    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)}`;
+    }
+}