kimaki 0.4.39 → 0.4.40

package/dist/cli.js

@@ -11,6 +11,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import * as errore from 'errore';
 import { createLogger } from './logger.js';
+import { uploadFilesToDiscord } from './discord-utils.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 import http from 'node:http';
 import { setDataDir, getDataDir, getLockPort } from './config.js';
@@ -136,7 +137,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
         })
             .toJSON(),
         new SlashCommandBuilder()
-            .setName('session')
+            .setName('new-session')
             .setDescription('Start a new OpenCode session')
             .addStringOption((option) => {
             option.setName('prompt').setDescription('Prompt content for the session').setRequired(true);
@@ -158,6 +159,17 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             return option;
         })
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('new-worktree')
+            .setDescription('Create a new git worktree and start a session thread')
+            .addStringOption((option) => {
+            option
+                .setName('name')
+                .setDescription('Name for the worktree (will be formatted: lowercase, spaces to dashes)')
+                .setRequired(true);
+            return option;
+        })
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
             .setDescription('Create Discord channels for a new OpenCode project')
@@ -434,7 +446,7 @@ async function run({ restart, addChannels }) {
     const currentDir = process.cwd();
     s.start('Starting OpenCode server...');
     const opencodePromise = initializeOpencodeForDirectory(currentDir).then((result) => {
-        if (errore.isError(result)) {
+        if (result instanceof Error) {
             throw new Error(result.message);
         }
         return result;
@@ -741,25 +753,11 @@ cli
         }
         const s = spinner();
         s.start(`Uploading ${resolvedFiles.length} file(s)...`);
-        for (const file of resolvedFiles) {
-            const buffer = fs.readFileSync(file);
-            const formData = new FormData();
-            formData.append('payload_json', JSON.stringify({
-                attachments: [{ id: 0, filename: path.basename(file) }],
-            }));
-            formData.append('files[0]', new Blob([buffer]), path.basename(file));
-            const response = await fetch(`https://discord.com/api/v10/channels/${threadRow.thread_id}/messages`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bot ${botRow.token}`,
-                },
-                body: formData,
-            });
-            if (!response.ok) {
-                const error = await response.text();
-                throw new Error(`Discord API error: ${response.status} - ${error}`);
-            }
-        }
+        await uploadFilesToDiscord({
+            threadId: threadRow.thread_id,
+            botToken: botRow.token,
+            files: resolvedFiles,
+        });
         s.stop(`Uploaded ${resolvedFiles.length} file(s)!`);
         note(`Files uploaded to Discord thread!\n\nFiles: ${resolvedFiles.map((f) => path.basename(f)).join(', ')}`, '✅ Success');
         process.exit(0);

package/dist/commands/abort.js

@@ -58,7 +58,7 @@ export async function handleAbortCommand({ command }) {
         abortControllers.delete(sessionId);
     }
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await command.reply({
             content: `Failed to abort: ${getClient.message}`,
             ephemeral: true,

package/dist/commands/add-project.js

@@ -19,7 +19,7 @@ export async function handleAddProjectCommand({ command, appId }) {
     try {
         const currentDir = process.cwd();
         const getClient = await initializeOpencodeForDirectory(currentDir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await command.editReply(getClient.message);
             return;
         }
@@ -65,7 +65,7 @@ export async function handleAddProjectAutocomplete({ interaction, appId, }) {
     try {
         const currentDir = process.cwd();
         const getClient = await initializeOpencodeForDirectory(currentDir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.respond([]);
             return;
         }

package/dist/commands/agent.js

@@ -103,7 +103,7 @@ export async function handleAgentCommand({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.editReply({ content: getClient.message });
             return;
         }
@@ -210,7 +210,7 @@ export async function handleQuickAgentCommand({ command, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await command.editReply({ content: getClient.message });
             return;
         }

package/dist/commands/fork.js

@@ -52,7 +52,7 @@ export async function handleForkCommand(interaction) {
     await interaction.deferReply({ ephemeral: true });
     const sessionId = row.session_id;
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await interaction.editReply({
             content: `Failed to load messages: ${getClient.message}`,
         });
@@ -128,7 +128,7 @@ export async function handleForkSelectMenu(interaction) {
     }
     await interaction.deferReply({ ephemeral: false });
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await interaction.editReply(`Failed to fork session: ${getClient.message}`);
         return;
     }

package/dist/commands/model.js

@@ -78,7 +78,7 @@ export async function handleModelCommand({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.editReply({ content: getClient.message });
             return;
         }
@@ -167,7 +167,7 @@ export async function handleProviderSelectMenu(interaction) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.editReply({
                 content: getClient.message,
                 components: [],

package/dist/commands/remove-project.js

@@ -30,7 +30,7 @@ export async function handleRemoveProjectCommand({ command, appId }) {
                 try: () => guild.channels.fetch(channel_id),
                 catch: (e) => e,
             });
-            if (errore.isError(channel)) {
+            if (channel instanceof Error) {
                 logger.error(`Failed to fetch channel ${channel_id}:`, channel);
                 failedChannels.push(`${channel_type}: ${channel_id}`);
                 continue;
@@ -88,7 +88,7 @@ export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
                 try: () => guild.channels.fetch(channel_id),
                 catch: (e) => e,
             });
-            if (errore.isError(channel)) {
+            if (channel instanceof Error) {
                 // Channel not in this guild, skip
                 continue;
             }

package/dist/commands/resume.js

@@ -42,7 +42,7 @@ export async function handleResumeCommand({ command, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await command.editReply(getClient.message);
             return;
         }
@@ -116,7 +116,7 @@ export async function handleResumeAutocomplete({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.respond([]);
             return;
         }

package/dist/commands/session.js

@@ -1,4 +1,4 @@
-// /session command - Start a new OpenCode session.
+// /new-session command - Start a new OpenCode session.
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -45,7 +45,7 @@ export async function handleSessionCommand({ command, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await command.editReply(getClient.message);
             return;
         }
@@ -107,7 +107,7 @@ async function handleAgentAutocomplete({ interaction, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.respond([]);
             return;
         }
@@ -174,7 +174,7 @@ export async function handleSessionAutocomplete({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.respond([]);
             return;
         }

package/dist/commands/share.js

@@ -52,7 +52,7 @@ export async function handleShareCommand({ command }) {
     }
     const sessionId = row.session_id;
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await command.reply({
             content: `Failed to share session: ${getClient.message}`,
             ephemeral: true,

package/dist/commands/undo-redo.js

@@ -53,7 +53,7 @@ export async function handleUndoCommand({ command }) {
     const sessionId = row.session_id;
     await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await command.editReply(`Failed to undo: ${getClient.message}`);
         return;
     }
@@ -140,7 +140,7 @@ export async function handleRedoCommand({ command }) {
     const sessionId = row.session_id;
     await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await command.editReply(`Failed to redo: ${getClient.message}`);
         return;
     }

package/dist/commands/worktree.js

@@ -0,0 +1,180 @@
+// Worktree management command: /new-worktree
+// Uses OpenCode SDK v2 to create worktrees with kimaki- prefix
+// Creates thread immediately, then worktree in background so user can type
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import { createPendingWorktree, setWorktreeReady, setWorktreeError, } from '../database.js';
+import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { extractTagsArrays } from '../xml.js';
+import { createLogger } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger('WORKTREE');
+class WorktreeError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'WorktreeError';
+    }
+}
+/**
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add kimaki- prefix.
+ * "My Feature" → "kimaki-my-feature"
+ */
+function formatWorktreeName(name) {
+    const formatted = name
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+    return `kimaki-${formatted}`;
+}
+/**
+ * Get project directory from channel topic.
+ */
+function getProjectDirectoryFromChannel(channel, appId) {
+    if (!channel.topic) {
+        return new WorktreeError('This channel has no topic configured');
+    }
+    const extracted = extractTagsArrays({
+        xml: channel.topic,
+        tags: ['kimaki.directory', 'kimaki.app'],
+    });
+    const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+    const channelAppId = extracted['kimaki.app']?.[0]?.trim();
+    if (channelAppId && channelAppId !== appId) {
+        return new WorktreeError('This channel is not configured for this bot');
+    }
+    if (!projectDirectory) {
+        return new WorktreeError('This channel is not configured with a project directory');
+    }
+    if (!fs.existsSync(projectDirectory)) {
+        return new WorktreeError(`Directory does not exist: ${projectDirectory}`);
+    }
+    return projectDirectory;
+}
+/**
+ * Create worktree in background and update starter message when done.
+ */
+async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, clientV2, }) {
+    // Create worktree using SDK v2
+    logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`);
+    const worktreeResult = await errore.tryAsync({
+        try: async () => {
+            const response = await clientV2.worktree.create({
+                directory: projectDirectory,
+                worktreeCreateInput: {
+                    name: worktreeName,
+                },
+            });
+            if (response.error) {
+                throw new Error(`SDK error: ${JSON.stringify(response.error)}`);
+            }
+            if (!response.data) {
+                throw new Error('No worktree data returned from SDK');
+            }
+            return response.data;
+        },
+        catch: (e) => new WorktreeError('Failed to create worktree', { cause: e }),
+    });
+    if (errore.isError(worktreeResult)) {
+        const errorMsg = worktreeResult.message;
+        logger.error('[NEW-WORKTREE] Error:', worktreeResult.cause);
+        setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
+        await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
+        return;
+    }
+    // Success - update database and edit starter message
+    setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory });
+    await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n` +
+        `📁 \`${worktreeResult.directory}\`\n` +
+        `🌿 Branch: \`${worktreeResult.branch}\``);
+}
+export async function handleNewWorktreeCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const rawName = command.options.getString('name', true);
+    const worktreeName = formatWorktreeName(rawName);
+    if (worktreeName === 'kimaki-') {
+        await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.');
+        return;
+    }
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels');
+        return;
+    }
+    const textChannel = channel;
+    const projectDirectory = getProjectDirectoryFromChannel(textChannel, appId);
+    if (errore.isError(projectDirectory)) {
+        await command.editReply(projectDirectory.message);
+        return;
+    }
+    // Initialize opencode and check if worktree already exists
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to initialize OpenCode: ${getClient.message}`);
+        return;
+    }
+    const clientV2 = getOpencodeClientV2(projectDirectory);
+    if (!clientV2) {
+        await command.editReply('Failed to get OpenCode client');
+        return;
+    }
+    // Check if worktree with this name already exists
+    // SDK returns array of directory paths like "~/.opencode/worktree/abc/kimaki-my-feature"
+    const listResult = await errore.tryAsync({
+        try: async () => {
+            const response = await clientV2.worktree.list({ directory: projectDirectory });
+            return response.data || [];
+        },
+        catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+    });
+    if (errore.isError(listResult)) {
+        await command.editReply(listResult.message);
+        return;
+    }
+    // Check if any worktree path ends with our name
+    const existingWorktree = listResult.find((dir) => dir.endsWith(`/${worktreeName}`));
+    if (existingWorktree) {
+        await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktree}\``);
+        return;
+    }
+    // Create thread immediately so user can start typing
+    const result = await errore.tryAsync({
+        try: async () => {
+            const starterMessage = await textChannel.send({
+                content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            const thread = await starterMessage.startThread({
+                name: `worktree: ${worktreeName}`,
+                autoArchiveDuration: 1440,
+                reason: 'Worktree session',
+            });
+            return { thread, starterMessage };
+        },
+        catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
+    });
+    if (errore.isError(result)) {
+        logger.error('[NEW-WORKTREE] Error:', result.cause);
+        await command.editReply(result.message);
+        return;
+    }
+    const { thread, starterMessage } = result;
+    // Store pending worktree in database
+    createPendingWorktree({
+        threadId: thread.id,
+        worktreeName,
+        projectDirectory,
+    });
+    await command.editReply(`Creating worktree in ${thread.toString()}`);
+    // Create worktree in background (don't await)
+    createWorktreeInBackground({
+        thread,
+        starterMessage,
+        worktreeName,
+        projectDirectory,
+        clientV2,
+    }).catch((e) => {
+        logger.error('[NEW-WORKTREE] Background error:', e);
+    });
+}

package/dist/database.js

@@ -18,7 +18,7 @@ export function getDatabase() {
             },
             catch: (e) => e,
         });
