morpheus-cli 0.6.2 → 0.6.3

package/dist/cli/commands/start.js

@@ -8,6 +8,8 @@ import { writePid, readPid, isProcessRunning, clearPid, checkStalePid, killProce
 import { ConfigManager } from '../../config/manager.js';
 import { renderBanner } from '../utils/render.js';
 import { TelegramAdapter } from '../../channels/telegram.js';
+import { DiscordAdapter } from '../../channels/discord.js';
+import { ChannelRegistry } from '../../channels/registry.js';
 import { WebhookDispatcher } from '../../runtime/webhooks/dispatcher.js';
 import { PATHS } from '../../config/paths.js';
 import { Oracle } from '../../runtime/oracle.js';
@@ -17,7 +19,6 @@ import { getVersion } from '../utils/version.js';
 import { startSessionEmbeddingScheduler } from '../../runtime/session-embedding-scheduler.js';
 import { TaskWorker } from '../../runtime/tasks/worker.js';
 import { TaskNotifier } from '../../runtime/tasks/notifier.js';
-import { TaskDispatcher } from '../../runtime/tasks/dispatcher.js';
 import { ChronosWorker } from '../../runtime/chronos/worker.js';
 import { ChronosRepository } from '../../runtime/chronos/repository.js';
 export const startCommand = new Command('start')
@@ -148,10 +149,7 @@ export const startCommand = new Command('start')
                 const telegram = new TelegramAdapter(oracle);
                 try {
                     await telegram.connect(config.channels.telegram.token, config.channels.telegram.allowedUsers || []);
-                    // Wire Telegram adapter to webhook dispatcher for proactive notifications
-                    WebhookDispatcher.setTelegramAdapter(telegram);
-                    TaskDispatcher.setTelegramAdapter(telegram);
-                    ChronosWorker.setNotifyFn((text) => telegram.sendMessage(text));
+                    ChannelRegistry.register(telegram);
                     adapters.push(telegram);
                 }
                 catch (e) {
@@ -162,6 +160,23 @@ export const startCommand = new Command('start')
                 display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'), { source: 'Zaion' });
             }
         }
+        // Initialize Discord
+        if (config.channels.discord.enabled) {
+            if (config.channels.discord.token) {
+                const discord = new DiscordAdapter(oracle);
+                try {
+                    await discord.connect(config.channels.discord.token, config.channels.discord.allowedUsers || []);
+                    ChannelRegistry.register(discord);
+                    adapters.push(discord);
+                }
+                catch (e) {
+                    display.log(chalk.red(`Failed to initialize Discord adapter: ${e.message}`), { source: 'Zaion' });
+                }
+            }
+            else {
+                display.log(chalk.yellow('Discord enabled but no token provided. Skipping.'), { source: 'Zaion' });
+            }
+        }
         // Start Background Services
         startSessionEmbeddingScheduler();
         chronosWorker.start();

package/dist/config/manager.js

@@ -167,8 +167,9 @@ export class ConfigManager {
                 allowedUsers: resolveStringArray('MORPHEUS_TELEGRAM_ALLOWED_USERS', config.channels.telegram.allowedUsers, DEFAULT_CONFIG.channels.telegram.allowedUsers)
             },
             discord: {
-                enabled: config.channels.discord.enabled, // Discord doesn't have env var precedence for now
-                token: config.channels.discord.token
+                enabled: config.channels.discord.enabled,
+                token: config.channels.discord.token,
+                allowedUsers: config.channels.discord.allowedUsers ?? []
             }
         };
         // Apply precedence to UI config

package/dist/config/schemas.js

