morpheus-cli 0.5.0 → 0.5.2

package/dist/runtime/trinity.js

@@ -0,0 +1,246 @@
+import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { ConfigManager } from "../config/manager.js";
+import { ProviderFactory } from "./providers/factory.js";
+import { ProviderError } from "./errors.js";
+import { DisplayManager } from "./display.js";
+import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+import { DatabaseRegistry } from "./memory/trinity-db.js";
+import { testConnection, introspectSchema, executeQuery } from "./trinity-connector.js";
+import { updateTrinityDelegateToolDescription } from "./tools/trinity-tool.js";
+/**
+ * Trinity is a subagent of Oracle specialized in database operations.
+ * It receives delegated tasks from Oracle, interprets them in natural language,
+ * generates appropriate queries (SQL or NoSQL), executes them, and returns results.
+ */
+export class Trinity {
+    static instance = null;
+    static currentSessionId = undefined;
+    agent;
+    config;
+    display = DisplayManager.getInstance();
+    constructor(config) {
+        this.config = config || ConfigManager.getInstance().get();
+    }
+    static setSessionId(sessionId) {
+        Trinity.currentSessionId = sessionId;
+    }
+    static getInstance(config) {
+        if (!Trinity.instance) {
+            Trinity.instance = new Trinity(config);
+        }
+        return Trinity.instance;
+    }
+    static resetInstance() {
+        Trinity.instance = null;
+    }
+    static async refreshDelegateCatalog() {
+        const registry = DatabaseRegistry.getInstance();
+        const databases = registry.listDatabases();
+        updateTrinityDelegateToolDescription(databases);
+    }
+    buildTrinityTools() {
+        const registry = DatabaseRegistry.getInstance();
+        const listDatabases = tool(async () => {
+            const dbs = registry.listDatabases();
+            if (dbs.length === 0)
+                return 'No databases registered.';
+            return dbs.map((db) => {
+                const schema = db.schema_json
+                    ? JSON.parse(db.schema_json)
+                    : null;
+                let schemaSummary = 'schema not loaded';
+                if (schema) {
+                    if (schema.databases) {
+                        const totalTables = schema.databases.reduce((acc, d) => acc + d.tables.length, 0);
+                        schemaSummary = `${schema.databases.length} databases, ${totalTables} tables total`;
+                    }
+                    else {
+                        schemaSummary = schema.tables?.map((t) => t.name).join(', ') || 'no tables';
+                    }
+                }
+                const updatedAt = db.schema_updated_at
+                    ? new Date(db.schema_updated_at).toISOString()
+                    : 'never';
+                return `[${db.id}] ${db.name} (${db.type}) — ${schemaSummary} — schema updated: ${updatedAt}`;
+            }).join('\n');
+        }, {
+            name: 'trinity_list_databases',
+            description: 'List all registered databases with their name, type, and schema summary.',
+            schema: z.object({}),
+        });
+        const getSchema = tool(async ({ database_id }) => {
+            const db = registry.getDatabase(database_id);
+            if (!db)
+                return `Database with id ${database_id} not found.`;
+            if (!db.schema_json)
+                return `No schema cached for database "${db.name}". Use trinity_refresh_schema first.`;
+            return `Schema for "${db.name}" (${db.type}):\n${db.schema_json}`;
+        }, {
+            name: 'trinity_get_schema',
+            description: 'Get the full cached schema of a registered database by its id.',
+            schema: z.object({
+                database_id: z.number().describe('The id of the database to get schema for'),
+            }),
+        });
+        const refreshSchema = tool(async ({ database_id }) => {
+            const db = registry.getDatabase(database_id);
+            if (!db)
+                return `Database with id ${database_id} not found.`;
+            try {
+                const schema = await introspectSchema(db);
+                registry.updateSchema(database_id, JSON.stringify(schema, null, 2));
+                if (schema.databases) {
+                    const totalTables = schema.databases.reduce((acc, d) => acc + d.tables.length, 0);
+                    const summary = schema.databases.map((d) => `${d.name}(${d.tables.length}t)`).join(', ');
+                    return `Schema refreshed for "${db.name}". Found ${schema.databases.length} databases: ${summary}. Total: ${totalTables} tables.`;
+                }
+                return `Schema refreshed for "${db.name}". Tables: ${schema.tables.map((t) => t.name).join(', ')}`;
+            }
+            catch (err) {
+                return `Failed to refresh schema for "${db.name}": ${err.message}`;
+            }
+        }, {
+            name: 'trinity_refresh_schema',
+            description: 'Re-introspect and update the cached schema for a registered database.',
+            schema: z.object({
+                database_id: z.number().describe('The id of the database to refresh schema for'),
+            }),
+        });
+        const testConnectionTool = tool(async ({ database_id }) => {
+            const db = registry.getDatabase(database_id);
+            if (!db)
+                return `Database with id ${database_id} not found.`;
+            try {
+                const ok = await testConnection(db);
+                return ok
+                    ? `Connection to "${db.name}" (${db.type}) successful.`
+                    : `Connection to "${db.name}" (${db.type}) failed.`;
+            }
+            catch (err) {
+                return `Connection test failed: ${err.message}`;
+            }
+        }, {
+            name: 'trinity_test_connection',
+            description: 'Test connectivity to a registered database.',
+            schema: z.object({
+                database_id: z.number().describe('The id of the database to test'),
+            }),
+        });
+        const executeQueryTool = tool(async ({ database_id, query, params, }) => {
+            const db = registry.getDatabase(database_id);
+            if (!db)
+                return `Database with id ${database_id} not found.`;
+            try {
+                const result = await executeQuery(db, query, params);
+                if (result.rows.length === 0)
+                    return `Query returned 0 rows. (rowCount: ${result.rowCount})`;
+                const preview = result.rows.slice(0, 50);
+                const json = JSON.stringify(preview, null, 2);
+                const note = result.rowCount > 50 ? `\n... (${result.rowCount} total rows, showing first 50)` : '';
+                return `Rows (${result.rowCount}):\n${json}${note}`;
+            }
+            catch (err) {
+                return `Query execution failed: ${err.message}`;
+            }
+        }, {
+            name: 'trinity_execute_query',
+            description: 'Execute a SQL query (PostgreSQL/MySQL/SQLite) or MongoDB JSON command on a registered database. ' +
+                'For SQL: pass a standard SQL string. ' +
+                'For MongoDB: pass a JSON string with { "collection": "name", "operation": "find|aggregate|countDocuments", "filter": {}, "options": {} }.',
+            schema: z.object({
+                database_id: z.number().describe('The id of the target database'),
+                query: z.string().describe('SQL query string or MongoDB JSON command'),
+                params: z.array(z.any()).optional().describe('Optional positional parameters for parameterized SQL queries'),
+            }),
+        });
+        return [listDatabases, getSchema, refreshSchema, testConnectionTool, executeQueryTool];
+    }
+    async initialize() {
+        const trinityConfig = this.config.trinity || this.config.llm;
+        const tools = this.buildTrinityTools();
+        this.display.log(`Trinity initialized with ${tools.length} tools.`, { source: 'Trinity' });
+        try {
+            this.agent = await ProviderFactory.createBare(trinityConfig, tools);
+        }
+        catch (err) {
+            throw new ProviderError(trinityConfig.provider, err, 'Trinity subagent initialization failed');
+        }
+    }
+    async execute(task, context, sessionId) {
+        if (!this.agent) {
+            await this.initialize();
+        }
+        const trinityConfig = this.config.trinity || this.config.llm;
+        this.display.log(`Executing delegated task: ${task.slice(0, 80)}...`, { source: 'Trinity' });
+        const registry = DatabaseRegistry.getInstance();
+        const databases = registry.listDatabases();
+        const dbSummary = databases.length > 0
+            ? databases.map((db) => {
+                const schema = db.schema_json ? JSON.parse(db.schema_json) : null;
+                const tables = schema?.tables?.map((t) => t.name).join(', ') || 'schema not loaded';
+                return `- [${db.id}] ${db.name} (${db.type}): ${tables}`;
+            }).join('\n')
+            : '  (no databases registered)';
+        const systemMessage = new SystemMessage(`
+You are Trinity, a specialized database subagent within the Morpheus system.
+
+You receive natural-language database tasks from Oracle and execute them using your available tools.
+
+Registered databases:
+${dbSummary}
+
+OPERATING RULES:
+1. Interpret the task in natural language and determine the correct query to execute.
+2. Always check the schema first using trinity_get_schema before writing queries.
+3. If the schema is missing, use trinity_refresh_schema to load it.
+4. Write safe, read-only queries by default. Only execute write operations if explicitly requested.
+5. Return results in a clear, structured format.
+6. If a query fails, try to diagnose the issue and suggest a fix.
+7. Never expose raw credentials or connection strings in your responses.
+8. Respond in the same language as the task.
+9. For SQL databases: write standard SQL appropriate to the database type.
+10. For MongoDB: format queries as JSON with { collection, operation, filter, options }.
+
+${context ? `CONTEXT FROM ORACLE:\n${context}` : ''}
+    `);
+        const userMessage = new HumanMessage(task);
+        const messages = [systemMessage, userMessage];
+        try {
+            const response = await this.agent.invoke({ messages });
+            const lastMessage = response.messages[response.messages.length - 1];
+            const content = typeof lastMessage.content === 'string'
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+            const targetSession = sessionId ?? Trinity.currentSessionId ?? 'trinity';
+            const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
+            try {
+                const persisted = new AIMessage(content);
+                persisted.usage_metadata =
+                    lastMessage.usage_metadata ??
+                        lastMessage.response_metadata?.usage ??
+                        lastMessage.response_metadata?.tokenUsage ??
+                        lastMessage.usage;
+                persisted.provider_metadata = {
+                    provider: trinityConfig.provider,
+                    model: trinityConfig.model,
+                };
+                await history.addMessage(persisted);
+            }
+            finally {
+                history.close();
+            }
+            this.display.log('Trinity task completed.', { source: 'Trinity' });
+            return content;
+        }
+        catch (err) {
+            throw new ProviderError(trinityConfig.provider, err, 'Trinity task execution failed');
+        }
+    }
+    async reload() {
+        this.config = ConfigManager.getInstance().get();
+        this.agent = undefined;
+        await this.initialize();
+    }
+}

