disunday 1.0.0

package/dist/openai-realtime.js

@@ -0,0 +1,226 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* istanbul ignore file */
+// @ts-nocheck
+import { RealtimeClient } from '@openai/realtime-api-beta';
+import { writeFile } from 'fs';
+import { createLogger, LogPrefix } from './logger.js';
+const openaiLogger = createLogger(LogPrefix.OPENAI);
+const audioParts = [];
+function saveBinaryFile(fileName, content) {
+    writeFile(fileName, content, 'utf8', (err) => {
+        if (err) {
+            openaiLogger.error(`Error writing file ${fileName}:`, err);
+            return;
+        }
+        openaiLogger.log(`Appending stream content to file ${fileName}.`);
+    });
+}
+function convertToWav(rawData, mimeType) {
+    const options = parseMimeType(mimeType);
+    const dataLength = rawData.reduce((a, b) => a + b.length, 0);
+    const wavHeader = createWavHeader(dataLength, options);
+    const buffer = Buffer.concat(rawData);
+    return Buffer.concat([wavHeader, buffer]);
+}
+function parseMimeType(mimeType) {
+    const [fileType, ...params] = mimeType.split(';').map((s) => s.trim());
+    const [_, format] = fileType?.split('/') || [];
+    const options = {
+        numChannels: 1,
+        bitsPerSample: 16,
+    };
+    if (format && format.startsWith('L')) {
+        const bits = parseInt(format.slice(1), 10);
+        if (!isNaN(bits)) {
+            options.bitsPerSample = bits;
+        }
+    }
+    for (const param of params) {
+        const [key, value] = param.split('=').map((s) => s.trim());
+        if (key === 'rate') {
+            options.sampleRate = parseInt(value || '', 10);
+        }
+    }
+    return options;
+}
+function createWavHeader(dataLength, options) {
+    const { numChannels, sampleRate, bitsPerSample } = options;
+    // http://soundfile.sapp.org/doc/WaveFormat
+    const byteRate = (sampleRate * numChannels * bitsPerSample) / 8;
+    const blockAlign = (numChannels * bitsPerSample) / 8;
+    const buffer = Buffer.alloc(44);
+    buffer.write('RIFF', 0); // ChunkID
+    buffer.writeUInt32LE(36 + dataLength, 4); // ChunkSize
+    buffer.write('WAVE', 8); // Format
+    buffer.write('fmt ', 12); // Subchunk1ID
+    buffer.writeUInt32LE(16, 16); // Subchunk1Size (PCM)
+    buffer.writeUInt16LE(1, 20); // AudioFormat (1 = PCM)
+    buffer.writeUInt16LE(numChannels, 22); // NumChannels
+    buffer.writeUInt32LE(sampleRate, 24); // SampleRate
+    buffer.writeUInt32LE(byteRate, 28); // ByteRate
+    buffer.writeUInt16LE(blockAlign, 32); // BlockAlign
+    buffer.writeUInt16LE(bitsPerSample, 34); // BitsPerSample
+    buffer.write('data', 36); // Subchunk2ID
+    buffer.writeUInt32LE(dataLength, 40); // Subchunk2Size
+    return buffer;
+}
+function defaultAudioChunkHandler({ data, mimeType }) {
+    audioParts.push(data);
+    const fileName = 'audio.wav';
+    const buffer = convertToWav(audioParts, mimeType);
+    saveBinaryFile(fileName, buffer);
+}
+export async function startGenAiSession({ onAssistantAudioChunk, onAssistantStartSpeaking, onAssistantStopSpeaking, onAssistantInterruptSpeaking, systemMessage, tools, } = {}) {
+    if (!process.env.OPENAI_API_KEY) {
+        throw new Error('OPENAI_API_KEY environment variable is required');
+    }
+    const client = new RealtimeClient({
+        apiKey: process.env.OPENAI_API_KEY,
+    });
+    const audioChunkHandler = onAssistantAudioChunk || defaultAudioChunkHandler;
+    let isAssistantSpeaking = false;
+    // Configure session with 24kHz sample rate
+    client.updateSession({
+        instructions: systemMessage || '',
+        voice: 'alloy',
+        input_audio_format: 'pcm16',
+        output_audio_format: 'pcm16',
+        input_audio_transcription: { model: 'whisper-1' },
+        turn_detection: { type: 'server_vad' },
+        modalities: ['text', 'audio'],
+        temperature: 0.8,
+    });
+    // Add tools if provided
+    if (tools) {
+        for (const [name, tool] of Object.entries(tools)) {
+            // Convert AI SDK tool to OpenAI Realtime format
+            // The tool.inputSchema is a Zod schema, we need to convert it to JSON Schema
+            let parameters = {
+                type: 'object',
+                properties: {},
+                required: [],
+            };
+            // If the tool has a Zod schema, we can try to extract basic structure
+            // For now, we'll use a simple placeholder
+            if (tool.description?.includes('session')) {
+                parameters = {
+                    type: 'object',
+                    properties: {
+                        sessionId: { type: 'string', description: 'The session ID' },
+                        message: { type: 'string', description: 'The message text' },
+                    },
+                    required: ['sessionId'],
+                };
+            }
+            client.addTool({
+                type: 'function',
+                name,
+                description: tool.description || '',
+                parameters,
+            }, async (params) => {
+                try {
+                    if (!tool.execute || typeof tool.execute !== 'function') {
+                        return { error: 'Tool execute function not found' };
+                    }
+                    // Call the execute function with params
+                    // The Tool type from 'ai' expects (input, options) but we need to handle this safely
+                    const result = await tool.execute(params, {
+                        abortSignal: new AbortController().signal,
+                        toolCallId: '',
+                        messages: [],
+                    });
+                    return result;
+                }
+                catch (error) {
+                    openaiLogger.error(`Tool ${name} execution error:`, error);
+                    return { error: String(error) };
+                }
+            });
+        }
+    }
+    // Set up event handlers
+    client.on('conversation.item.created', ({ item }) => {
+        if ('role' in item && item.role === 'assistant' && item.type === 'message') {
+            // Check if this is the first audio content
+            const hasAudio = 'content' in item &&
+                Array.isArray(item.content) &&
+                item.content.some((c) => 'type' in c && c.type === 'audio');
+            if (hasAudio && !isAssistantSpeaking && onAssistantStartSpeaking) {
+                isAssistantSpeaking = true;
+                onAssistantStartSpeaking();
+            }
+        }
+    });
+    client.on('conversation.updated', ({ item, delta }) => {
+        // Handle audio chunks
+        if (delta?.audio && 'role' in item && item.role === 'assistant') {
+            if (!isAssistantSpeaking && onAssistantStartSpeaking) {
+                isAssistantSpeaking = true;
+                onAssistantStartSpeaking();
+            }
+            // OpenAI provides audio as Int16Array or base64
+            let audioBuffer;
+            if (delta.audio instanceof Int16Array) {
+                audioBuffer = Buffer.from(delta.audio.buffer);
+            }
+            else {
+                // Assume base64 string
+                audioBuffer = Buffer.from(delta.audio, 'base64');
+            }
+            // OpenAI uses 24kHz PCM16 format
+            audioChunkHandler({
+                data: audioBuffer,
+                mimeType: 'audio/pcm;rate=24000',
+            });
+        }
+        // Handle transcriptions
+        if (delta?.transcript) {
+            if ('role' in item) {
+                if (item.role === 'user') {
+                    openaiLogger.log('User transcription:', delta.transcript);
+                }
+                else if (item.role === 'assistant') {
+                    openaiLogger.log('Assistant transcription:', delta.transcript);
+                }
+            }
+        }
+    });
+    client.on('conversation.item.completed', ({ item }) => {
+        if ('role' in item &&
+            item.role === 'assistant' &&
+            isAssistantSpeaking &&
+            onAssistantStopSpeaking) {
+            isAssistantSpeaking = false;
+            onAssistantStopSpeaking();
+        }
+    });
+    client.on('conversation.interrupted', () => {
+        openaiLogger.log('Assistant was interrupted');
+        if (isAssistantSpeaking && onAssistantInterruptSpeaking) {
+            isAssistantSpeaking = false;
+            onAssistantInterruptSpeaking();
+        }
+    });
+    // Connect to the Realtime API
+    await client.connect();
+    const sessionResult = {
+        session: {
+            send: (audioData) => {
+                // Convert ArrayBuffer to Int16Array for OpenAI
+                const int16Data = new Int16Array(audioData);
+                client.appendInputAudio(int16Data);
+            },
+            sendText: (text) => {
+                // Send text message to OpenAI
+                client.sendUserMessageContent([{ type: 'input_text', text }]);
+            },
+            close: () => {
+                client.disconnect();
+            },
+        },
+        stop: () => {
+            client.disconnect();
+        },
+    };
+    return sessionResult;
+}

