morpheus-cli 0.4.3 → 0.4.6

package/dist/runtime/tools/analytics-tools.js

@@ -1,22 +1,22 @@
 import { tool } from "langchain";
 import * as z from "zod";
-import path from "path";
 import Database from "better-sqlite3";
 import { homedir } from "os";
-// Tool for querying message counts from the database
+import path from "path";
 const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+// Tool for querying message counts from the database
 export const MessageCountTool = tool(async ({ timeRange }) => {
     try {
-        // Connect to database
         const db = new Database(dbPath);
+        // The messages table uses `created_at` (Unix ms integer), not `timestamp`
         let query = "SELECT COUNT(*) as count FROM messages";
         const params = [];
         if (timeRange) {
-            query += " WHERE timestamp BETWEEN ? AND ?";
-            params.push(timeRange.start);
-            params.push(timeRange.end);
+            query += " WHERE created_at BETWEEN ? AND ?";
+            params.push(new Date(timeRange.start).getTime());
+            params.push(new Date(timeRange.end).getTime());
         }
-        const result = db.prepare(query).get(params);
+        const result = db.prepare(query).get(...params);
         db.close();
         return JSON.stringify(result.count);
     }
@@ -26,11 +26,11 @@ export const MessageCountTool = tool(async ({ timeRange }) => {
     }
 }, {
     name: "message_count",
-    description: "Returns count of stored messages. Accepts an optional 'timeRange' parameter with start and end timestamps for filtering.",
+    description: "Returns count of stored messages. Accepts an optional 'timeRange' parameter with ISO date strings (start/end) for filtering.",
     schema: z.object({
         timeRange: z.object({
-            start: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
-            end: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+            start: z.string().describe("ISO date string, e.g. 2026-01-01T00:00:00Z"),
+            end: z.string().describe("ISO date string, e.g. 2026-12-31T23:59:59Z"),
         }).optional(),
     }),
 });
@@ -39,20 +39,44 @@ export const ProviderModelUsageTool = tool(async () => {
     try {
         const db = new Database(dbPath);
         const query = `
-        SELECT 
-          provider,
-          COALESCE(model, 'unknown') as model,
-          SUM(input_tokens) as totalInputTokens,
-          SUM(output_tokens) as totalOutputTokens,
-          SUM(total_tokens) as totalTokens,
-          COUNT(*) as messageCount
-        FROM messages
-        WHERE provider IS NOT NULL
-        GROUP BY provider, COALESCE(model, 'unknown')
-        ORDER BY provider, model
+        SELECT
+          m.provider,
+          COALESCE(m.model, 'unknown') as model,
+          SUM(m.input_tokens) as totalInputTokens,
+          SUM(m.output_tokens) as totalOutputTokens,
+          SUM(m.total_tokens) as totalTokens,
+          COUNT(*) as messageCount,
+          COALESCE(SUM(m.audio_duration_seconds), 0) as totalAudioSeconds,
+          p.input_price_per_1m,
+          p.output_price_per_1m
+        FROM messages m
+        LEFT JOIN model_pricing p ON p.provider = m.provider AND p.model = COALESCE(m.model, 'unknown')
+        WHERE m.provider IS NOT NULL
+        GROUP BY m.provider, COALESCE(m.model, 'unknown')
+        ORDER BY m.provider, m.model
       `;
-        const results = db.prepare(query).all();
+        const rows = db.prepare(query).all();
         db.close();
+        const results = rows.map(row => {
+            const inputTokens = row.totalInputTokens || 0;
+            const outputTokens = row.totalOutputTokens || 0;
+            let estimatedCostUsd = null;
+            if (row.input_price_per_1m != null && row.output_price_per_1m != null) {
+                estimatedCostUsd =
+                    (inputTokens / 1_000_000) * row.input_price_per_1m +
+                        (outputTokens / 1_000_000) * row.output_price_per_1m;
+            }
+            return {
+                provider: row.provider,
+                model: row.model,
+                totalInputTokens: inputTokens,
+                totalOutputTokens: outputTokens,
+                totalTokens: row.totalTokens || 0,
+                messageCount: row.messageCount || 0,
+                totalAudioSeconds: row.totalAudioSeconds || 0,
+                estimatedCostUsd,
+            };
+        });
         return JSON.stringify(results);
     }
     catch (error) {
@@ -61,31 +85,43 @@ export const ProviderModelUsageTool = tool(async () => {
     }
 }, {
     name: "provider_model_usage",
-    description: "Returns token usage statistics grouped by provider and model.",
+    description: "Returns token usage statistics grouped by provider and model, including audio duration and estimated cost in USD (when pricing is configured).",
     schema: z.object({}),
 });
-// Tool for querying token usage statistics from the database
+// Tool for querying global token usage statistics from the database
 export const TokenUsageTool = tool(async ({ timeRange }) => {
     try {
-        // Connect to database
         const db = new Database(dbPath);
-        let query = "SELECT SUM(input_tokens) as inputTokens, SUM(output_tokens) as outputTokens, SUM(input_tokens + output_tokens) as totalTokens FROM messages";
+        // The messages table uses `created_at` (Unix ms integer), not `timestamp`
+        let whereClause = "";
         const params = [];
         if (timeRange) {
-            query += " WHERE timestamp BETWEEN ? AND ?";
-            params.push(timeRange.start);
-            params.push(timeRange.end);
+            whereClause = " WHERE created_at BETWEEN ? AND ?";
+            params.push(new Date(timeRange.start).getTime());
+            params.push(new Date(timeRange.end).getTime());
         }
-        const result = db.prepare(query).get(params);
+        const row = db.prepare(`SELECT
+           SUM(input_tokens) as inputTokens,
+           SUM(output_tokens) as outputTokens,
+           SUM(total_tokens) as totalTokens,
+           COALESCE(SUM(audio_duration_seconds), 0) as totalAudioSeconds
+         FROM messages${whereClause}`).get(...params);
+        // Estimated cost via model_pricing join
+        const costRow = db.prepare(`SELECT
+           SUM((COALESCE(m.input_tokens, 0) / 1000000.0) * p.input_price_per_1m
+             + (COALESCE(m.output_tokens, 0) / 1000000.0) * p.output_price_per_1m) as totalCost
+         FROM messages m
+         INNER JOIN model_pricing p ON p.provider = m.provider AND p.model = COALESCE(m.model, 'unknown')
+         WHERE m.provider IS NOT NULL${whereClause ? whereClause.replace("WHERE", "AND") : ""}`).get(...params);
         db.close();
-        // Handle potential null values
-        const tokenStats = {
-            totalTokens: result.totalTokens || 0,
-            inputTokens: result.inputTokens || 0,
-            outputTokens: result.outputTokens || 0,
-            timestamp: new Date().toISOString()
-        };
-        return JSON.stringify(tokenStats);
+        return JSON.stringify({
+            inputTokens: row.inputTokens || 0,
+            outputTokens: row.outputTokens || 0,
+            totalTokens: row.totalTokens || 0,
+            totalAudioSeconds: row.totalAudioSeconds || 0,
+            estimatedCostUsd: costRow.totalCost ?? null,
+            timestamp: new Date().toISOString(),
+        });
     }
     catch (error) {
         console.error("Error in TokenUsageTool:", error);
@@ -93,11 +129,11 @@ export const TokenUsageTool = tool(async ({ timeRange }) => {
     }
 }, {
     name: "token_usage",
-    description: "Returns token usage statistics. Accepts an optional 'timeRange' parameter with start and end timestamps for filtering.",
+    description: "Returns global token usage statistics including input/output tokens, total tokens, audio duration in seconds, and estimated cost in USD (when pricing is configured). Accepts an optional 'timeRange' parameter with ISO date strings for filtering.",
     schema: z.object({
         timeRange: z.object({
-            start: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
-            end: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+            start: z.string().describe("ISO date string, e.g. 2026-01-01T00:00:00Z"),
+            end: z.string().describe("ISO date string, e.g. 2026-12-31T23:59:59Z"),
         }).optional(),
     }),
 });

package/dist/runtime/tools/diagnostic-tools.js

@@ -9,30 +9,38 @@ export const DiagnosticTool = tool(async () => {
     try {
         const timestamp = new Date().toISOString();
         const components = {};
-        // Check configuration
+        const morpheusRoot = path.join(homedir(), ".morpheus");
+        // ── Configuration ──────────────────────────────────────────────
         try {
             const configManager = ConfigManager.getInstance();
             await configManager.load();
             const config = configManager.get();
-            // Basic validation - check if required fields exist
-            const requiredFields = ['llm', 'logging', 'ui'];
+            const requiredFields = ["llm", "logging", "ui"];
             const missingFields = requiredFields.filter(field => !(field in config));
             if (missingFields.length === 0) {
+                const sati = config.sati;
+                const apoc = config.apoc;
                 components.config = {
                     status: "healthy",
                     message: "Configuration is valid and complete",
                     details: {
-                        llmProvider: config.llm?.provider,
+                        oracleProvider: config.llm?.provider,
+                        oracleModel: config.llm?.model,
+                        satiProvider: sati?.provider ?? `${config.llm?.provider} (inherited)`,
+                        satiModel: sati?.model ?? `${config.llm?.model} (inherited)`,
+                        apocProvider: apoc?.provider ?? `${config.llm?.provider} (inherited)`,
+                        apocModel: apoc?.model ?? `${config.llm?.model} (inherited)`,
+                        apocWorkingDir: apoc?.working_dir ?? "not set",
                         uiEnabled: config.ui?.enabled,
-                        uiPort: config.ui?.port
-                    }
+                        uiPort: config.ui?.port,
+                    },
                 };
             }
             else {
                 components.config = {
                     status: "warning",
-                    message: `Missing required configuration fields: ${missingFields.join(', ')}`,
-                    details: { missingFields }
+                    message: `Missing required configuration fields: ${missingFields.join(", ")}`,
+                    details: { missingFields },
                 };
             }
         }
@@ -40,45 +48,62 @@ export const DiagnosticTool = tool(async () => {
             components.config = {
                 status: "error",
                 message: `Configuration error: ${error.message}`,
-                details: {}
+                details: {},
             };
         }
-        // Check storage/database
+        // ── Short-term memory DB ────────────────────────────────────────
         try {
-            // For now, we'll check if the data directory exists
-            const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+            const dbPath = path.join(morpheusRoot, "memory", "short-memory.db");
             await fsPromises.access(dbPath);
-            components.storage = {
+            const stat = await fsPromises.stat(dbPath);
+            components.shortMemoryDb = {
                 status: "healthy",
-                message: "Database file is accessible",
-                details: { path: dbPath }
+                message: "Short-memory database is accessible",
+                details: { path: dbPath, sizeBytes: stat.size },
             };
         }
         catch (error) {
-            components.storage = {
+            components.shortMemoryDb = {
                 status: "error",
-                message: `Storage error: ${error.message}`,
-                details: {}
+                message: `Short-memory DB not accessible: ${error.message}`,
+                details: {},
             };
         }
-        // Check network connectivity (basic check)
+        // ── Sati long-term memory DB ────────────────────────────────────
+        try {
+            const satiDbPath = path.join(morpheusRoot, "memory", "sati-memory.db");
+            await fsPromises.access(satiDbPath);
+            const stat = await fsPromises.stat(satiDbPath);
+            components.satiMemoryDb = {
+                status: "healthy",
+                message: "Sati memory database is accessible",
+                details: { path: satiDbPath, sizeBytes: stat.size },
+            };
+        }
+        catch {
+            // Sati DB may not exist yet if no memories have been stored — treat as warning
+            components.satiMemoryDb = {
+                status: "warning",
+                message: "Sati memory database does not exist yet (no memories stored yet)",
+                details: {},
+            };
+        }
+        // ── LLM provider configured ─────────────────────────────────────
         try {
-            // For now, we'll just check if we can reach the LLM provider configuration
             const configManager = ConfigManager.getInstance();
-            await configManager.load();
             const config = configManager.get();
-            if (config.llm && config.llm.provider) {
+            if (config.llm?.provider) {
                 components.network = {
                     status: "healthy",
-                    message: `LLM provider configured: ${config.llm.provider}`,
-                    details: { provider: config.llm.provider }
+                    message: `Oracle LLM provider configured: ${config.llm.provider}`,
+                    details: { provider: config.llm.provider, model: config.llm.model },
                 };
             }
             else {
                 components.network = {
                     status: "warning",
-                    message: "No LLM provider configured",
-                    details: {}
+                    message: "No Oracle LLM provider configured",
+                    details: {},
                 };
             }
         }
@@ -86,39 +111,43 @@ export const DiagnosticTool = tool(async () => {
             components.network = {
                 status: "error",
                 message: `Network check error: ${error.message}`,
-                details: {}
+                details: {},
             };
         }
-        // Check if the agent is running
+        // ── Agent process ───────────────────────────────────────────────
+        components.agent = {
+            status: "healthy",
+            message: "Agent is running (this tool is executing inside the agent process)",
+            details: { pid: process.pid, uptime: `${Math.floor(process.uptime())}s` },
+        };
+        // ── Logs directory ──────────────────────────────────────────────
         try {
-            // This is a basic check - in a real implementation, we might check if the agent process is running
-            components.agent = {
+            const logsDir = path.join(morpheusRoot, "logs");
+            await fsPromises.access(logsDir);
+            components.logs = {
                 status: "healthy",
-                message: "Agent is running",
-                details: { uptime: "N/A - runtime information not available in this context" }
+                message: "Logs directory is accessible",
+                details: { path: logsDir },
             };
         }
-        catch (error) {
-            components.agent = {
-                status: "error",
-                message: `Agent check error: ${error.message}`,
-                details: {}
+        catch {
+            components.logs = {
+                status: "warning",
+                message: "Logs directory not found (will be created on first log write)",
+                details: {},
             };
         }
-        return JSON.stringify({
-            timestamp,
-            components
-        });
+        return JSON.stringify({ timestamp, components });
     }
     catch (error) {
         console.error("Error in DiagnosticTool:", error);
         return JSON.stringify({
             timestamp: new Date().toISOString(),
-            error: "Failed to run diagnostics"
+            error: "Failed to run diagnostics",
         });
     }
 }, {
     name: "diagnostic_check",
-    description: "Performs system health diagnostics and returns a comprehensive report on system components.",
+    description: "Performs system health diagnostics and returns a comprehensive report covering configuration (Oracle/Sati/Apoc), short-memory DB, Sati long-term memory DB, LLM provider, agent process, and logs directory.",
     schema: z.object({}),
 });

package/dist/runtime/webhooks/dispatcher.js

@@ -0,0 +1,95 @@
+import { WebhookRepository } from './repository.js';
+import { DisplayManager } from '../display.js';
+export class WebhookDispatcher {
+    static telegramAdapter = null;
+    static oracle = null;
+    display = DisplayManager.getInstance();
+    /**
+     * Called at boot time after TelegramAdapter.connect() succeeds,
+     * so Telegram notifications can be dispatched from any trigger.
+     */
+    static setTelegramAdapter(adapter) {
+        WebhookDispatcher.telegramAdapter = adapter;
+    }
+    /**
+     * Called at boot time with the Oracle instance so webhooks can use
+     * the full Oracle (MCPs, apoc_delegate, memory, etc.).
+     */
+    static setOracle(oracle) {
+        WebhookDispatcher.oracle = oracle;
+    }
+    /**
+     * Main orchestration method — runs in background (fire-and-forget).
+     * 1. Builds the agent prompt from webhook.prompt + payload
+     * 2. Sends to Oracle (which can use MCPs or delegate to Apoc)
+     * 3. Persists result to DB
+     * 4. Dispatches to configured channels
+     */
+    async dispatch(webhook, payload, notificationId) {
+        const repo = WebhookRepository.getInstance();
+        const oracle = WebhookDispatcher.oracle;
+        if (!oracle) {
+            const errMsg = 'Oracle not available — webhook cannot be processed.';
+            this.display.log(errMsg, { source: 'Webhooks', level: 'error' });
+            repo.updateNotificationResult(notificationId, 'failed', errMsg);
+            return;
+        }
+        const message = this.buildPrompt(webhook.prompt, payload);
+        let result;
+        let status;
+        try {
+            result = await oracle.chat(message);
+            status = 'completed';
+            this.display.log(`Webhook "${webhook.name}" completed (notification: ${notificationId})`, { source: 'Webhooks', level: 'success' });
+        }
+        catch (err) {
+            result = `Execution error: ${err.message}`;
+            status = 'failed';
+            this.display.log(`Webhook "${webhook.name}" failed: ${err.message}`, { source: 'Webhooks', level: 'error' });
+        }
+        // Persist result
+        repo.updateNotificationResult(notificationId, status, result);
+        // Dispatch to configured channels
+        for (const channel of webhook.notification_channels) {
+            if (channel === 'telegram') {
+                await this.sendTelegram(webhook.name, result, status);
+            }
+            // 'ui' channel is handled by UI polling — nothing extra needed here
+        }
+    }
+    /**
+     * Combines the user-authored webhook prompt with the received payload.
+     */
+    buildPrompt(webhookPrompt, payload) {
+        const payloadStr = JSON.stringify(payload, null, 2);
+        return `${webhookPrompt}
+
+---
+RECEIVED WEBHOOK PAYLOAD:
+\`\`\`json
+${payloadStr}
+\`\`\`
+
+Analyze the payload above and follow the instructions provided. Be concise and actionable in your response.`;
+    }
+    /**
+     * Sends a formatted Telegram message to all allowed users.
+     * Silently skips if the adapter is not connected.
+     */
+    async sendTelegram(webhookName, result, status) {
+        const adapter = WebhookDispatcher.telegramAdapter;
+        if (!adapter) {
+            this.display.log('Telegram notification skipped — adapter not connected.', { source: 'Webhooks', level: 'warning' });
+            return;
+        }
+        try {
+            const icon = status === 'completed' ? '✅' : '❌';
+            const truncated = result.length > 3500 ? result.slice(0, 3500) + '…' : result;
+            const message = `${icon} *Webhook: ${webhookName}*\n\n${truncated}`;
+            await adapter.sendMessage(message);
+        }
+        catch (err) {
+            this.display.log(`Failed to send Telegram notification for webhook "${webhookName}": ${err.message}`, { source: 'Webhooks', level: 'error' });
+        }
+    }
+}

package/dist/runtime/webhooks/repository.js

@@ -0,0 +1,199 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import { homedir } from 'os';
+import fs from 'fs-extra';
+import { randomUUID } from 'crypto';
+export class WebhookRepository {
+    static instance = null;
+    db;
+    constructor() {
+        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+        fs.ensureDirSync(path.dirname(dbPath));
+        this.db = new Database(dbPath, { timeout: 5000 });
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.ensureTables();
+    }
+    static getInstance() {
+        if (!WebhookRepository.instance) {
+            WebhookRepository.instance = new WebhookRepository();
+        }
+        return WebhookRepository.instance;
+    }
+    ensureTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS webhooks (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        api_key TEXT NOT NULL UNIQUE,
+        prompt TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        notification_channels TEXT NOT NULL DEFAULT '["ui"]',
+        created_at INTEGER NOT NULL,
+        last_triggered_at INTEGER,
+        trigger_count INTEGER NOT NULL DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_webhooks_name ON webhooks(name);
+      CREATE INDEX IF NOT EXISTS idx_webhooks_api_key ON webhooks(api_key);
+
+      CREATE TABLE IF NOT EXISTS webhook_notifications (
+        id TEXT PRIMARY KEY,
+        webhook_id TEXT NOT NULL,
+        webhook_name TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        payload TEXT NOT NULL,
+        result TEXT,
+        read INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        FOREIGN KEY (webhook_id) REFERENCES webhooks(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_webhook_notifications_webhook_id
+        ON webhook_notifications(webhook_id);
+      CREATE INDEX IF NOT EXISTS idx_webhook_notifications_read
+        ON webhook_notifications(read);
+      CREATE INDEX IF NOT EXISTS idx_webhook_notifications_created_at
+        ON webhook_notifications(created_at DESC);
+    `);
+    }
+    // ─── Webhook CRUD ────────────────────────────────────────────────────────────
+    createWebhook(data) {
+        const id = randomUUID();
+        const api_key = randomUUID();
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO webhooks (id, name, api_key, prompt, enabled, notification_channels, created_at)
+      VALUES (?, ?, ?, ?, 1, ?, ?)
+    `).run(id, data.name, api_key, data.prompt, JSON.stringify(data.notification_channels), now);
+        return this.getWebhookById(id);
+    }
+    listWebhooks() {
+        const rows = this.db.prepare('SELECT * FROM webhooks ORDER BY created_at DESC').all();
+        return rows.map(this.deserializeWebhook);
+    }
+    getWebhookById(id) {
+        const row = this.db.prepare('SELECT * FROM webhooks WHERE id = ?').get(id);
+        return row ? this.deserializeWebhook(row) : null;
+    }
+    getWebhookByName(name) {
+        const row = this.db.prepare('SELECT * FROM webhooks WHERE name = ?').get(name);
+        return row ? this.deserializeWebhook(row) : null;
+    }
+    /**
+     * Looks up a webhook by name, then validates the api_key and enabled status.
+     * Returns null if not found, disabled, or api_key mismatch (caller decides error code).
+     */
+    getAndValidateWebhook(name, api_key) {
+        const row = this.db.prepare('SELECT * FROM webhooks WHERE name = ? AND enabled = 1').get(name);
+        if (!row)
+            return null;
+        const wh = this.deserializeWebhook(row);
+        if (wh.api_key !== api_key)
+            return null;
+        return wh;
+    }
+    updateWebhook(id, data) {
+        const existing = this.getWebhookById(id);
+        if (!existing)
+            return null;
+        const name = data.name ?? existing.name;
+        const prompt = data.prompt ?? existing.prompt;
+        const enabled = data.enabled !== undefined ? (data.enabled ? 1 : 0) : (existing.enabled ? 1 : 0);
+        const notification_channels = JSON.stringify(data.notification_channels ?? existing.notification_channels);
+        this.db.prepare(`
+      UPDATE webhooks
+      SET name = ?, prompt = ?, enabled = ?, notification_channels = ?
+      WHERE id = ?
+    `).run(name, prompt, enabled, notification_channels, id);
+        return this.getWebhookById(id);
+    }
+    deleteWebhook(id) {
+        const result = this.db.prepare('DELETE FROM webhooks WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    recordTrigger(webhookId) {
+        this.db.prepare(`
+      UPDATE webhooks
+      SET trigger_count = trigger_count + 1, last_triggered_at = ?
+      WHERE id = ?
+    `).run(Date.now(), webhookId);
+    }
+    deserializeWebhook(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            api_key: row.api_key,
+            prompt: row.prompt,
+            enabled: Boolean(row.enabled),
+            notification_channels: JSON.parse(row.notification_channels || '["ui"]'),
+            created_at: row.created_at,
+            last_triggered_at: row.last_triggered_at ?? null,
+            trigger_count: row.trigger_count ?? 0,
+        };
+    }
+    // ─── Notification CRUD ───────────────────────────────────────────────────────
+    createNotification(data) {
+        const id = randomUUID();
+        this.db.prepare(`
+      INSERT INTO webhook_notifications
+        (id, webhook_id, webhook_name, status, payload, read, created_at)
+      VALUES (?, ?, ?, 'pending', ?, 0, ?)
+    `).run(id, data.webhook_id, data.webhook_name, data.payload, Date.now());
+        return this.getNotificationById(id);
+    }
+    updateNotificationResult(id, status, result) {
+        this.db.prepare(`
+      UPDATE webhook_notifications
+      SET status = ?, result = ?, completed_at = ?
+      WHERE id = ?
+    `).run(status, result, Date.now(), id);
+    }
+    listNotifications(filters) {
+        let query = 'SELECT * FROM webhook_notifications WHERE 1=1';
+        const params = [];
+        if (filters?.webhookId) {
+            query += ' AND webhook_id = ?';
+            params.push(filters.webhookId);
+        }
+        if (filters?.unreadOnly) {
+            query += ' AND read = 0';
+        }
+        query += ' ORDER BY created_at DESC LIMIT 500';
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(this.deserializeNotification);
+    }
+    getNotificationById(id) {
+        const row = this.db.prepare('SELECT * FROM webhook_notifications WHERE id = ?').get(id);
+        return row ? this.deserializeNotification(row) : null;
+    }
+    markNotificationsRead(ids) {
+        const stmt = this.db.prepare('UPDATE webhook_notifications SET read = 1 WHERE id = ?');
+        const tx = this.db.transaction((list) => {
+            for (const id of list)
+                stmt.run(id);
+        });
+        tx(ids);
+    }
+    countUnread() {
+        const row = this.db.prepare('SELECT COUNT(*) as cnt FROM webhook_notifications WHERE read = 0').get();
+        return row?.cnt ?? 0;
+    }
+    deserializeNotification(row) {
+        return {
+            id: row.id,
+            webhook_id: row.webhook_id,
+            webhook_name: row.webhook_name,
+            status: row.status,
+            payload: row.payload,
+            result: row.result ?? null,
+            read: Boolean(row.read),
+            created_at: row.created_at,
+            completed_at: row.completed_at ?? null,
+        };
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/runtime/webhooks/types.js

@@ -0,0 +1 @@
+export {};