@@ -67,6 +67,7 @@ export const ConfigSchema = z.object({
         discord: z.object({
             enabled: z.boolean().default(false),
             token: z.string().optional(),
+            allowedUsers: z.array(z.string()).default([]),
         }).default(DEFAULT_CONFIG.channels.discord),
     }).default(DEFAULT_CONFIG.channels),
     ui: z.object({

package/dist/http/routers/chronos.js

@@ -11,12 +11,14 @@ const CreateJobSchema = z.object({
     schedule_type: ScheduleTypeSchema,
     schedule_expression: z.string().min(1),
     timezone: z.string().optional(),
+    notify_channels: z.array(z.string()).optional(),
 });
 const UpdateJobSchema = z.object({
     prompt: z.string().min(1).max(10000).optional(),
     schedule_expression: z.string().min(1).optional(),
     timezone: z.string().optional(),
     enabled: z.boolean().optional(),
+    notify_channels: z.array(z.string()).optional(),
 });
 const PreviewSchema = z.object({
     expression: z.string().min(1),
@@ -83,7 +85,7 @@ export function createChronosJobRouter(repo, _worker) {
         if (!parsed.success) {
             return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
         }
-        const { prompt, schedule_type, schedule_expression, timezone } = parsed.data;
+        const { prompt, schedule_type, schedule_expression, timezone, notify_channels } = parsed.data;
         const globalTz = configManager.getChronosConfig().timezone;
         const tz = timezone ?? globalTz;
         const opts = { timezone: tz };
@@ -97,6 +99,7 @@ export function createChronosJobRouter(repo, _worker) {
                 timezone: tz,
                 next_run_at: schedule.next_run_at,
                 created_by: 'ui',
+                notify_channels: notify_channels ?? [],
             });
             const display = DisplayManager.getInstance();
             display.log(`Job ${job.id} created — ${schedule.human_readable}`, { source: 'Chronos' });
@@ -154,6 +157,7 @@ export function createChronosJobRouter(repo, _worker) {
                 timezone: patch.timezone,
                 next_run_at: updatedSchedule?.next_run_at,
                 enabled: patch.enabled,
+                notify_channels: patch.notify_channels,
             });
             res.json(job);
         }

package/dist/runtime/__tests__/manual_start_verify.js

@@ -7,7 +7,7 @@ const mockConfig = {
     llm: { provider: 'openai', model: 'gpt-3.5-turbo', temperature: 0.1, api_key: 'sk-mock-key' },
     channels: {
         telegram: { enabled: false, allowedUsers: [] },
-        discord: { enabled: false }
+        discord: { enabled: false, allowedUsers: [] }
     },
     ui: { enabled: false, port: 3333 },
     logging: { enabled: false, level: 'info', retention: '1d' },

package/dist/runtime/chronos/repository.js

@@ -61,6 +61,7 @@ export class ChronosRepository {
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_at INTEGER NOT NULL DEFAULT 0`, 'created_at');
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0`, 'updated_at');
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_by TEXT NOT NULL DEFAULT 'api'`, 'created_by');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN notify_channels TEXT NOT NULL DEFAULT '[]'`, 'notify_channels');
         const execInfo = this.db.pragma('table_info(chronos_executions)');
         const execCols = new Set(execInfo.map((c) => c.name));
         const addExecCol = (sql, col) => {
@@ -87,6 +88,11 @@ export class ChronosRepository {
     `);
     }
     deserializeJob(row) {
+        let notify_channels = [];
+        try {
+            notify_channels = JSON.parse(row.notify_channels || '[]');
+        }
+        catch { /* keep [] */ }
         return {
             id: row.id,
             prompt: row.prompt,
@@ -100,6 +106,7 @@ export class ChronosRepository {
             created_at: row.created_at,
             updated_at: row.updated_at,
             created_by: row.created_by,
+            notify_channels,
         };
     }
     deserializeExecution(row) {
@@ -125,9 +132,9 @@ export class ChronosRepository {
         this.db.prepare(`
       INSERT INTO chronos_jobs (
         id, prompt, schedule_type, schedule_expression, cron_normalized,
-        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?, ?)
-    `).run(id, input.prompt, input.schedule_type, input.schedule_expression, input.cron_normalized ?? null, input.timezone, input.next_run_at, now, now, input.created_by);
+        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by, notify_channels
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?, ?, ?)
+    `).run(id, input.prompt, input.schedule_type, input.schedule_expression, input.cron_normalized ?? null, input.timezone, input.next_run_at, now, now, input.created_by, JSON.stringify(input.notify_channels ?? []));
         return this.getJob(id);
     }
     getJob(id) {
@@ -181,6 +188,10 @@ export class ChronosRepository {
             sets.push('enabled = ?');
             params.push(patch.enabled ? 1 : 0);
         }
+        if (patch.notify_channels !== undefined) {
+            sets.push('notify_channels = ?');
+            params.push(JSON.stringify(patch.notify_channels));
+        }
         params.push(id);
         this.db.prepare(`UPDATE chronos_jobs SET ${sets.join(', ')} WHERE id = ?`).run(...params);
         return this.getJob(id);

package/dist/runtime/chronos/worker.js

@@ -2,11 +2,11 @@ import { randomUUID } from 'crypto';
 import { ConfigManager } from '../../config/manager.js';
 import { DisplayManager } from '../display.js';
 import { parseNextRun } from './parser.js';
+import { ChannelRegistry } from '../../channels/registry.js';
 export class ChronosWorker {
     repo;
     oracle;
     static instance = null;
-    static notifyFn = null;
     /**
      * True while a Chronos job is being executed. Chronos management tools
      * (chronos_cancel, chronos_schedule) check this flag and refuse to operate
@@ -28,10 +28,6 @@ export class ChronosWorker {
     static setInstance(worker) {
         ChronosWorker.instance = worker;
     }
-    /** Register a function that will deliver Oracle responses to users (e.g. Telegram). */
-    static setNotifyFn(fn) {
-        ChronosWorker.notifyFn = fn;
-    }
     start() {
         if (this.timer)
             return;
@@ -93,11 +89,13 @@ export class ChronosWorker {
             // This avoids persisting an AIMessage with the marker in conversation history,
             // which would cause the LLM to reproduce the format in future scheduling responses.
             const promptWithContext = `[CHRONOS EXECUTION — job_id: ${job.id}]\n${job.prompt}`;
-            // If a Telegram notify function is registered, tag delegated tasks with
-            // origin_channel: 'telegram' so the TaskDispatcher broadcasts their result.
-            const taskContext = ChronosWorker.notifyFn
-                ? { origin_channel: 'telegram', session_id: activeSessionId }
-                : undefined;
+            // Determine which channel to tag delegated tasks with.
+            // Single notify_channel → use it so TaskDispatcher routes back correctly.
+            // Multiple or empty → 'chronos' means broadcast to all registered adapters.
+            const taskOriginChannel = job.notify_channels.length === 1
+                ? job.notify_channels[0]
+                : 'chronos';
+            const taskContext = { origin_channel: taskOriginChannel, session_id: activeSessionId };
             // Hard-block Chronos management tools during execution.
             ChronosWorker.isExecuting = true;
             const response = await this.oracle.chat(promptWithContext, undefined, false, taskContext);
@@ -126,15 +124,26 @@ export class ChronosWorker {
         }
     }
     async notify(job, response) {
-        if (!ChronosWorker.notifyFn)
+        if (ChannelRegistry.getAll().length === 0)
             return;
-        const display = DisplayManager.getInstance();
         const header = `⏰ *Chronos* — _${job.prompt.slice(0, 80)}${job.prompt.length > 80 ? '…' : ''}_\n\n`;
-        try {
-            await ChronosWorker.notifyFn(header + response);
+        const text = header + response;
+        if (job.notify_channels.length === 0) {
+            // No specific channels → broadcast to all registered adapters
+            await ChannelRegistry.broadcast(text);
         }
-        catch (err) {
-            display.log(`Job ${job.id} notification failed — ${err.message}`, { source: 'Chronos', level: 'error' });
+        else {
+            for (const ch of job.notify_channels) {
+                const adapter = ChannelRegistry.get(ch);
+                if (adapter) {
+                    await adapter.sendMessage(text).catch((err) => {
+                        DisplayManager.getInstance().log(`Job ${job.id} notification failed on channel "${ch}": ${err.message}`, { source: 'Chronos', level: 'error' });
+                    });
+                }
+                else {
+                    DisplayManager.getInstance().log(`Job ${job.id}: no adapter registered for channel "${ch}" — notification skipped.`, { source: 'Chronos', level: 'warning' });
+                }
+            }
         }
     }
 }

package/dist/runtime/chronos/worker.test.js

@@ -29,6 +29,7 @@ function makeJob(overrides = {}) {
         created_at: Date.now() - 5000,
         updated_at: Date.now() - 5000,
         created_by: 'ui',
+        notify_channels: [],
         ...overrides,
     };
 }

package/dist/runtime/oracle.js

@@ -212,6 +212,17 @@ Rules:
 10. After enqueuing all required delegated tasks for the current message, stop calling tools and return a concise acknowledgement.
 11. If a delegation is rejected as "not atomic", immediately split into smaller delegations and retry.
 
+## Chronos Channel Routing
+When calling chronos_schedule, set notify_channels based on the user's message:
+- User mentions a specific channel (e.g., "no Discord", "no Telegram", "on Discord", "me avise pelo Discord"): set notify_channels to that channel — e.g. ["discord"] or ["telegram"].
+- User says "all channels", "todos os canais", "em todos os canais": set notify_channels to [] (empty = broadcast to all active channels).
+- User does NOT mention any channel: omit notify_channels entirely (auto-detect uses the current conversation channel).
+
+Examples:
+- "me lembre daqui 5 minutos pelo Discord" → notify_channels: ["discord"]
+- "lembre em todos os canais" → notify_channels: []
+- "lembre em 1 hora" (sem canal) → omit notify_channels
+
 ## Chronos Scheduled Execution
 When the current user message starts with [CHRONOS EXECUTION], it means a Chronos scheduled job has just fired. The content after the prefix is the **job's saved prompt**, not a new live request from the user.
 

package/dist/runtime/tasks/dispatcher.js

@@ -2,12 +2,9 @@ import { DisplayManager } from '../display.js';
 import { WebhookRepository } from '../webhooks/repository.js';
 import { AIMessage } from '@langchain/core/messages';
 import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
+import { ChannelRegistry } from '../../channels/registry.js';
 export class TaskDispatcher {
-    static telegramAdapter = null;
     static display = DisplayManager.getInstance();
-    static setTelegramAdapter(adapter) {
-        TaskDispatcher.telegramAdapter = adapter;
-    }
     static async notifyTaskResult(task) {
         if (task.origin_channel === 'webhook') {
             if (!task.origin_message_id) {
@@ -19,25 +16,25 @@ export class TaskDispatcher {
                 ? (task.output && task.output.trim().length > 0 ? task.output : 'Task completed without output.')
                 : (task.error && task.error.trim().length > 0 ? task.error : 'Task failed with unknown error.');
             repo.updateNotificationResult(task.origin_message_id, status, result);
-            // Send Telegram notification if the webhook has 'telegram' in notification_channels
+            // Notify channels configured on the webhook
             const notification = repo.getNotificationById(task.origin_message_id);
             if (notification) {
                 const webhook = repo.getWebhookById(notification.webhook_id);
-                if (webhook?.notification_channels.includes('telegram')) {
-                    const adapter = TaskDispatcher.telegramAdapter;
-                    if (adapter) {
-                        try {
-                            const icon = status === 'completed' ? '✅' : '❌';
-                            const truncated = result.length > 3500 ? result.slice(0, 3500) + '…' : result;
-                            await adapter.sendMessage(`${icon} Webhook: ${webhook.name}\n\n${truncated}`);
+                if (webhook) {
+                    const icon = status === 'completed' ? '✅' : '❌';
+                    const truncated = result.length > 3500 ? result.slice(0, 3500) + '…' : result;
+                    const message = `${icon} Webhook: ${webhook.name}\n\n${truncated}`;
+                    for (const ch of webhook.notification_channels) {
+                        const adapter = ChannelRegistry.get(ch);
+                        if (adapter) {
+                            await adapter.sendMessage(message).catch((err) => {
+                                TaskDispatcher.display.log(`Failed to send notification via ${ch} for webhook "${webhook.name}": ${err.message}`, { source: 'TaskDispatcher', level: 'error' });
+                            });
                         }
-                        catch (err) {
-                            TaskDispatcher.display.log(`Failed to send Telegram notification for webhook "${webhook.name}": ${err.message}`, { source: 'TaskDispatcher', level: 'error' });
+                        else {
+                            TaskDispatcher.display.log(`Notification skipped for channel "${ch}" — adapter not registered.`, { source: 'TaskDispatcher', level: 'warning' });
                         }
                     }
-                    else {
-                        TaskDispatcher.display.log(`Telegram notification skipped for webhook "${webhook.name}" — adapter not connected.`, { source: 'TaskDispatcher', level: 'warning' });
-                    }
                 }
             }
             return;
@@ -65,13 +62,21 @@ export class TaskDispatcher {
             }
             return;
         }
-        if (task.origin_channel !== 'telegram') {
+        // 'chronos' origin — broadcast to all registered channels
+        if (task.origin_channel === 'chronos') {
+            const statusIcon = task.status === 'completed' ? '✅' : task.status === 'cancelled' ? '🚫' : '❌';
+            const body = task.status === 'completed'
+                ? (task.output && task.output.trim().length > 0 ? task.output : 'Task completed without output.')
+                : task.status === 'cancelled'
+                    ? 'Task was cancelled.'
+                    : (task.error && task.error.trim().length > 0 ? task.error : 'Task failed with unknown error.');
+            const message = `${statusIcon} Task \`${task.id.toUpperCase()}\`\n` +
+                `Agent: \`${task.agent.toUpperCase()}\`\n` +
+                `Status: \`${task.status.toUpperCase()}\`\n\n${body}`;
+            await ChannelRegistry.broadcast(message);
             return;
         }
-        const adapter = TaskDispatcher.telegramAdapter;
-        if (!adapter) {
-            throw new Error('Telegram adapter not connected');
-        }
+        // Channel-specific routing (telegram, discord, etc.)
         const statusIcon = task.status === 'completed' ? '✅' : task.status === 'cancelled' ? '🚫' : '❌';
         const body = task.status === 'completed'
             ? (task.output && task.output.trim().length > 0 ? task.output : 'Task completed without output.')
@@ -83,10 +88,15 @@ export class TaskDispatcher {
             `Status: \`${task.status.toUpperCase()}\``;
         const message = `${header}\n\n${body}`;
         if (task.origin_user_id) {
-            await adapter.sendMessageToUser(task.origin_user_id, message);
+            await ChannelRegistry.sendToUser(task.origin_channel, task.origin_user_id, message);
+            return;
+        }
+        // No specific user — broadcast on the originating channel
+        const adapter = ChannelRegistry.get(task.origin_channel);
+        if (!adapter) {
+            TaskDispatcher.display.log(`Task ${task.id}: no adapter for channel "${task.origin_channel}" — notification skipped.`, { source: 'TaskDispatcher', level: 'warning' });
             return;
         }
-        TaskDispatcher.display.log(`Task ${task.id} has telegram origin but no origin_user_id; broadcasting to allowed users.`, { source: 'TaskDispatcher', level: 'warning' });
         await adapter.sendMessage(message);
     }
     static async onTaskFinished(task) {

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

@@ -4,8 +4,11 @@ import { ChronosRepository } from '../chronos/repository.js';
 import { parseScheduleExpression, getNextOccurrences } from '../chronos/parser.js';
 import { ConfigManager } from '../../config/manager.js';
 import { ChronosWorker } from '../chronos/worker.js';
+import { TaskRequestContext } from '../tasks/context.js';
 // ─── chronos_schedule ────────────────────────────────────────────────────────
-export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule_expression, timezone }) => {
+// Channels that can be used as notify_channels on Chronos jobs
+const NON_CHANNEL_ORIGINS = new Set(['ui', 'api', 'cli', 'chronos', 'webhook']);
+export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule_expression, timezone, notify_channels }) => {
     if (ChronosWorker.isExecuting) {
         return JSON.stringify({ success: false, error: 'Cannot create a new Chronos job from within an active Chronos execution.' });
     }
@@ -13,6 +16,20 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
         const cfg = ConfigManager.getInstance().getChronosConfig();
         const tz = timezone ?? cfg.timezone;
         const parsed = parseScheduleExpression(schedule_expression, schedule_type, { timezone: tz });
+        // Resolve notify_channels:
+        // - Explicitly provided → use as-is
+        // - Not provided → auto-detect from current conversation origin channel
+        // - If origin channel is not a real user-facing channel (ui/api/cli) → empty = broadcast all
+        let channels;
+        if (notify_channels !== undefined) {
+            channels = notify_channels;
+        }
+        else {
+            const originChannel = TaskRequestContext.get()?.origin_channel;
+            channels = originChannel && !NON_CHANNEL_ORIGINS.has(originChannel)
+                ? [originChannel]
+                : [];
+        }
         const repo = ChronosRepository.getInstance();
         const job = repo.createJob({
             prompt,
@@ -22,6 +39,7 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
             next_run_at: parsed.next_run_at,
             cron_normalized: parsed.cron_normalized,
             created_by: 'oracle',
+            notify_channels: channels,
         });
         return JSON.stringify({
             success: true,
@@ -31,6 +49,7 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
             human_readable: parsed.human_readable,
             next_run_at: job.next_run_at != null ? new Date(job.next_run_at).toISOString() : null,
             timezone: job.timezone,
+            notify_channels: job.notify_channels,
         });
     }
     catch (err) {
@@ -42,7 +61,9 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
         'Use schedule_type "once" for a single execution (e.g. "tomorrow at 9am", "in 2 hours", "2026-03-01T09:00:00"), ' +
         '"cron" for a recurring cron expression (e.g. "0 9 * * 1-5" = every weekday at 9am), ' +
         '"interval" for natural interval phrases (e.g. "every 30 minutes", "every 2 hours", "every day"). ' +
-        'Returns the created job ID and the human-readable schedule confirmation.',
+        'Returns the created job ID and the human-readable schedule confirmation. ' +
+        'Use notify_channels to control where the result is delivered: omit to auto-detect from current channel, ' +
+        'pass ["discord"] or ["telegram"] for a specific channel, or [] for all active channels.',
     schema: z.object({
         prompt: z.string().describe('The prompt text to send to Oracle at the scheduled time.'),
         schedule_type: z
@@ -57,6 +78,13 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
             .string()
             .optional()
             .describe('IANA timezone (e.g. "America/Sao_Paulo"). Defaults to the global Chronos timezone config.'),
+        notify_channels: z
+            .array(z.string())
+            .optional()
+            .describe('Channels to notify when this job fires. ' +
+            'Omit to auto-use the current conversation channel. ' +
+            'Pass [] to broadcast to all active channels. ' +
+            'Pass ["discord"], ["telegram"], or ["discord","telegram"] for specific channels.'),
     }),
 });
 // ─── chronos_list ────────────────────────────────────────────────────────────

package/dist/runtime/webhooks/dispatcher.js

@@ -1,18 +1,11 @@
 import { WebhookRepository } from './repository.js';
 import { TaskRepository } from '../tasks/repository.js';
 import { DisplayManager } from '../display.js';
+import { ChannelRegistry } from '../../channels/registry.js';
 const STALE_NOTIFICATION_THRESHOLD_MS = 2 * 60 * 1000; // 2 minutes
 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.).
@@ -54,18 +47,14 @@ export class WebhookDispatcher {
             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');
-                }
+                await this.notifyChannels(webhook, 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');
-            }
+            await this.notifyChannels(webhook, result, 'failed');
         }
     }
     /**
@@ -140,23 +129,23 @@ Analyze the payload above and follow the instructions provided. Be concise and a
         }
     }
     /**
-     * Sends a formatted Telegram message to all allowed users.
-     * Silently skips if the adapter is not connected.
+     * Sends a notification to all channels configured on the webhook.
+     * Uses ChannelRegistry — no adapter references needed here.
      */
-    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' });
+    async notifyChannels(webhook, result, status) {
+        const icon = status === 'completed' ? '✅' : '❌';
+        const truncated = result.length > 3500 ? result.slice(0, 3500) + '…' : result;
+        const message = `${icon} Webhook: ${webhook.name}\n\n${truncated}`;
+        for (const ch of webhook.notification_channels) {
+            const adapter = ChannelRegistry.get(ch);
+            if (adapter) {
+                await adapter.sendMessage(message).catch((err) => {
+                    this.display.log(`Failed to send notification via "${ch}" for webhook "${webhook.name}": ${err.message}`, { source: 'Webhooks', level: 'error' });
+                });
+            }
+            else {
+                this.display.log(`Notification skipped for channel "${ch}" — adapter not registered.`, { source: 'Webhooks', level: 'warning' });
+            }
         }
     }
 }

package/dist/types/config.js

@@ -31,7 +31,7 @@ export const DEFAULT_CONFIG = {
     },
     channels: {
         telegram: { enabled: false, allowedUsers: [] },
-        discord: { enabled: false },
+        discord: { enabled: false, allowedUsers: [] },
     },
     ui: {
         enabled: true,