package/dist/opencode.js

@@ -0,0 +1,224 @@
+// OpenCode server process manager.
+// Spawns and maintains OpenCode API servers per project directory,
+// handles automatic restarts on failure, and provides typed SDK clients.
+// Uses errore for type-safe error handling.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import { createOpencodeClient, } from '@opencode-ai/sdk';
+import { createOpencodeClient as createOpencodeClientV2, } from '@opencode-ai/sdk/v2';
+import * as errore from 'errore';
+import { createLogger, LogPrefix } from './logger.js';
+import { getBashWhitelist } from './config.js';
+import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
+const opencodeLogger = createLogger(LogPrefix.OPENCODE);
+const opencodeServers = new Map();
+const serverRetryCount = new Map();
+async function getOpenPort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, () => {
+            const address = server.address();
+            if (address && typeof address === 'object') {
+                const port = address.port;
+                server.close(() => {
+                    resolve(port);
+                });
+            }
+            else {
+                reject(new Error('Failed to get port'));
+            }
+        });
+        server.on('error', reject);
+    });
+}
+async function waitForServer(port, maxAttempts = 30) {
+    const endpoint = `http://127.0.0.1:${port}/api/health`;
+    for (let i = 0; i < maxAttempts; i++) {
+        const response = await errore.tryAsync({
+            try: () => fetch(endpoint),
+            catch: (e) => new FetchError({ url: endpoint, cause: e }),
+        });
+        if (response instanceof Error) {
+            // Connection refused or other transient errors - continue polling
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            continue;
+        }
+        if (response.status < 500) {
+            return true;
+        }
+        const body = await response.text();
+        // Fatal errors that won't resolve with retrying
+        if (body.includes('BunInstallFailedError')) {
+            return new ServerStartError({ port, reason: body.slice(0, 200) });
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    return new ServerStartError({
+        port,
+        reason: `Server did not start after ${maxAttempts} seconds`,
+    });
+}
+export async function initializeOpencodeForDirectory(directory) {
+    const existing = opencodeServers.get(directory);
+    if (existing && !existing.process.killed) {
+        opencodeLogger.log(`Reusing existing server on port ${existing.port} for directory: ${directory}`);
+        return () => {
+            const entry = opencodeServers.get(directory);
+            if (!entry?.client) {
+                throw new ServerNotReadyError({ directory });
+            }
+            return entry.client;
+        };
+    }
+    // Verify directory exists and is accessible before spawning
+    const accessCheck = errore.tryFn({
+        try: () => {
+            fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK);
+        },
+        catch: () => new DirectoryNotAccessibleError({ directory }),
+    });
+    if (accessCheck instanceof Error) {
+        return accessCheck;
+    }
+    const port = await getOpenPort();
+    const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
+    const serverProcess = spawn(opencodeCommand, ['serve', '--port', port.toString()], {
+        stdio: 'pipe',
+        detached: false,
+        cwd: directory,
+        env: {
+            ...process.env,
+            OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                $schema: 'https://opencode.ai/config.json',
+                lsp: false,
+                formatter: false,
+                permission: {
+                    edit: 'allow',
+                    bash: (() => {
+                        const whitelist = getBashWhitelist();
+                        if (whitelist.includes('*')) {
+                            return 'allow';
+                        }
+                        if (whitelist.length === 0) {
+                            return 'deny';
+                        }
+                        // Convert whitelist array to permission object: { cmd: 'allow', ... }
+                        return Object.fromEntries(whitelist.map((cmd) => {
+                            return [cmd, 'allow'];
+                        }));
+                    })(),
+                    webfetch: 'allow',
+                },
+            }),
+            OPENCODE_PORT: port.toString(),
+        },
+    });
+    // Buffer logs until we know if server started successfully
+    const logBuffer = [];
+    logBuffer.push(`Spawned opencode serve --port ${port} in ${directory} (pid: ${serverProcess.pid})`);
+    serverProcess.stdout?.on('data', (data) => {
+        logBuffer.push(`[stdout] ${data.toString().trim()}`);
+    });
+    serverProcess.stderr?.on('data', (data) => {
+        logBuffer.push(`[stderr] ${data.toString().trim()}`);
+    });
+    serverProcess.on('error', (error) => {
+        logBuffer.push(`Failed to start server on port ${port}: ${error}`);
+    });
+    serverProcess.on('exit', (code) => {
+        opencodeLogger.log(`Opencode server on ${directory} exited with code:`, code);
+        opencodeServers.delete(directory);
+        if (code !== 0) {
+            const retryCount = serverRetryCount.get(directory) || 0;
+            if (retryCount < 5) {
+                serverRetryCount.set(directory, retryCount + 1);
+                opencodeLogger.log(`Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`);
+                initializeOpencodeForDirectory(directory).then((result) => {
+                    if (result instanceof Error) {
+                        opencodeLogger.error(`Failed to restart opencode server:`, result);
+                    }
+                });
+            }
+            else {
+                opencodeLogger.error(`Server for ${directory} crashed too many times (5), not restarting`);
+            }
+        }
+        else {
+            serverRetryCount.delete(directory);
+        }
+    });
+    const waitResult = await waitForServer(port);
+    if (waitResult instanceof Error) {
+        // Dump buffered logs on failure
+        opencodeLogger.error(`Server failed to start for ${directory}:`);
+        for (const line of logBuffer) {
+            opencodeLogger.error(`  ${line}`);
+        }
+        return waitResult;
+    }
+    opencodeLogger.log(`Server ready on port ${port}`);
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const fetchWithTimeout = (request) => fetch(request, {
+        // @ts-ignore
+        timeout: false,
+    });
+    const client = createOpencodeClient({
+        baseUrl,
+        fetch: fetchWithTimeout,
+    });
+    const clientV2 = createOpencodeClientV2({
+        baseUrl,
+        fetch: fetchWithTimeout,
+    });
+    opencodeServers.set(directory, {
+        process: serverProcess,
+        client,
+        clientV2,
+        port,
+    });
+    return () => {
+        const entry = opencodeServers.get(directory);
+        if (!entry?.client) {
+            throw new ServerNotReadyError({ directory });
+        }
+        return entry.client;
+    };
+}
+export function getOpencodeServers() {
+    return opencodeServers;
+}
+export function getOpencodeServerPort(directory) {
+    const entry = opencodeServers.get(directory);
+    return entry?.port ?? null;
+}
+export function getOpencodeClientV2(directory) {
+    const entry = opencodeServers.get(directory);
+    return entry?.clientV2 ?? null;
+}
+/**
+ * Restart the opencode server for a directory.
+ * Kills the existing process and reinitializes a new one.
+ * Used for resolving opencode state issues, refreshing auth, plugins, etc.
+ */
+export async function restartOpencodeServer(directory) {
+    const existing = opencodeServers.get(directory);
+    if (existing) {
+        opencodeLogger.log(`Killing existing server for directory: ${directory} (pid: ${existing.process.pid})`);
+        // Reset retry count so the exit handler doesn't auto-restart
+        serverRetryCount.set(directory, 999);
+        existing.process.kill('SIGTERM');
+        opencodeServers.delete(directory);
+        // Give the process time to fully terminate
+        await new Promise((resolve) => {
+            setTimeout(resolve, 1000);
+        });
+    }
+    // Reset retry count for the fresh start
+    serverRetryCount.delete(directory);
+    const result = await initializeOpencodeForDirectory(directory);
+    if (result instanceof Error) {
+        return result;
+    }
+    return true;
+}

