kimaki 0.4.1 → 0.4.4

package/dist/discordBot.js

@@ -327,7 +327,6 @@ function frameMono16khz() {
 }
 export function getDatabase() {
     if (!db) {
-        // Create ~/.kimaki directory if it doesn't exist
         const kimakiDir = path.join(os.homedir(), '.kimaki');
         try {
             fs.mkdirSync(kimakiDir, { recursive: true });
@@ -338,7 +337,6 @@ export function getDatabase() {
         const dbPath = path.join(kimakiDir, 'discord-sessions.db');
         dbLogger.log(`Opening database at: ${dbPath}`);
         db = new Database(dbPath);
-        // Initialize tables
         db.exec(`
       CREATE TABLE IF NOT EXISTS thread_sessions (
         thread_id TEXT PRIMARY KEY,
@@ -379,6 +377,51 @@ export function getDatabase() {
     }
     return db;
 }
+export async function ensureKimakiCategory(guild) {
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === 'kimaki';
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: 'Kimaki',
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function createProjectChannels({ guild, projectDirectory, appId, }) {
+    const baseName = path.basename(projectDirectory);
+    const channelName = `${baseName}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .slice(0, 100);
+    const kimakiCategory = await ensureKimakiCategory(guild);
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: kimakiCategory,
+        topic: `<kimaki><directory>${projectDirectory}</directory><app>${appId}</app></kimaki>`,
+    });
+    const voiceChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildVoice,
+        parent: kimakiCategory,
+    });
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)')
+        .run(textChannel.id, projectDirectory, 'text');
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)')
+        .run(voiceChannel.id, projectDirectory, 'voice');
+    return {
+        textChannelId: textChannel.id,
+        voiceChannelId: voiceChannel.id,
+        channelName,
+    };
+}
 async function getOpenPort() {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -405,6 +448,7 @@ async function getOpenPort() {
  */
 async function sendThreadMessage(thread, content) {
     const MAX_LENGTH = 2000;
+    content = escapeBackticksInCodeBlocks(content);
     // Simple case: content fits in one message
     if (content.length <= MAX_LENGTH) {
         return await thread.send(content);
@@ -551,6 +595,21 @@ async function processVoiceAttachment({ message, thread, projectDirectory, isNew
     await sendThreadMessage(thread, `📝 **Transcribed message:** ${escapeDiscordFormatting(transcription)}`);
     return transcription;
 }
+export function escapeBackticksInCodeBlocks(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'code') {
+            const escapedCode = token.text.replace(/`/g, '\\`');
+            result += '```' + (token.lang || '') + '\n' + escapedCode + '\n```\n';
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}
 /**
  * Escape Discord formatting characters to prevent breaking code blocks and inline code
  */
@@ -708,130 +767,123 @@ export async function initializeOpencodeForDirectory(directory) {
         return entry.client;
     };
 }
-function formatPart(part) {
-    switch (part.type) {
-        case 'text':
-            return escapeDiscordFormatting(part.text || '');
-        case 'reasoning':
-            if (!part.text?.trim())
-                return '';
-            return `▪︎ thinking: ${escapeDiscordFormatting(part.text || '')}`;
-        case 'tool':
-            if (part.state.status === 'completed' || part.state.status === 'error') {
-                let outputToDisplay = '';
-                let summaryText = '';
-                if (part.tool === 'bash') {
-                    const output = part.state.status === 'completed'
-                        ? part.state.output
-                        : part.state.error;
-                    const lines = (output || '').split('\n').filter((l) => l.trim());
-                    summaryText = `(${lines.length} line${lines.length === 1 ? '' : 's'})`;
-                }
-                else if (part.tool === 'edit') {
-                    const newString = part.state.input?.newString || '';
-                    const oldString = part.state.input?.oldString || '';
-                    const added = newString.split('\n').length;
-                    const removed = oldString.split('\n').length;
-                    summaryText = `(+${added}-${removed})`;
-                }
-                else if (part.tool === 'write') {
-                    const content = part.state.input?.content || '';
-                    const lines = content.split('\n').length;
-                    summaryText = `(${lines} line${lines === 1 ? '' : 's'})`;
-                }
-                else if (part.tool === 'read') {
-                }
-                else if (part.tool === 'write') {
-                }
-                else if (part.tool === 'edit') {
-                }
-                else if (part.tool === 'list') {
-                }
-                else if (part.tool === 'glob') {
-                }
-                else if (part.tool === 'grep') {
-                }
-                else if (part.tool === 'task') {
-                }
-                else if (part.tool === 'todoread') {
-                    // Special handling for read - don't show arguments
-                }
-                else if (part.tool === 'todowrite') {
-                    const todos = part.state.input?.todos || [];
-                    outputToDisplay = todos
-                        .map((todo) => {
-                        let statusIcon = '▢';
-                        switch (todo.status) {
-                            case 'pending':
-                                statusIcon = '▢';
-                                break;
-                            case 'in_progress':
-                                statusIcon = '●';
-                                break;
-                            case 'completed':
-                                statusIcon = '■';
-                                break;
-                            case 'cancelled':
-                                statusIcon = '■';
-                                break;
-                        }
-                        return `\`${statusIcon}\` ${todo.content}`;
-                    })
-                        .filter(Boolean)
-                        .join('\n');
-                }
-                else if (part.tool === 'webfetch') {
-                    const url = part.state.input?.url || '';
-                    const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
-                    summaryText = urlWithoutProtocol ? `(${urlWithoutProtocol})` : '';
-                }
-                else if (part.state.input) {
-                    const inputFields = Object.entries(part.state.input)
-                        .map(([key, value]) => {
-                        if (value === null || value === undefined)
-                            return null;
-                        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-                        const truncatedValue = stringValue.length > 100
-                            ? stringValue.slice(0, 100) + '…'
-                            : stringValue;
-                        return `${key}: ${truncatedValue}`;
-                    })
-                        .filter(Boolean);
-                    if (inputFields.length > 0) {
-                        outputToDisplay = inputFields.join(', ');
-                    }
-                }
-                let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error';
-                if (toolTitle) {
-                    toolTitle = `\`${escapeInlineCode(toolTitle)}\``;
-                }
-                const icon = part.state.status === 'completed'
-                    ? '◼︎'
-                    : part.state.status === 'error'
-                        ? '⨯'
-                        : '';
-                const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
-                let text = title;
-                if (outputToDisplay) {
-                    text += '\n\n' + outputToDisplay;
-                }
-                return text;
+function getToolSummaryText(part) {
+    if (part.type !== 'tool')
+        return '';
+    if (part.state.status !== 'completed' && part.state.status !== 'error')
+        return '';
+    if (part.tool === 'bash') {
+        const output = part.state.status === 'completed' ? part.state.output : part.state.error;
+        const lines = (output || '').split('\n').filter((l) => l.trim());
+        return `(${lines.length} line${lines.length === 1 ? '' : 's'})`;
+    }
+    if (part.tool === 'edit') {
+        const newString = part.state.input?.newString || '';
+        const oldString = part.state.input?.oldString || '';
+        const added = newString.split('\n').length;
+        const removed = oldString.split('\n').length;
+        return `(+${added}-${removed})`;
+    }
+    if (part.tool === 'write') {
+        const content = part.state.input?.content || '';
+        const lines = content.split('\n').length;
+        return `(${lines} line${lines === 1 ? '' : 's'})`;
+    }
+    if (part.tool === 'webfetch') {
+        const url = part.state.input?.url || '';
+        const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
+        return urlWithoutProtocol ? `(${urlWithoutProtocol})` : '';
+    }
+    if (part.tool === 'read' ||
+        part.tool === 'list' ||
+        part.tool === 'glob' ||
+        part.tool === 'grep' ||
+        part.tool === 'task' ||
+        part.tool === 'todoread' ||
+        part.tool === 'todowrite') {
+        return '';
+    }
+    if (!part.state.input)
+        return '';
+    const inputFields = Object.entries(part.state.input)
+        .map(([key, value]) => {
+        if (value === null || value === undefined)
+            return null;
+        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+        const truncatedValue = stringValue.length > 100 ? stringValue.slice(0, 100) + '…' : stringValue;
+        return `${key}: ${truncatedValue}`;
+    })
+        .filter(Boolean);
+    if (inputFields.length === 0)
+        return '';
+    return `(${inputFields.join(', ')})`;
+}
+function getToolOutputToDisplay(part) {
+    if (part.type !== 'tool')
+        return '';
+    if (part.state.status !== 'completed' && part.state.status !== 'error')
+        return '';
+    if (part.state.status === 'error') {
+        return part.state.error || 'Unknown error';
+    }
+    if (part.tool === 'todowrite') {
+        const todos = part.state.input?.todos || [];
+        return todos
+            .map((todo) => {
+            let statusIcon = '▢';
+            if (todo.status === 'in_progress') {
+                statusIcon = '●';
             }
+            if (todo.status === 'completed' || todo.status === 'cancelled') {
+                statusIcon = '■';
+            }
+            return `\`${statusIcon}\` ${todo.content}`;
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    return '';
+}
+function formatPart(part) {
+    if (part.type === 'text') {
+        return part.text || '';
+    }
+    if (part.type === 'reasoning') {
+        if (!part.text?.trim())
             return '';
-        case 'file':
-            return `📄 ${part.filename || 'File'}`;
-        case 'step-start':
-        case 'step-finish':
-        case 'patch':
-            return '';
-        case 'agent':
-            return `◼︎ agent ${part.id}`;
-        case 'snapshot':
-            return `◼︎ snapshot ${part.snapshot}`;
-        default:
-            discordLogger.warn('Unknown part type:', part);
+        return `◼︎ thinking`;
+    }
+    if (part.type === 'file') {
+        return `📄 ${part.filename || 'File'}`;
+    }
+    if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
+        return '';
+    }
+    if (part.type === 'agent') {
+        return `◼︎ agent ${part.id}`;
+    }
+    if (part.type === 'snapshot') {
+        return `◼︎ snapshot ${part.snapshot}`;
+    }
+    if (part.type === 'tool') {
+        if (part.state.status !== 'completed' && part.state.status !== 'error') {
             return '';
+        }
+        const summaryText = getToolSummaryText(part);
+        const outputToDisplay = getToolOutputToDisplay(part);
+        let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error';
+        if (toolTitle) {
+            toolTitle = `\`${escapeInlineCode(toolTitle)}\``;
+        }
+        const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : '';
+        const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
+        if (outputToDisplay) {
+            return title + '\n\n' + outputToDisplay;
+        }
+        return title;
     }
+    discordLogger.warn('Unknown part type:', part);
+    return '';
 }
 export async function createDiscordClient() {
     return new Client({
@@ -868,6 +920,9 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
     sessionLogger.log(`Using directory: ${directory}`);
     // Note: We'll cancel the existing request after we have the session ID
     const getClient = await initializeOpencodeForDirectory(directory);
+    // Get the port for this directory
+    const serverEntry = opencodeServers.get(directory);
+    const port = serverEntry?.port;
     // Get session ID from database
     const row = getDatabase()
         .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
@@ -912,9 +967,12 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
     if (abortControllers.has(session.id)) {
         abortControllers.get(session.id)?.abort(new Error('new reply'));
     }
-    const promptAbortController = new AbortController();
-    abortControllers.set(session.id, promptAbortController);
-    const eventsResult = await getClient().event.subscribe({});
+    const abortController = new AbortController();
+    // Store this controller for this session
+    abortControllers.set(session.id, abortController);
+    const eventsResult = await getClient().event.subscribe({
+        signal: abortController.signal,
+    });
     const events = eventsResult.stream;
     sessionLogger.log(`Subscribed to OpenCode events`);
     // Load existing part-message mappings from database
@@ -936,6 +994,7 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
     }
     let currentParts = [];
     let stopTyping = null;
+    let usedModel;
     const sendPartMessage = async (part) => {
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
@@ -966,7 +1025,7 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
         // Outer-scoped interval for typing notifications. Only one at a time.
         let typingInterval = null;
         function startTyping(thread) {
-            if (promptAbortController.signal.aborted) {
+            if (abortController.signal.aborted) {
                 discordLogger.log(`Not starting typing, already aborted`);
                 return () => { };
             }
@@ -988,8 +1047,8 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                 });
             }, 8000);
             // Only add listener if not already aborted
-            if (!promptAbortController.signal.aborted) {
-                promptAbortController.signal.addEventListener('abort', () => {
+            if (!abortController.signal.aborted) {
+                abortController.signal.addEventListener('abort', () => {
                     if (typingInterval) {
                         clearInterval(typingInterval);
                         typingInterval = null;
@@ -1020,6 +1079,7 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                     // Track assistant message ID
                     if (msg.role === 'assistant') {
                         assistantMessageId = msg.id;
+                        usedModel = msg.modelID;
                         voiceLogger.log(`[EVENT] Tracking assistant message ${assistantMessageId}`);
                     }
                     else {
@@ -1061,7 +1121,7 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                         }
                         // start typing in a moment, so that if the session finished, because step-finish is at the end of the message, we do not show typing status
                         setTimeout(() => {
-                            if (promptAbortController.signal.aborted)
+                            if (abortController.signal.aborted)
                                 return;
                             stopTyping = startTyping(thread);
                         }, 300);
@@ -1100,6 +1160,10 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
             }
         }
         catch (e) {
+            if (isAbortError(e, abortController.signal)) {
+                sessionLogger.log('AbortController aborted event handling (normal exit)');
+                return;
+            }
             sessionLogger.error(`Unexpected error in event handling code`, e);
             throw e;
         }
@@ -1132,14 +1196,16 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                 sessionLogger.log(`Stopped typing for session`);
             }
             // Only send duration message if request was not aborted or was aborted with 'finished' reason
-            if (!promptAbortController.signal.aborted ||
-                promptAbortController.signal.reason === 'finished') {
+            if (!abortController.signal.aborted ||
+                abortController.signal.reason === 'finished') {
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
-                await sendThreadMessage(thread, `_Completed in ${sessionDuration}_`);
-                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}`);
+                const attachCommand = port ? ` ⋅ ${session.id}` : '';
+                const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
+                await sendThreadMessage(thread, `_Completed in ${sessionDuration}_${attachCommand}${modelInfo}`);
+                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}`);
             }
             else {
-                sessionLogger.log(`Session was aborted (reason: ${promptAbortController.signal.reason}), skipping duration message`);
+                sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
             }
         }
     };
@@ -1152,11 +1218,10 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
             body: {
                 parts: [{ type: 'text', text: prompt }],
             },
-            signal: promptAbortController.signal,
+            signal: abortController.signal,
         });
-        promptAbortController.abort(new Error('finished'));
+        abortController.abort('finished');
         sessionLogger.log(`Successfully sent prompt, got response`);
-        abortControllers.delete(session.id);
         // Update reaction to success
         if (originalMessage) {
             try {
@@ -1168,12 +1233,12 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                 discordLogger.log(`Could not update reaction:`, e);
             }
         }
-        return { sessionID: session.id, result: response.data };
+        return { sessionID: session.id, result: response.data, port };
     }
     catch (error) {
         sessionLogger.error(`ERROR: Failed to send prompt:`, error);
-        if (!isAbortError(error, promptAbortController.signal)) {
-            promptAbortController.abort(new Error('error'));
+        if (!isAbortError(error, abortController.signal)) {
+            abortController.abort('error');
             if (originalMessage) {
                 try {
                     await originalMessage.reactions.removeAll();
@@ -1184,7 +1249,6 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                     discordLogger.log(`Could not update reaction:`, e);
                 }
             }
-            // Always log the error's constructor name (if any) and make error reporting more readable
             const errorName = error &&
                 typeof error === 'object' &&
                 'constructor' in error &&
@@ -1459,10 +1523,20 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                             .toLowerCase()
                             .includes(focusedValue.toLowerCase()))
                             .slice(0, 25) // Discord limit
-                            .map((session) => ({
-                            name: `${session.title} (${new Date(session.time.updated).toLocaleString()})`,
-                            value: session.id,
-                        }));
+                            .map((session) => {
+                            const dateStr = new Date(session.time.updated).toLocaleString();
+                            const suffix = ` (${dateStr})`;
+                            // Discord limit is 100 chars. Reserve space for suffix.
+                            const maxTitleLength = 100 - suffix.length;
+                            let title = session.title;
+                            if (title.length > maxTitleLength) {
+                                title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…';
+                            }
+                            return {
+                                name: `${title}${suffix}`,
+                                value: session.id,
+                            };
+                        });
                         await interaction.respond(sessions);
                     }
                     catch (error) {
@@ -1516,7 +1590,6 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                                 : '';
                             // Map to Discord autocomplete format
                             const choices = files
-                                .slice(0, 25) // Discord limit
                                 .map((file) => {
                                 const fullValue = prefix + file;
                                 // Get all basenames for display
@@ -1531,7 +1604,10 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                                     name: displayName,
                                     value: fullValue,
                                 };
-                            });
+                            })
+                                // Discord API limits choice value to 100 characters
+                                .filter((choice) => choice.value.length <= 100)
+                                .slice(0, 25); // Discord limit
                             await interaction.respond(choices);
                         }
                         catch (error) {
@@ -1540,6 +1616,48 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         }
                     }
                 }
+                else if (interaction.commandName === 'add-project') {
+                    const focusedValue = interaction.options.getFocused();
+                    try {
+                        const currentDir = process.cwd();
+                        const getClient = await initializeOpencodeForDirectory(currentDir);
+                        const projectsResponse = await getClient().project.list({});
+                        if (!projectsResponse.data) {
+                            await interaction.respond([]);
+                            return;
+                        }
+                        const db = getDatabase();
+                        const existingDirs = db
+                            .prepare('SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?')
+                            .all('text');
+                        const existingDirSet = new Set(existingDirs.map((row) => row.directory));
+                        const availableProjects = projectsResponse.data.filter((project) => !existingDirSet.has(project.worktree));
+                        const projects = availableProjects
+                            .filter((project) => {
+                            const baseName = path.basename(project.worktree);
+                            const searchText = `${baseName} ${project.worktree}`.toLowerCase();
+                            return searchText.includes(focusedValue.toLowerCase());
+                        })
+                            .sort((a, b) => {
+                            const aTime = a.time.initialized || a.time.created;
+                            const bTime = b.time.initialized || b.time.created;
+                            return bTime - aTime;
+                        })
+                            .slice(0, 25)
+                            .map((project) => {
+                            const name = `${path.basename(project.worktree)} (${project.worktree})`;
+                            return {
+                                name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+                                value: project.id,
+                            };
+                        });
+                        await interaction.respond(projects);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+                        await interaction.respond([]);
+                    }
+                }
             }
             // Handle slash commands
             if (interaction.isChatInputCommand()) {
@@ -1720,6 +1838,53 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await command.editReply(`Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`);
                     }
                 }
+                else if (command.commandName === 'add-project') {
+                    await command.deferReply({ ephemeral: false });
+                    const projectId = command.options.getString('project', true);
+                    const guild = command.guild;
+                    if (!guild) {
+                        await command.editReply('This command can only be used in a guild');
+                        return;
+                    }
+                    try {
+                        const currentDir = process.cwd();
+                        const getClient = await initializeOpencodeForDirectory(currentDir);
+                        const projectsResponse = await getClient().project.list({});
+                        if (!projectsResponse.data) {
+                            await command.editReply('Failed to fetch projects');
+                            return;
+                        }
+                        const project = projectsResponse.data.find((p) => p.id === projectId);
+                        if (!project) {
+                            await command.editReply('Project not found');
+                            return;
+                        }
+                        const directory = project.worktree;
+                        if (!fs.existsSync(directory)) {
+                            await command.editReply(`Directory does not exist: ${directory}`);
+                            return;
+                        }
+                        const db = getDatabase();
+                        const existingChannel = db
+                            .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+                            .get(directory, 'text');
+                        if (existingChannel) {
+                            await command.editReply(`A channel already exists for this directory: <#${existingChannel.channel_id}>`);
+                            return;
+                        }
+                        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+                            guild,
+                            projectDirectory: directory,
+                            appId: currentAppId,
+                        });
+                        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``);
+                        discordLogger.log(`Created channels for project ${channelName} at ${directory}`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[ADD-PROJECT] Error:', error);
+                        await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
             }
         }
         catch (error) {