-        if (errore.isError(mkdirError)) {
+        if (mkdirError instanceof Error) {
             dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message);
         }
         const dbPath = path.join(dataDir, 'discord-sessions.db');
@@ -75,6 +75,19 @@ export function getDatabase() {
         xai_api_key TEXT,
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
       )
+    `);
+        // Track worktrees created for threads (for /new-worktree command)
+        // status: 'pending' while creating, 'ready' when done, 'error' if failed
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_worktrees (
+        thread_id TEXT PRIMARY KEY,
+        worktree_name TEXT NOT NULL,
+        worktree_directory TEXT,
+        project_directory TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        error_message TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
     `);
         runModelMigrations(db);
     }
@@ -202,6 +215,41 @@ export function setSessionAgent(sessionId, agentName) {
     const db = getDatabase();
     db.prepare(`INSERT OR REPLACE INTO session_agents (session_id, agent_name) VALUES (?, ?)`).run(sessionId, agentName);
 }
+/**
+ * Get the worktree info for a thread.
+ */
+export function getThreadWorktree(threadId) {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM thread_worktrees WHERE thread_id = ?').get(threadId);
+}
+/**
+ * Create a pending worktree entry for a thread.
+ */
+export function createPendingWorktree({ threadId, worktreeName, projectDirectory, }) {
+    const db = getDatabase();
+    db.prepare(`INSERT OR REPLACE INTO thread_worktrees (thread_id, worktree_name, project_directory, status) VALUES (?, ?, ?, 'pending')`).run(threadId, worktreeName, projectDirectory);
+}
+/**
+ * Mark a worktree as ready with its directory.
+ */
+export function setWorktreeReady({ threadId, worktreeDirectory, }) {
+    const db = getDatabase();
+    db.prepare(`UPDATE thread_worktrees SET worktree_directory = ?, status = 'ready' WHERE thread_id = ?`).run(worktreeDirectory, threadId);
+}
+/**
+ * Mark a worktree as failed with error message.
+ */
+export function setWorktreeError({ threadId, errorMessage, }) {
+    const db = getDatabase();
+    db.prepare(`UPDATE thread_worktrees SET status = 'error', error_message = ? WHERE thread_id = ?`).run(errorMessage, threadId);
+}
+/**
+ * Delete the worktree info for a thread.
+ */
+export function deleteThreadWorktree(threadId) {
+    const db = getDatabase();
+    db.prepare('DELETE FROM thread_worktrees WHERE thread_id = ?').run(threadId);
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/discord-bot.js

@@ -1,7 +1,7 @@
 // Core Discord bot module that handles message events and bot lifecycle.
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
-import { getDatabase, closeDatabase } from './database.js';
+import { getDatabase, closeDatabase, getThreadWorktree } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
 import { getOpencodeSystemMessage } from './system-message.js';
@@ -22,7 +22,10 @@ import * as errore from 'errore';
 import { extractTagsArrays } from './xml.js';
 import { createLogger } from './logger.js';
 import { setGlobalDispatcher, Agent } from 'undici';
-setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }));
+// Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
+// Each session's event.subscribe() holds a connection; without enough connections,
+// regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
+setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }));
 const discordLogger = createLogger('DISCORD');
 const voiceLogger = createLogger('VOICE');
 export async function createDiscordClient() {
@@ -94,7 +97,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     try: () => message.fetch(),
                     catch: (e) => e,
                 });