package/dist/reaction-handler.js

@@ -0,0 +1,128 @@
+import { Events, ChannelType, } from 'discord.js';
+import * as errore from 'errore';
+import { getDatabase } from './database.js';
+import { abortSession } from './session-handler.js';
+import { createLogger, LogPrefix } from './logger.js';
+import { hasRequiredPermissions, getDisundayMetadata, resolveTextChannel } from './discord-utils.js';
+const reactionLogger = createLogger(LogPrefix.REACTION);
+const REACTION_COMMANDS = {
+    '🔄': 'retry',
+    '❌': 'abort',
+    '📌': 'pin',
+};
+export function registerReactionHandler({ discordClient, appId, }) {
+    discordClient.on(Events.MessageReactionAdd, async (reaction, user) => {
+        try {
+            if (user.bot) {
+                return;
+            }
+            if (reaction.partial) {
+                const fetched = await errore.tryAsync(() => reaction.fetch());
+                if (fetched instanceof Error) {
+                    return;
+                }
+                reaction = fetched;
+            }
+            const emoji = reaction.emoji.name;
+            if (!emoji || !(emoji in REACTION_COMMANDS)) {
+                return;
+            }
+            const command = REACTION_COMMANDS[emoji];
+            const message = reaction.message;
+            if (message.partial) {
+                const fetched = await errore.tryAsync(() => message.fetch());
+                if (fetched instanceof Error) {
+                    return;
+                }
+            }
+            const channel = message.channel;
+            const isThread = [
+                ChannelType.PublicThread,
+                ChannelType.PrivateThread,
+                ChannelType.AnnouncementThread,
+            ].includes(channel.type);
+            if (!isThread) {
+                return;
+            }
+            const thread = channel;
+            const member = await errore.tryAsync(() => thread.guild.members.fetch(user.id));
+            if (member instanceof Error) {
+                return;
+            }
+            const hasPerms = hasRequiredPermissions(member, thread.guild);
+            if (!hasPerms) {
+                return;
+            }
+            reactionLogger.log(`[REACTION] ${command} triggered by ${user.username} in thread ${thread.id}`);
+            switch (command) {
+                case 'abort':
+                    await handleAbortReaction(thread, appId);
+                    break;
+                case 'retry':
+                    await handleRetryReaction(thread, message, appId);
+                    break;
+                case 'pin':
+                    await handlePinReaction(message);
+                    break;
+            }
+            await reaction.users.remove(user.id).catch(() => { });
+        }
+        catch (error) {
+            reactionLogger.error('[REACTION] Error handling reaction:', error);
+        }
+    });
+    reactionLogger.log('[REACTION] Handler registered');
+}
+async function handleAbortReaction(thread, appId) {
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(thread.id);
+    if (!row?.session_id) {
+        return;
+    }
+    const aborted = abortSession(row.session_id);
+    if (aborted) {
+        await thread.send('⏹️ Session aborted via reaction');
+        reactionLogger.log(`[REACTION] Aborted session ${row.session_id}`);
+    }
+}
+async function handleRetryReaction(thread, message, appId) {
+    const textChannel = await resolveTextChannel(thread);
+    const { projectDirectory } = getDisundayMetadata(textChannel);
+    if (!projectDirectory) {
+        return;
+    }
+    const row = getDatabase()
+        .prepare(`SELECT session_id FROM thread_sessions WHERE thread_id = ?`)
+        .get(thread.id);
+    if (!row?.session_id) {
+        return;
+    }
+    const lastUserMessage = await findLastUserMessage(thread);
+    if (!lastUserMessage) {
+        await thread.send('❌ No previous message to retry');
+        return;
+    }
+    const { handleOpencodeSession } = await import('./session-handler.js');
+    await thread.send(`🔄 Retrying: "${lastUserMessage.slice(0, 50)}${lastUserMessage.length > 50 ? '...' : ''}"`);
+    await handleOpencodeSession({
+        prompt: lastUserMessage,
+        thread,
+        projectDirectory,
+    });
+}
+async function handlePinReaction(message) {
+    const pinResult = await errore.tryAsync(() => message.pin());
+    if (pinResult instanceof Error) {
+        reactionLogger.log(`[REACTION] Could not pin message: ${pinResult.message}`);
+    }
+    else {
+        reactionLogger.log(`[REACTION] Pinned message ${message.id}`);
+    }
+}
+async function findLastUserMessage(thread) {
+    const messages = await thread.messages.fetch({ limit: 20 });
+    const userMessages = messages.filter((m) => !m.author.bot && m.content?.trim());
+    const lastUserMsg = userMessages.first();
+    return lastUserMsg?.content || null;
+}