package/dist/runtime/webhooks/dispatcher.js

@@ -1,5 +1,7 @@
 import { WebhookRepository } from './repository.js';
+import { TaskRepository } from '../tasks/repository.js';
 import { DisplayManager } from '../display.js';
+const STALE_NOTIFICATION_THRESHOLD_MS = 2 * 60 * 1000; // 2 minutes
 export class WebhookDispatcher {
     static telegramAdapter = null;
     static oracle = null;
@@ -35,17 +37,35 @@ export class WebhookDispatcher {
         }
         const message = this.buildPrompt(webhook.prompt, payload);
         try {
-            await oracle.chat(message, undefined, false, {
+            const response = await oracle.chat(message, undefined, false, {
                 origin_channel: 'webhook',
                 session_id: `webhook-${webhook.id}`,
                 origin_message_id: notificationId,
             });
-            this.display.log(`Webhook "${webhook.name}" accepted and queued (notification: ${notificationId})`, { source: 'Webhooks', level: 'success' });
+            // Check whether Oracle delegated a task for this notification.
+            // If a task exists with this origin_message_id, TaskNotifier will update
+            // the notification when the task completes. If not (Oracle answered
+            // directly), mark it completed now with the direct response.
+            const taskRepo = TaskRepository.getInstance();
+            const delegatedTask = taskRepo.findTaskByOriginMessageId(notificationId);
+            if (delegatedTask) {
+                this.display.log(`Webhook "${webhook.name}" accepted and queued (notification: ${notificationId})`, { source: 'Webhooks', level: 'success' });
+            }
+            else {
+                repo.updateNotificationResult(notificationId, 'completed', response);
+                this.display.log(`Webhook "${webhook.name}" completed with direct response (notification: ${notificationId})`, { source: 'Webhooks', level: 'success' });
+                if (webhook.notification_channels.includes('telegram')) {
+                    await this.sendTelegram(webhook.name, response, 'completed');
+                }
+            }
         }
         catch (err) {
             const result = `Execution error: ${err.message}`;
             this.display.log(`Webhook "${webhook.name}" failed: ${err.message}`, { source: 'Webhooks', level: 'error' });
             repo.updateNotificationResult(notificationId, 'failed', result);
+            if (webhook.notification_channels.includes('telegram')) {
+                await this.sendTelegram(webhook.name, result, 'failed');
+            }
         }
     }
     /**
@@ -63,6 +83,57 @@ ${payloadStr}
 
 Analyze the payload above and follow the instructions provided. Be concise and actionable in your response.`;
     }
+    /**
+     * Called at startup to re-dispatch webhook notifications that got stuck in
+     * 'pending' status (e.g. from a previous crash or from the direct-response
+     * bug). Skips notifications that already have an active task running.
+     */
+    static async recoverStale() {
+        const display = DisplayManager.getInstance();
+        const oracle = WebhookDispatcher.oracle;
+        if (!oracle) {
+            display.log('Webhook recovery skipped — Oracle not available.', {
+                source: 'Webhooks',
+                level: 'warning',
+            });
+            return;
+        }
+        const repo = WebhookRepository.getInstance();
+        const taskRepo = TaskRepository.getInstance();
+        const stale = repo.findStaleNotifications(STALE_NOTIFICATION_THRESHOLD_MS);
+        if (stale.length === 0)
+            return;
+        display.log(`Recovering ${stale.length} stale webhook notification(s)...`, {
+            source: 'Webhooks',
+            level: 'warning',
+        });
+        for (const notification of stale) {
+            // Skip if a task is still active for this notification
+            const activeTask = taskRepo.findTaskByOriginMessageId(notification.id);
+            if (activeTask && (activeTask.status === 'pending' || activeTask.status === 'running')) {
+                display.log(`Webhook notification ${notification.id} has active task ${activeTask.id} — skipping recovery.`, { source: 'Webhooks' });
+                continue;
+            }
+            const webhook = repo.getWebhookById(notification.webhook_id);
+            if (!webhook || !webhook.enabled) {
+                repo.updateNotificationResult(notification.id, 'failed', webhook ? 'Webhook was disabled.' : 'Webhook no longer exists.');
+                continue;
+            }
+            let payload;
+            try {
+                payload = JSON.parse(notification.payload);
+            }
+            catch {
+                payload = {};
+            }
+            display.log(`Re-dispatching stale notification ${notification.id} for webhook "${webhook.name}".`, { source: 'Webhooks' });
+            // Fire-and-forget re-dispatch (same pattern as the trigger endpoint)
+            const dispatcher = new WebhookDispatcher();
+            dispatcher.dispatch(webhook, payload, notification.id).catch((err) => {
+                display.log(`Recovery dispatch error for notification ${notification.id}: ${err.message}`, { source: 'Webhooks', level: 'error' });
+            });
+        }
+    }
     /**
      * Sends a formatted Telegram message to all allowed users.
      * Silently skips if the adapter is not connected.

package/dist/runtime/webhooks/repository.js

@@ -180,6 +180,13 @@ export class WebhookRepository {
         const row = this.db.prepare('SELECT COUNT(*) as cnt FROM webhook_notifications WHERE read = 0').get();
         return row?.cnt ?? 0;
     }
+    findStaleNotifications(olderThanMs) {
+        const cutoff = Date.now() - olderThanMs;
+        const rows = this.db.prepare(`SELECT * FROM webhook_notifications
+       WHERE status = 'pending' AND created_at < ?
+       ORDER BY created_at ASC`).all(cutoff);
+        return rows.map(this.deserializeNotification);
+    }
     deserializeNotification(row) {
         return {
             id: row.id,