@brianli/kimaki 0.4.72-brianli.1

package/dist/forum-sync/watchers.js

@@ -0,0 +1,307 @@
+// Runtime state management, file watchers, and Discord event listeners.
+// Manages the lifecycle of forum sync: initial sync, live Discord event handling,
+// file system watcher for bidirectional sync, and debounced sync scheduling.
+import fs from 'node:fs';
+import parcelWatcher from '@parcel/watcher';
+import { ChannelType, Events, } from 'discord.js';
+import { createLogger } from '../logger.js';
+import { readForumSyncConfig } from './config.js';
+import { ensureDirectory, getCanonicalThreadFilePath, } from './discord-operations.js';
+import { syncForumToFiles } from './sync-to-files.js';
+import { syncFilesToForum } from './sync-to-discord.js';
+import { DEFAULT_DEBOUNCE_MS, ForumSyncOperationError, addIgnoredPath, shouldIgnorePath, } from './types.js';
+const forumLogger = createLogger('FORUM');
+// ═══════════════════════════════════════════════════════════════════════════
+// MODULE STATE
+// ═══════════════════════════════════════════════════════════════════════════
+const forumStateById = new Map();
+const watcherUnsubscribeByForumId = new Map();
+let discordListenersRegistered = false;
+// ═══════════════════════════════════════════════════════════════════════════
+// RUNTIME STATE
+// ═══════════════════════════════════════════════════════════════════════════
+function buildRuntimeState({ forumChannelId, outputDir, direction, }) {
+    return {
+        forumChannelId,
+        outputDir,
+        direction,
+        dirtyThreadIds: new Set(),
+        ignoredPaths: new Map(),
+        queuedFileEvents: new Map(),
+        discordDebounceTimer: null,
+        fileDebounceTimer: null,
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// FILE WATCHER EVENT HANDLING
+// ═══════════════════════════════════════════════════════════════════════════
+async function runQueuedFileEvents({ runtimeState, discordClient, }) {
+    const queuedEntries = Array.from(runtimeState.queuedFileEvents.entries());
+    runtimeState.queuedFileEvents.clear();
+    if (queuedEntries.length === 0)
+        return;
+    const changedFilePaths = queuedEntries
+        .filter(([, eventType]) => eventType === 'create' || eventType === 'update')
+        .map(([filePath]) => filePath);
+    const deletedFilePaths = queuedEntries
+        .filter(([, eventType]) => eventType === 'delete')
+        .map(([filePath]) => filePath);
+    const fileSyncResult = await syncFilesToForum({
+        discordClient,
+        forumChannelId: runtimeState.forumChannelId,
+        outputDir: runtimeState.outputDir,
+        runtimeState,
+        changedFilePaths,
+        deletedFilePaths,
+    });
+    if (fileSyncResult instanceof Error) {
+        forumLogger.warn(`FS -> Discord sync failed for ${runtimeState.forumChannelId}: ${fileSyncResult.message}`);
+        return;
+    }
+    if (fileSyncResult.created + fileSyncResult.updated + fileSyncResult.deleted >
+        0) {
+        forumLogger.log(`FS -> Discord ${runtimeState.forumChannelId}: +${fileSyncResult.created} ~${fileSyncResult.updated} -${fileSyncResult.deleted} (skip ${fileSyncResult.skipped})`);
+    }
+    // Refresh the FS mirror for any threads that were touched
+    const discordSyncResult = await syncForumToFiles({
+        discordClient,
+        forumChannelId: runtimeState.forumChannelId,
+        outputDir: runtimeState.outputDir,
+        runtimeState,
+        forceThreadIds: runtimeState.dirtyThreadIds,
+    });
+    if (discordSyncResult instanceof Error) {
+        forumLogger.warn(`Discord -> FS refresh failed for ${runtimeState.forumChannelId}: ${discordSyncResult.message}`);
+        return;
+    }
+    runtimeState.dirtyThreadIds.clear();
+}
+function queueFileEvent({ runtimeState, filePath, eventType, discordClient, }) {
+    if (shouldIgnorePath({ runtimeState, filePath }))
+        return;
+    runtimeState.queuedFileEvents.set(filePath, eventType);
+    if (runtimeState.fileDebounceTimer) {
+        clearTimeout(runtimeState.fileDebounceTimer);
+    }
+    runtimeState.fileDebounceTimer = setTimeout(() => {
+        runtimeState.fileDebounceTimer = null;
+        void runQueuedFileEvents({ runtimeState, discordClient });
+    }, DEFAULT_DEBOUNCE_MS);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// DISCORD EVENT HANDLING
+// ═══════════════════════════════════════════════════════════════════════════
+function scheduleDiscordSync({ runtimeState, threadId, discordClient, }) {
+    runtimeState.dirtyThreadIds.add(threadId);
+    if (runtimeState.discordDebounceTimer) {
+        clearTimeout(runtimeState.discordDebounceTimer);
+    }
+    runtimeState.discordDebounceTimer = setTimeout(() => {
+        runtimeState.discordDebounceTimer = null;
+        void (async () => {
+            const syncResult = await syncForumToFiles({
+                discordClient,
+                forumChannelId: runtimeState.forumChannelId,
+                outputDir: runtimeState.outputDir,
+                runtimeState,
+                forceThreadIds: runtimeState.dirtyThreadIds,
+            });
+            if (syncResult instanceof Error) {
+                forumLogger.warn(`Debounced Discord -> FS sync failed for ${runtimeState.forumChannelId}: ${syncResult.message}`);
+                return;
+            }
+            runtimeState.dirtyThreadIds.clear();
+        })();
+    }, DEFAULT_DEBOUNCE_MS);
+}
+function getThreadEventData({ channel, }) {
+    if (!channel)
+        return null;
+    if (channel.type !== ChannelType.PublicThread &&
+        channel.type !== ChannelType.PrivateThread &&
+        channel.type !== ChannelType.AnnouncementThread) {
+        return null;
+    }
+    if (!channel.parentId)
+        return null;
+    return { forumChannelId: channel.parentId, threadId: channel.id };
+}
+function getEventThreadFromMessage({ message, }) {
+    const channel = message.channel;
+    if (!channel || !channel.isThread())
+        return null;
+    return channel;
+}
+function tryHandleThreadEvent({ channel, discordClient, }) {
+    const data = getThreadEventData({ channel });
+    if (!data)
+        return;
+    const runtimeState = forumStateById.get(data.forumChannelId);
+    if (!runtimeState)
+        return;
+    scheduleDiscordSync({ runtimeState, threadId: data.threadId, discordClient });
+}
+/**
+ * Find the file path for a thread, checking root and one level of subdirectories.
+ */
+function findThreadFilePath({ outputDir, threadId, }) {
+    const rootPath = getCanonicalThreadFilePath({ outputDir, threadId });
+    if (fs.existsSync(rootPath))
+        return rootPath;
+    const dirEntries = (() => {
+        try {
+            return fs.readdirSync(outputDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+    })();
+    for (const entry of dirEntries) {
+        if (!entry.isDirectory())
+            continue;
+        const subPath = getCanonicalThreadFilePath({
+            outputDir,
+            threadId,
+            subfolder: entry.name,
+        });
+        if (fs.existsSync(subPath))
+            return subPath;
+    }
+    return null;
+}
+function registerDiscordSyncListeners({ discordClient, }) {
+    if (discordListenersRegistered)
+        return;
+    discordListenersRegistered = true;
+    discordClient.on(Events.MessageCreate, (message) => {
+        if (message.author?.bot)
+            return;
+        const thread = getEventThreadFromMessage({ message });
+        tryHandleThreadEvent({ channel: thread, discordClient });
+    });
+    discordClient.on(Events.MessageUpdate, (_oldMessage, newMessage) => {
+        const thread = getEventThreadFromMessage({ message: newMessage });
+        tryHandleThreadEvent({ channel: thread, discordClient });
+    });
+    discordClient.on(Events.ThreadUpdate, (_oldThread, newThread) => {
+        tryHandleThreadEvent({ channel: newThread, discordClient });
+    });
+    discordClient.on(Events.ThreadDelete, async (thread) => {
+        const data = getThreadEventData({ channel: thread });
+        if (!data)
+            return;
+        const runtimeState = forumStateById.get(data.forumChannelId);
+        if (!runtimeState)
+            return;
+        const targetPath = findThreadFilePath({
+            outputDir: runtimeState.outputDir,
+            threadId: data.threadId,
+        });
+        if (!targetPath)
+            return;
+        addIgnoredPath({ runtimeState, filePath: targetPath });
+        await fs.promises.unlink(targetPath).catch((cause) => {
+            forumLogger.warn(`Failed to delete forum file on thread delete ${targetPath}:`, cause);
+        });
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// FILE WATCHER SETUP
+// ═══════════════════════════════════════════════════════════════════════════
+async function startWatcherForRuntimeState({ runtimeState, discordClient, }) {
+    if (runtimeState.direction !== 'bidirectional')
+        return;
+    const subscription = await parcelWatcher
+        .subscribe(runtimeState.outputDir, (_error, events) => {
+        const mdEvents = events.filter((event) => event.path.endsWith('.md'));
+        mdEvents
+            .filter((event) => event.type === 'create' ||
+            event.type === 'update' ||
+            event.type === 'delete')
+            .map((event) => {
+            queueFileEvent({
+                runtimeState,
+                filePath: event.path,
+                eventType: event.type,
+                discordClient,
+            });
+        });
+    })
+        .catch((cause) => new ForumSyncOperationError({
+        forumChannelId: runtimeState.forumChannelId,
+        reason: `failed to subscribe watcher for ${runtimeState.outputDir}`,
+        cause,
+    }));
+    if (subscription instanceof Error)
+        return subscription;
+    watcherUnsubscribeByForumId.set(runtimeState.forumChannelId, () => {
+        return subscription.unsubscribe();
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// PUBLIC API
+// ═══════════════════════════════════════════════════════════════════════════
+export async function stopConfiguredForumSync() {
+    const unsubscribers = Array.from(watcherUnsubscribeByForumId.values());
+    watcherUnsubscribeByForumId.clear();
+    forumStateById.clear();
+    await Promise.all(unsubscribers.map(async (unsubscribe) => {
+        await unsubscribe().catch((cause) => {
+            forumLogger.warn('Failed to unsubscribe forum watcher:', cause);
+        });
+    }));
+}
+export async function startConfiguredForumSync({ discordClient, appId, }) {
+    const loadedConfig = await readForumSyncConfig({ appId });
+    if (loadedConfig instanceof Error)
+        return loadedConfig;
+    if (loadedConfig.length === 0)
+        return;
+    registerDiscordSyncListeners({ discordClient });
+    // Process each config independently so one stale/deleted forum channel
+    // doesn't block the watcher from starting for other valid configs.
+    for (const entry of loadedConfig) {
+        const runtimeState = buildRuntimeState({
+            forumChannelId: entry.forumChannelId,
+            outputDir: entry.outputDir,
+            direction: entry.direction,
+        });
+        forumStateById.set(entry.forumChannelId, runtimeState);
+        const ensureResult = await ensureDirectory({ directory: entry.outputDir });
+        if (ensureResult instanceof Error) {
+            forumLogger.warn(`Skipping forum ${entry.forumChannelId}: failed to create ${entry.outputDir}`);
+            continue;
+        }
+        const fileToDiscordResult = await syncFilesToForum({
+            discordClient,
+            forumChannelId: entry.forumChannelId,
+            outputDir: entry.outputDir,
+            runtimeState,
+        });
+        if (fileToDiscordResult instanceof Error) {
+            forumLogger.warn(`Skipping forum ${entry.forumChannelId}: FS->Discord sync failed: ${fileToDiscordResult.message}`);
+            continue;
+        }
+        const discordToFileResult = await syncForumToFiles({
+            discordClient,
+            forumChannelId: entry.forumChannelId,
+            outputDir: entry.outputDir,
+            forceFullRefresh: true,
+            runtimeState,
+        });
+        if (discordToFileResult instanceof Error) {
+            forumLogger.warn(`Skipping forum ${entry.forumChannelId}: Discord->FS sync failed: ${discordToFileResult.message}`);
+            continue;
+        }
+        const watcherResult = await startWatcherForRuntimeState({
+            runtimeState,
+            discordClient,
+        });
+        if (watcherResult instanceof Error) {
+            forumLogger.warn(`Skipping forum ${entry.forumChannelId}: watcher failed: ${watcherResult.message}`);
+            continue;
+        }
+        forumLogger.log(`Forum sync started for ${entry.forumChannelId} (${entry.direction}) -> ${entry.outputDir}`);
+        forumLogger.log(`Initial sync: Discord->FS synced ${discordToFileResult.synced}, skipped ${discordToFileResult.skipped}, deleted ${discordToFileResult.deleted}; FS->Discord created ${fileToDiscordResult.created}, updated ${fileToDiscordResult.updated}, deleted ${fileToDiscordResult.deleted}`);
+    }
+}

package/dist/gateway-consumer.js

@@ -0,0 +1,232 @@
+import { WebSocket } from 'undici';
+import { getDiscordWsUrl, resolveDiscordAuthHeader, } from './discord-auth.js';
+import { createLogger, LogPrefix } from './logger.js';
+import { notifyError } from './sentry.js';
+const gatewayLogger = createLogger(LogPrefix.CLI);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function parseGatewayStreamMessage(parsed) {
+    if (!isRecord(parsed) || typeof parsed.type !== 'string') {
+        return null;
+    }
+    if (parsed.type === 'connected' &&
+        typeof parsed.guild_id === 'string' &&
+        typeof parsed.machine_id === 'string' &&
+        typeof parsed.connected_at === 'string') {
+        return {
+            type: 'connected',
+            guild_id: parsed.guild_id,
+            machine_id: parsed.machine_id,
+            connected_at: parsed.connected_at,
+        };
+    }
+    if (parsed.type === 'discord_event' &&
+        typeof parsed.guild_id === 'string' &&
+        typeof parsed.op === 'number') {
+        return {
+            type: 'discord_event',
+            guild_id: parsed.guild_id,
+            op: parsed.op,
+            t: typeof parsed.t === 'string' ? parsed.t : undefined,
+            s: typeof parsed.s === 'number' ? parsed.s : undefined,
+            d: parsed.d,
+        };
+    }
+    return null;
+}
+async function decodeWebSocketData(data) {
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data).toString('utf8');
+    }
+    if (ArrayBuffer.isView(data)) {
+        return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString('utf8');
+    }
+    if (isRecord(data) && typeof data.arrayBuffer === 'function') {
+        try {
+            const arrayBuffer = (await data.arrayBuffer());
+            return Buffer.from(arrayBuffer).toString('utf8');
+        }
+        catch (error) {
+            return new Error('Failed to decode websocket message body', {
+                cause: error,
+            });
+        }
+    }
+    return new Error('Unsupported websocket message payload type');
+}
+export function buildGatewayMachineWebSocketUrl(rawWsUrl) {
+    const parsed = new URL(rawWsUrl);
+    if (parsed.protocol !== 'ws:' &&
+        parsed.protocol !== 'wss:') {
+        throw new Error(`KIMAKI_DISCORD_WS_URL must use ws:// or wss://, got ${parsed.protocol}`);
+    }
+    const path = parsed.pathname.replace(/\/+$/, '');
+    if (path === '/ws/machine') {
+        return parsed.toString();
+    }
+    if (path === '' || path === '/') {
+        parsed.pathname = '/ws/machine';
+        return parsed.toString();
+    }
+    throw new Error(`KIMAKI_DISCORD_WS_URL must point to /ws/machine (or base host), got ${parsed.pathname}`);
+}
+function bootstrapReadyState({ discordClient, appId, }) {
+    const wsManager = discordClient.ws;
+    const fakeShard = {
+        id: 0,
+        checkReady: () => {
+            if (!discordClient.isReady()) {
+                wsManager.triggerClientReady();
+            }
+        },
+    };
+    const readyPacket = {
+        op: 0,
+        t: 'READY',
+        s: 0,
+        d: {
+            v: 10,
+            user: {
+                id: appId,
+                username: 'kimaki',
+                discriminator: '0000',
+                avatar: null,
+                bot: true,
+                public_flags: 0,
+            },
+            guilds: [],
+            session_id: 'kimaki-auth-mode',
+            resume_gateway_url: 'wss://gateway.discord.gg',
+            application: {
+                id: appId,
+                flags: 0,
+            },
+        },
+    };
+    wsManager.handlePacket(readyPacket, fakeShard);
+}
+export function startGatewayAuthModeConsumer({ discordClient, guildId, appId, }) {
+    if (!process.env.KIMAKI_DISCORD_WS_URL) {
+        throw new Error('Auth mode requires KIMAKI_DISCORD_WS_URL pointing to the gateway machine websocket endpoint');
+    }
+    const authorization = resolveDiscordAuthHeader(undefined)?.value;
+    if (!authorization) {
+        throw new Error('Auth mode requires valid KIMAKI_PRIVATE_KEY and KIMAKI_GUILD_ID');
+    }
+    const wsManager = discordClient.ws;
+    const fakeShard = {
+        id: 0,
+        checkReady: () => {
+            if (!discordClient.isReady()) {
+                ;
+                discordClient.ws.triggerClientReady();
+            }
+        },
+    };
+    bootstrapReadyState({ discordClient, appId });
+    const wsUrl = buildGatewayMachineWebSocketUrl(getDiscordWsUrl());
+    let socket = null;
+    let closed = false;
+    let retryDelayMs = 1_000;
+    let retryTimer = null;
+    const clearRetryTimer = () => {
+        if (retryTimer) {
+            clearTimeout(retryTimer);
+            retryTimer = null;
+        }
+    };
+    const scheduleReconnect = () => {
+        if (closed) {
+            return;
+        }
+        clearRetryTimer();
+        const delay = retryDelayMs;
+        retryDelayMs = Math.min(30_000, retryDelayMs * 2);
+        retryTimer = setTimeout(() => {
+            connect();
+        }, delay);
+    };
+    const handleIncomingJson = async (text) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        const message = parseGatewayStreamMessage(parsed);
+        if (!message) {
+            return;
+        }
+        if (message.type === 'connected') {
+            gatewayLogger.log(`Auth stream connected (guild=${message.guild_id}, machine=${message.machine_id})`);
+            return;
+        }
+        if (message.guild_id !== guildId) {
+            return;
+        }
+        if (message.op !== 0 || !message.t) {
+            return;
+        }
+        try {
+            wsManager.handlePacket({
+                op: message.op,
+                t: message.t,
+                s: message.s,
+                d: message.d,
+            }, fakeShard);
+        }
+        catch (error) {
+            gatewayLogger.warn(`Failed to handle gateway event ${message.t}: ${error instanceof Error ? error.message : String(error)}`);
+            void notifyError(error, `Failed to handle gateway event ${message.t}`);
+        }
+    };
+    const connect = () => {
+        if (closed) {
+            return;
+        }
+        clearRetryTimer();
+        gatewayLogger.log(`Connecting to gateway auth stream at ${wsUrl}`);
+        socket = new WebSocket(wsUrl, {
+            headers: {
+                Authorization: authorization,
+            },
+        });
+        socket.addEventListener('open', () => {
+            retryDelayMs = 1_000;
+            gatewayLogger.log('Gateway auth stream connected');
+        });
+        socket.addEventListener('message', (event) => {
+            void (async () => {
+                const text = await decodeWebSocketData(event.data);
+                if (text instanceof Error) {
+                    gatewayLogger.warn(text.message);
+                    return;
+                }
+                await handleIncomingJson(text);
+            })();
+        });
+        socket.addEventListener('error', (event) => {
+            gatewayLogger.warn(`Gateway auth stream error: ${event.type || 'unknown_error'}`);
+        });
+        socket.addEventListener('close', () => {
+            if (closed) {
+                return;
+            }
+            gatewayLogger.warn('Gateway auth stream disconnected; reconnecting...');
+            scheduleReconnect();
+        });
+    };
+    connect();
+    return () => {
+        closed = true;
+        clearRetryTimer();
+        const currentSocket = socket;
+        socket = null;
+        currentSocket?.close();
+    };
+}

package/dist/gateway-consumer.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'vitest';
+import { buildGatewayMachineWebSocketUrl } from './gateway-consumer.js';
+describe('buildGatewayMachineWebSocketUrl', () => {
+    test('keeps explicit /ws/machine URL', () => {
+        const resolved = buildGatewayMachineWebSocketUrl('wss://gateway.example.com/ws/machine');
+        expect(resolved).toBe('wss://gateway.example.com/ws/machine');
+    });
+    test('appends /ws/machine for base host URL', () => {
+        const resolved = buildGatewayMachineWebSocketUrl('wss://gateway.example.com');
+        expect(resolved).toBe('wss://gateway.example.com/ws/machine');
+    });
+    test('rejects unsupported paths', () => {
+        expect(() => buildGatewayMachineWebSocketUrl('wss://gateway.example.com/gateway')).toThrow('/ws/machine');
+    });
+    test('rejects non-websocket protocols', () => {
+        expect(() => buildGatewayMachineWebSocketUrl('https://gateway.example.com/ws/machine')).toThrow('ws:// or wss://');
+    });
+});

package/dist/genai-worker-wrapper.js

@@ -0,0 +1,111 @@
+// Main thread interface for the GenAI worker.
+// Spawns and manages the worker thread, handling message passing for
+// audio input/output, tool call completions, and graceful shutdown.
+import { Worker } from 'node:worker_threads';
+import { createLogger, LogPrefix } from './logger.js';
+import { notifyError } from './sentry.js';
+const genaiWorkerLogger = createLogger(LogPrefix.GENAI_WORKER);
+const genaiWrapperLogger = createLogger(LogPrefix.GENAI_WORKER);
+export function createGenAIWorker(options) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(new URL('../dist/genai-worker.js', import.meta.url));
+        // Handle messages from worker
+        worker.on('message', (message) => {
+            switch (message.type) {
+                case 'assistantOpusPacket':
+                    options.onAssistantOpusPacket(message.packet);
+                    break;
+                case 'assistantStartSpeaking':
+                    options.onAssistantStartSpeaking?.();
+                    break;
+                case 'assistantStopSpeaking':
+                    options.onAssistantStopSpeaking?.();
+                    break;
+                case 'assistantInterruptSpeaking':
+                    options.onAssistantInterruptSpeaking?.();
+                    break;
+                case 'toolCallCompleted':
+                    options.onToolCallCompleted?.(message);
+                    break;
+                case 'error':
+                    genaiWorkerLogger.error('Error:', message.error);
+                    options.onError?.(message.error);
+                    break;
+                case 'ready':
+                    genaiWorkerLogger.log('Ready');
+                    // Resolve with the worker interface
+                    resolve({
+                        sendRealtimeInput({ audio, audioStreamEnd }) {
+                            worker.postMessage({
+                                type: 'sendRealtimeInput',
+                                audio,
+                                audioStreamEnd,
+                            });
+                        },
+                        sendTextInput(text) {
+                            worker.postMessage({
+                                type: 'sendTextInput',
+                                text,
+                            });
+                        },
+                        interrupt() {
+                            worker.postMessage({
+                                type: 'interrupt',
+                            });
+                        },
+                        async stop() {
+                            genaiWrapperLogger.log('Stopping worker...');
+                            // Send stop message to trigger graceful shutdown
+                            worker.postMessage({ type: 'stop' });
+                            // Wait for worker to exit gracefully (with timeout)
+                            await new Promise((resolve) => {
+                                let resolved = false;
+                                // Listen for worker exit
+                                worker.once('exit', (code) => {
+                                    if (!resolved) {
+                                        resolved = true;
+                                        genaiWrapperLogger.log(`[GENAI WORKER WRAPPER] Worker exited with code ${code}`);
+                                        resolve();
+                                    }
+                                });
+                                // Timeout after 5 seconds and force terminate
+                                setTimeout(() => {
+                                    if (!resolved) {
+                                        resolved = true;
+                                        genaiWrapperLogger.log('[GENAI WORKER WRAPPER] Worker did not exit gracefully, terminating...');
+                                        worker.terminate().then(() => {
+                                            genaiWrapperLogger.log('Worker terminated');
+                                            resolve();
+                                        });
+                                    }
+                                }, 5000);
+                            });
+                        },
+                    });
+                    break;
+            }
+        });
+        // Handle worker errors
+        worker.on('error', (error) => {
+            genaiWorkerLogger.error('Worker error:', error);
+            reject(error);
+        });
+        worker.on('exit', (code) => {
+            if (code !== 0) {
+                genaiWorkerLogger.error(`Worker stopped with exit code ${code}`);
+                void notifyError(new Error(`GenAI worker exited with code ${code}`), 'GenAI worker non-zero exit after init');
+            }
+        });
+        // Send initialization message
+        const initMessage = {
+            type: 'init',
+            directory: options.directory,
+            systemMessage: options.systemMessage,
+            guildId: options.guildId,
+            channelId: options.channelId,
+            appId: options.appId,
+            geminiApiKey: options.geminiApiKey,
+        };
+        worker.postMessage(initMessage);
+    });
+}