package/dist/scheduler.js

@@ -0,0 +1,93 @@
+import { ChannelType } from 'discord.js';
+import * as errore from 'errore';
+import { getPendingSchedules, updateScheduleStatus, runScheduleMigrations, getChannelDirectory, } from './database.js';
+import { handleOpencodeSession } from './session-handler.js';
+import { sendThreadMessage, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
+import { createLogger, LogPrefix } from './logger.js';
+const schedulerLogger = createLogger(LogPrefix.SESSION);
+let schedulerInterval = null;
+export function startScheduler(client) {
+    runScheduleMigrations();
+    if (schedulerInterval) {
+        clearInterval(schedulerInterval);
+    }
+    schedulerInterval = setInterval(() => {
+        void processSchedules(client);
+    }, 10_000);
+    schedulerLogger.log('[SCHEDULER] Started (checking every 10s)');
+}
+export function stopScheduler() {
+    if (schedulerInterval) {
+        clearInterval(schedulerInterval);
+        schedulerInterval = null;
+        schedulerLogger.log('[SCHEDULER] Stopped');
+    }
+}
+async function processSchedules(client) {
+    const pendingSchedules = getPendingSchedules();
+    for (const schedule of pendingSchedules) {
+        schedulerLogger.log(`[SCHEDULER] Processing schedule #${schedule.id}`);
+        const result = await errore.tryAsync(async () => {
+            const targetChannelId = schedule.thread_id || schedule.channel_id;
+            const channel = await client.channels.fetch(targetChannelId);
+            if (!channel) {
+                throw new Error(`Channel ${targetChannelId} not found`);
+            }
+            const isThread = [
+                ChannelType.PublicThread,
+                ChannelType.PrivateThread,
+                ChannelType.AnnouncementThread,
+            ].includes(channel.type);
+            if (isThread) {
+                const thread = channel;
+                const parentId = thread.parentId;
+                if (!parentId) {
+                    throw new Error('Thread has no parent channel');
+                }
+                const channelConfig = getChannelDirectory(parentId);
+                if (!channelConfig?.directory) {
+                    throw new Error(`No project directory configured for channel ${parentId}`);
+                }
+                await sendThreadMessage(thread, `⏰ **Scheduled message** (from <@${schedule.created_by}>):\n${schedule.prompt}`);
+                await handleOpencodeSession({
+                    prompt: schedule.prompt,
+                    thread,
+                    projectDirectory: channelConfig.directory,
+                    channelId: parentId,
+                });
+            }
+            else if (channel.type === ChannelType.GuildText) {
+                const textChannel = channel;
+                const channelConfig = getChannelDirectory(textChannel.id);
+                if (!channelConfig?.directory) {
+                    throw new Error(`No project directory configured for channel ${textChannel.id}`);
+                }
+                const starterMessage = await textChannel.send({
+                    content: `⏰ **Scheduled** (from <@${schedule.created_by}>): ${schedule.prompt.slice(0, 100)}${schedule.prompt.length > 100 ? '...' : ''}`,
+                    flags: SILENT_MESSAGE_FLAGS,
+                });
+                const thread = await starterMessage.startThread({
+                    name: `Scheduled: ${schedule.prompt.slice(0, 50)}${schedule.prompt.length > 50 ? '...' : ''}`,
+                    autoArchiveDuration: 1440,
+                });
+                await handleOpencodeSession({
+                    prompt: schedule.prompt,
+                    thread,
+                    projectDirectory: channelConfig.directory,
+                    channelId: textChannel.id,
+                });
+            }
+            else {
+                throw new Error(`Unsupported channel type: ${channel.type}`);
+            }
+        });
+        if (result instanceof Error) {
+            schedulerLogger.error(`[SCHEDULER] Failed schedule #${schedule.id}:`, result);
+            updateScheduleStatus(schedule.id, 'failed', result.message);
+        }
+        else {
+            schedulerLogger.log(`[SCHEDULER] Completed schedule #${schedule.id}`);
+            updateScheduleStatus(schedule.id, 'completed');
+        }
+    }
+}