morpheus-cli 0.5.1 → 0.5.3

package/README.md

@@ -64,6 +64,81 @@ morpheus session new
 morpheus session status
 ```
 
+## Docker
+
+### Docker Compose (recommended)
+
+**1. Create an `env.docker` file** (referenced by `docker-compose.yml`):
+
+```bash
+cp .env.example env.docker   # or create manually
+```
+
+Minimal `env.docker`:
+
+```env
+OPENAI_API_KEY=sk-...
+THE_ARCHITECT_PASS=changeme
+```
+
+**2. Run:**
+
+```bash
+docker compose up -d
+```
+
+The dashboard will be available at `http://localhost:3333`.
+
+**Useful commands:**
+
+```bash
+docker compose logs -f          # follow logs
+docker compose restart morpheus # restart the agent
+docker compose down             # stop
+docker compose down -v          # stop and remove persistent data
+```
+
+**Data persistence:** configuration and databases are stored in the `morpheus_data` Docker volume (`/root/.morpheus` inside the container). They survive container restarts and rebuilds.
+
+**Override variables** at runtime via the `environment` block in `docker-compose.yml` or directly in `env.docker`. All `MORPHEUS_*` env vars work the same as in a native install. See the [Environment Variables](#environment-variables) section for the full list.
+
+### Docker (standalone)
+
+**Build:**
+
+```bash
+docker build -t morpheus .
+```
+
+**Run:**
+
+```bash
+docker run -d \
+  --name morpheus-agent \
+  -p 3333:3333 \
+  -e OPENAI_API_KEY=sk-... \
+  -e THE_ARCHITECT_PASS=changeme \
+  -v morpheus_data:/root/.morpheus \
+  morpheus
+```
+
+**With Telegram:**
+
+```bash
+docker run -d \
+  --name morpheus-agent \
+  -p 3333:3333 \
+  -e OPENAI_API_KEY=sk-... \
+  -e THE_ARCHITECT_PASS=changeme \
+  -e MORPHEUS_TELEGRAM_ENABLED=true \
+  -e MORPHEUS_TELEGRAM_TOKEN=<bot-token> \
+  -e MORPHEUS_TELEGRAM_ALLOWED_USERS=123456789 \
+  -v morpheus_data:/root/.morpheus \
+  morpheus
+```
+
+**Health check:** the container exposes `GET /health` and Docker will probe it every 30s (60s start period, 3 retries before marking unhealthy).
+
 ## Async Task Execution
 
 Morpheus uses asynchronous delegation by default:

package/dist/cli/commands/start.js

@@ -162,6 +162,10 @@ export const startCommand = new Command('start')
             taskWorker.start();
             taskNotifier.start();
         }
+        // Recover webhook notifications stuck in 'pending' from previous runs
+        WebhookDispatcher.recoverStale().catch((err) => {
+            display.log(`Webhook recovery error: ${err.message}`, { source: 'Webhooks', level: 'error' });
+        });
         // Handle graceful shutdown
         const shutdown = async (signal) => {
             display.stopSpinner();

package/dist/runtime/tasks/repository.js

@@ -148,6 +148,10 @@ export class TaskRepository {
         const row = this.db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
         return row ? this.deserializeTask(row) : null;
     }
+    findTaskByOriginMessageId(originMessageId) {
+        const row = this.db.prepare('SELECT * FROM tasks WHERE origin_message_id = ? LIMIT 1').get(originMessageId);
+        return row ? this.deserializeTask(row) : null;
+    }
     listTasks(filters) {
         const params = [];
         let query = 'SELECT * FROM tasks WHERE 1=1';

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,62 @@ ${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' });
+            // Sequential await — recovery dispatches run one at a time.
+            // Firing all at once would flood Oracle and cause concurrent
+            // EmbeddingService initializations, leading to repeated ONNX errors.
+            try {
+                const dispatcher = new WebhookDispatcher();
+                await 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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morpheus-cli",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Morpheus is a local AI agent for developers, running as a CLI daemon that connects to LLMs, local tools, and MCPs, enabling interaction via Terminal, Telegram, and Discord. Inspired by the character Morpheus from *The Matrix*, the project acts as an intelligent orchestrator, bridging the gap between the developer and complex systems.",
   "bin": {
     "morpheus": "./bin/morpheus.js"