-                if (errore.isError(fetched)) {
+                if (fetched instanceof Error) {
                     discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message);
                     return;
                 }
@@ -132,6 +135,28 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
                     channelAppId = extracted['kimaki.app']?.[0]?.trim();
                 }
+                // Check if this thread is a worktree thread
+                const worktreeInfo = getThreadWorktree(thread.id);
+                if (worktreeInfo) {
+                    if (worktreeInfo.status === 'pending') {
+                        await message.reply({
+                            content: '⏳ Worktree is still being created. Please wait...',
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    if (worktreeInfo.status === 'error') {
+                        await message.reply({
+                            content: `❌ Worktree creation failed: ${worktreeInfo.error_message}`,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    if (worktreeInfo.worktree_directory) {
+                        projectDirectory = worktreeInfo.worktree_directory;
+                        discordLogger.log(`Using worktree directory: ${projectDirectory}`);
+                    }
+                }
                 if (channelAppId && channelAppId !== currentAppId) {
                     voiceLogger.log(`[IGNORED] Thread belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`);
                     return;
@@ -175,7 +200,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (projectDirectory) {
                     try {
                         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-                        if (errore.isError(getClient)) {
+                        if (getClient instanceof Error) {
                             voiceLogger.error(`[SESSION] Failed to initialize OpenCode client:`, getClient.message);
                             throw new Error(getClient.message);
                         }

package/dist/discord-utils.js

@@ -8,6 +8,9 @@ import { formatMarkdownTables } from './format-tables.js';
 import { limitHeadingDepth } from './limit-heading-depth.js';
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
 import { createLogger } from './logger.js';
+import mime from 'mime';
+import fs from 'node:fs';
+import path from 'node:path';
 const discordLogger = createLogger('DISCORD');
 export const SILENT_MESSAGE_FLAGS = 4 | 4096;
 // Same as SILENT but without SuppressNotifications - triggers badge/notification
@@ -244,3 +247,36 @@ export function getKimakiMetadata(textChannel) {
     const channelAppId = extracted['kimaki.app']?.[0]?.trim();
     return { projectDirectory, channelAppId };
 }
+/**
+ * Upload files to a Discord thread/channel in a single message.
+ * Sending all files in one message causes Discord to display images in a grid layout.
+ */
+export async function uploadFilesToDiscord({ threadId, botToken, files, }) {
+    if (files.length === 0) {
+        return;
+    }
+    // Build attachments array for all files
+    const attachments = files.map((file, index) => ({
+        id: index,
+        filename: path.basename(file),
+    }));
+    const formData = new FormData();
+    formData.append('payload_json', JSON.stringify({ attachments }));
+    // Append each file with its array index, with correct MIME type for grid display
+    files.forEach((file, index) => {
+        const buffer = fs.readFileSync(file);
+        const mimeType = mime.getType(file) || 'application/octet-stream';
+        formData.append(`files[${index}]`, new Blob([buffer], { type: mimeType }), path.basename(file));
+    });
+    const response = await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bot ${botToken}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Discord API error: ${response.status} - ${error}`);
+    }
+}