kimaki 0.14.0 → 0.16.0

package/dist/cli-commands/send.js

@@ -138,12 +138,6 @@ cli
             if (options.user) {
                 incompatibleFlags.push('--user');
             }
-            if (!sendAt && options.agent) {
-                incompatibleFlags.push('--agent');
-            }
-            if (!sendAt && options.model) {
-                incompatibleFlags.push('--model');
-            }
             if (incompatibleFlags.length > 0) {
                 cliLogger.error(`Incompatible options with --thread/--session: ${incompatibleFlags.join(', ')}`);
                 process.exit(EXIT_NO_RESTART);
@@ -313,6 +307,8 @@ cli
             }
             const threadPromptMarker = {
                 start: true,
+                ...(options.agent && { agent: options.agent }),
+                ...(options.model && { model: options.model }),
                 ...(options.permission?.length ? { permissions: options.permission } : {}),
                 ...(options.injectionGuard?.length ? { injectionGuardPatterns: options.injectionGuard } : {}),
             };
@@ -334,8 +330,12 @@ cli
                 rest,
             });
             const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
-            note(`Prompt sent to thread: ${threadData.name}\n\nURL: ${threadUrl}`, '✅ Message Sent');
-            cliLogger.log(threadUrl);
+            const existingSessionId = sessionId || await getThreadSession(targetThreadId);
+            const sessionLine = existingSessionId ? `Session: ${existingSessionId}\n` : '';
+            note(`Prompt sent to thread: ${threadData.name}\n${sessionLine}\nURL: ${threadUrl}`, '✅ Message Sent');
+            if (existingSessionId)
+                process.stdout.write(`Session: ${existingSessionId}\n`);
+            process.stdout.write(`${threadUrl}\n`);
             if (options.wait) {
                 const { waitAndOutputSession } = await import('../wait-session.js');
                 await waitAndOutputSession({
@@ -353,16 +353,18 @@ cli
         // Get channel info to extract directory from topic
         const channelData = (await rest.get(Routes.channel(channelId)));
         const channelConfig = await getChannelDirectory(channelData.id);
-        if (!channelConfig) {
+        if (!channelConfig && !notifyOnly) {
             cliLogger.log('Channel not configured');
             throw new Error(`Channel #${channelData.name} is not configured with a project directory. Run the bot first to sync channel data.`);
         }
-        const projectDirectory = channelConfig.directory;
+        const projectDirectory = channelConfig?.directory;
         // Validate --cwd is inside the project or an existing git worktree.
         let resolvedCwd;
         if (options.cwd) {
+            // projectDirectory is guaranteed here: --cwd is incompatible with --notify-only,
+            // and non-notify sends already require channelConfig above.
             const cwdResult = await resolveSessionWorkingDirectory({
-                projectDirectory,
+                projectDirectory: projectDirectory,
                 candidatePath: options.cwd,
             });
             if (cwdResult instanceof Error) {
@@ -455,7 +457,16 @@ cli
             botToken,
             embeds: autoStartEmbed,
             rest,
+            splitInsteadOfAttach: notifyOnly,
         });
+        // For notify-only on non-project channels, just post the message without
+        // creating a thread. There's no session to start, so a thread is unnecessary.
+        if (notifyOnly && !channelConfig) {
+            const messageUrl = `https://discord.com/channels/${channelData.guild_id}/${channelId}/${starterMessage.id}`;
+            note(`Channel: #${channelData.name}\n\nMessage sent.\n\nURL: ${messageUrl}`, '✅ Message Sent');
+            process.stdout.write(`${messageUrl}\n`);
+            process.exit(0);
+        }
         cliLogger.log('Creating thread...');
         const threadData = (await rest.post(Routes.threads(channelId, starterMessage.id), {
             body: {
@@ -470,21 +481,41 @@ cli
             await rest.put(Routes.threadMembers(threadData.id, resolvedUser.id));
         }
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
+        // Poll for session ID if the bot is expected to auto-start (not --notify-only).
+        // The bot picks up the thread and creates a session asynchronously;
+        // we wait briefly so the caller can reference the session immediately.
+        let newSessionId;
+        if (!notifyOnly) {
+            const { waitForSessionId } = await import('../wait-session.js');
+            newSessionId = await waitForSessionId({
+                threadId: threadData.id,
+                timeoutMs: 15_000,
+            }).catch((e) => {
+                cliLogger.warn(`Could not resolve session ID: ${e instanceof Error ? e.message : String(e)}`);
+                return undefined;
+            });
+        }
         const worktreeNote = worktreeName
             ? `\nWorktree: ${worktreeName} (will be created by bot)`
             : resolvedCwd
                 ? `\nWorking directory: ${resolvedCwd}`
                 : '';
+        const sessionLine = newSessionId ? `\nSession: ${newSessionId}` : '';
+        const directoryLine = projectDirectory ? `\nDirectory: ${projectDirectory}` : '';
         const successMessage = notifyOnly
-            ? `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nNotification created. Reply to start a session.\n\nURL: ${threadUrl}`
-            : `Thread: ${threadData.name}\nDirectory: ${projectDirectory}${worktreeNote}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`;
+            ? `Thread: ${threadData.name}${directoryLine}\n\nNotification created. Reply to start a session.\n\nURL: ${threadUrl}`
+            : `Thread: ${threadData.name}${directoryLine}${worktreeNote}${sessionLine}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`;
         note(successMessage, '✅ Thread Created');
-        cliLogger.log(threadUrl);
+        if (newSessionId)
+            process.stdout.write(`Session: ${newSessionId}\n`);
+        process.stdout.write(`${threadUrl}\n`);
         if (options.wait) {
+            // projectDirectory is guaranteed here: --wait is incompatible with --notify-only,
+            // and non-notify sends already require channelConfig above.
             const { waitAndOutputSession } = await import('../wait-session.js');
             await waitAndOutputSession({
                 threadId: threadData.id,
-                projectDirectory,
+                projectDirectory: projectDirectory,
                 waitStartedAtMs,
             });
         }

package/dist/cli-commands/session.js

@@ -166,9 +166,8 @@ cli
             const dir = project.worktree;
             cliLogger.log(`Trying project: ${dir}`);
             const otherClient = await initializeOpencodeForDirectory(dir);
-            if (otherClient instanceof Error) {
+            if (otherClient instanceof Error)
                 continue;
-            }
             const otherMarkdown = new ShareMarkdown(otherClient());
             const otherResult = await otherMarkdown.generate({
                 sessionID: sessionId,
@@ -387,15 +386,12 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
     const parsedRows = rows.flatMap((row) => {
-        const parsed = errore.try({
-            try: () => {
-                return JSON.parse(row.event_json);
-            },
-            catch: (error) => {
-                return new Error('Failed to parse persisted event JSON', {
-                    cause: error,
-                });
-            },
+        const parsed = errore.try(() => {
+            return JSON.parse(row.event_json);
+        }, (error) => {
+            return new Error('Failed to parse persisted event JSON', {
+                cause: error,
+            });
         });
         if (parsed instanceof Error) {
             cliLogger.warn(`Skipping invalid persisted event row ${row.id}: ${parsed.message}`);
@@ -499,6 +495,52 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('session abort <sessionId>', 'Abort a running session without archiving the thread')
+    .action(async (sessionId) => {
+    try {
+        await initDatabase();
+        const { token: botToken } = await resolveBotCredentials();
+        const rest = createDiscordRest(botToken);
+        // Try to resolve the project directory for the OpenCode abort call
+        const directory = await resolveSessionDirectoryFromDatabase({ sessionId });
+        if (directory instanceof Error) {
+            cliLogger.error(directory.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const serverResult = await initializeOpencodeForDirectory(directory);
+        if (serverResult instanceof Error) {
+            cliLogger.error(`Failed to initialize OpenCode: ${serverResult.message}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const client = serverResult();
+        // Don't pass directory — the server resolves sessions by ID regardless
+        // of the x-opencode-directory header, matching archiveThread's pattern.
+        // This avoids issues when --cwd was used (session directory != project directory).
+        const abortResult = await client.session.abort({
+            sessionID: sessionId,
+        }).catch((e) => new Error('Failed to abort session', { cause: e }));
+        if (abortResult instanceof Error) {
+            cliLogger.error(abortResult.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Post a message in the Discord thread so it's clear why the session stopped
+        const threadId = await getThreadIdBySessionId(sessionId);
+        if (threadId) {
+            await rest.post(Routes.channelMessages(threadId), {
+                body: { content: 'Session aborted via CLI' },
+            }).catch((e) => {
+                cliLogger.warn(`Could not post abort message to thread: ${e instanceof Error ? e.message : String(e)}`);
+            });
+        }
+        note(`Aborted session: ${sessionId}${threadId ? `\nThread ID: ${threadId}` : ''}`, '✅ Aborted');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('session discord-url <sessionId>', 'Print the Discord thread URL for a session')
     .option('--json', 'Output as JSON')

package/dist/cli-runner.js

@@ -107,7 +107,7 @@ export function isThreadChannelType(type) {
         ChannelType.AnnouncementThread,
     ].includes(type);
 }
-export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, }) {
+export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, splitInsteadOfAttach, }) {
     const discordMaxLength = 2000;
     if (prompt.length <= discordMaxLength) {
         return (await rest.post(Routes.channelMessages(channelId), {
@@ -118,6 +118,33 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
             },
         }));
     }
+    if (splitInsteadOfAttach) {
+        const { splitMarkdownForDiscord } = await import('./discord-utils.js');
+        const chunks = splitMarkdownForDiscord({
+            content: prompt,
+            maxLength: discordMaxLength,
+        });
+        let firstMessage;
+        for (let chunk of chunks) {
+            if (!chunk?.trim())
+                continue;
+            // Safety net: hard-truncate if splitting still produced an oversized chunk
+            if (chunk.length > discordMaxLength) {
+                chunk = chunk.slice(0, discordMaxLength - 4) + '...';
+            }
+            const message = (await rest.post(Routes.channelMessages(channelId), {
+                body: {
+                    content: chunk,
+                    // Only attach embeds to the first message
+                    ...(firstMessage ? {} : { embeds }),
+                    allowed_mentions: { parse: store.getState().allowedMentions },
+                },
+            }));
+            if (!firstMessage)
+                firstMessage = message;
+        }
+        return firstMessage;
+    }
     const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
     const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`;
     const tmpDir = path.join(process.cwd(), 'tmp');
@@ -759,8 +786,7 @@ export async function resolveCredentials({ forceRestartOnboarding, forceGateway,
                 options: [
                     {
                         value: 'gateway',
-                        disabled: true,
-                        label: 'Gateway (pre-built Kimaki bot, currently disabled because of Discord verification process. will be re-enabled soon)',
+                        label: 'Gateway (pre-built Kimaki bot, no setup needed)',
                     },
                     {
                         value: 'self_hosted',

package/dist/commands/abort.js

@@ -1,7 +1,7 @@
 // /abort command - Abort the current OpenCode request in this thread.
 import { ChannelType, MessageFlags, } from 'discord.js';
 import { getThreadSession } from '../database.js';
-import { initializeOpencodeForDirectory } from '../opencode.js';
+import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
@@ -35,7 +35,7 @@ export async function handleAbortCommand({ command, }) {
         await command.editReply('Could not determine project directory for this channel');
         return;
     }
-    const { projectDirectory } = resolved;
+    const { projectDirectory, workingDirectory } = resolved;
     const sessionId = await getThreadSession(channel.id);
     if (!sessionId) {
         await command.editReply('No active session in this thread');
@@ -48,13 +48,16 @@ export async function handleAbortCommand({ command, }) {
     }
     else {
         // No runtime but session exists — fall back to direct API abort
-        const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (getClient instanceof Error) {
-            await command.editReply(`Failed to abort: ${getClient.message}`);
+        const serverResult = await initializeOpencodeForDirectory(projectDirectory);
+        if (serverResult instanceof Error) {
+            await command.editReply(`Failed to abort: ${serverResult.message}`);
             return;
         }
         try {
-            await getClient().session.abort({ sessionID: sessionId });
+            const client = getOpencodeClient(workingDirectory);
+            if (client) {
+                await client.session.abort({ sessionID: sessionId, directory: workingDirectory });
+            }
         }
         catch (error) {
             logger.error('[ABORT] API abort failed:', error);

package/dist/commands/add-dir.js

@@ -132,7 +132,7 @@ export async function handleAddDirCommand({ command, }) {
         await command.editReply(`Failed to update session permissions: ${getClient.message}`);
         return;
     }
-    const client = getOpencodeClient(resolvedDirectories.projectDirectory);
+    const client = getOpencodeClient(resolvedDirectories.workingDirectory);
     if (!client) {
         await command.editReply('Failed to get OpenCode client');
         return;

package/dist/commands/btw.js

@@ -10,41 +10,52 @@ import { createLogger, LogPrefix } from '../logger.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 const logger = createLogger(LogPrefix.FORK);
 export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
-    const sessionId = await getThreadSession(sourceThread.id);
+    // Parallelize: session lookup + opencode init + parent channel resolve are independent
+    const [sessionId, getClientResult, textChannel] = await Promise.all([
+        getThreadSession(sourceThread.id),
+        initializeOpencodeForDirectory(projectDirectory),
+        resolveTextChannel(sourceThread),
+    ]);
     if (!sessionId) {
         return new Error('No active session in this thread');
     }
-    const getClient = await initializeOpencodeForDirectory(projectDirectory);
-    if (getClient instanceof Error) {
-        return new Error(`Failed to fork session: ${getClient.message}`, {
-            cause: getClient,
+    if (getClientResult instanceof Error) {
+        return new Error(`Failed to fork session: ${getClientResult.message}`, {
+            cause: getClientResult,
         });
     }
-    const forkResponse = await getClient().session.fork({
-        sessionID: sessionId,
-    });
-    if (!forkResponse.data) {
-        return new Error('Failed to fork session');
-    }
-    const textChannel = await resolveTextChannel(sourceThread);
     if (!textChannel) {
         return new Error('Could not resolve parent text channel');
     }
+    // Fork must succeed before creating the Discord thread to avoid orphan threads
+    const forkResponse = await getClientResult().session.fork({ sessionID: sessionId });
+    if (!forkResponse.data) {
+        return new Error('Failed to fork session');
+    }
     const forkedSession = forkResponse.data;
     const thread = await textChannel.threads.create({
         name: `btw: ${prompt}`.slice(0, 100),
         autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
         reason: `btw fork from session ${sessionId}`,
     });
+    // DB mapping must complete before user-visible actions so the thread is routable
     await setThreadSession(thread.id, forkedSession.id);
-    await thread.members.add(userId);
-    logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`);
+    // Parallelize: member add and status message are independent best-effort actions
     const sourceThreadLink = `<#${sourceThread.id}>`;
-    await sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`);
+    await Promise.all([
+        thread.members.add(userId).catch(() => { }),
+        sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`),
+    ]);
+    logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from source thread ${sourceThread.id} (session ${sessionId})`);
     const wrappedPrompt = [
         `The user asked a side question while you were working on another task.`,
         `This is a forked session whose ONLY goal is to answer this question.`,
-        `Do NOT continue, resume, or reference the previous task. Only answer the question below.\n`,
+        `Do NOT continue, resume, or reference the previous task. Only answer the question below.`,
+        ``,
+        `Parent session: ${sessionId} (thread <#${sourceThread.id}>)`,
+        `If the user asks you to send a message or follow-up to the parent session, use:`,
+        `  kimaki send --session ${sessionId} --prompt 'your message here'`,
+        ``,
         prompt,
     ].join('\n');
     const runtime = getOrCreateRuntime({

package/dist/commands/compact.js

@@ -54,7 +54,7 @@ export async function handleCompactCommand({ command, }) {
         });
         return;
     }
-    const client = getOpencodeClient(projectDirectory);
+    const client = getOpencodeClient(workingDirectory);
     if (!client) {
         await command.reply({
             content: 'Failed to get OpenCode client',

package/dist/commands/context-usage.js

@@ -1,10 +1,10 @@
 // /context-usage command - Show token usage and context window percentage for the current session.
 import { ChannelType, MessageFlags, } from 'discord.js';
+import { OpenCodeSdkError } from '../errors.js';
 import { getThreadSession } from '../database.js';
-import { initializeOpencodeForDirectory } from '../opencode.js';
+import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import * as errore from 'errore';
 const logger = createLogger(LogPrefix.SESSION);
 function getTokenTotal({ input, output, reasoning, cache, }) {
     return input + output + reasoning + cache.read + cache.write;
@@ -49,17 +49,25 @@ export async function handleContextUsageCommand({ command, }) {
         });
         return;
     }
-    const getClient = await initializeOpencodeForDirectory(projectDirectory);
-    if (getClient instanceof Error) {
+    const serverResult = await initializeOpencodeForDirectory(projectDirectory);
+    if (serverResult instanceof Error) {
         await command.reply({
-            content: `Failed to get context usage: ${getClient.message}`,
+            content: `Failed to get context usage: ${serverResult.message}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const client = getOpencodeClient(workingDirectory);
+    if (!client) {
+        await command.reply({
+            content: 'Failed to get OpenCode client',
             flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
         });
         return;
     }
     await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
     try {
-        const messagesResponse = await getClient().session.messages({
+        const messagesResponse = await client.session.messages({
             sessionID: sessionId,
             directory: workingDirectory,
         });
@@ -98,9 +106,8 @@ export async function handleContextUsageCommand({ command, }) {
         }, 0);
         // Fetch model context limit from provider API
         let contextLimit;
-        const providersResult = await errore.tryAsync(() => {
-            return getClient().provider.list({ directory: workingDirectory });
-        });
+        const providersResult = await client.provider.list({ directory: workingDirectory })
+            .catch((e) => new OpenCodeSdkError({ operation: 'provider.list', cause: e }));
         if (providersResult instanceof Error) {
             logger.error('[CONTEXT-USAGE] Failed to fetch provider info:', providersResult);
         }

package/dist/commands/fork.js

@@ -27,15 +27,12 @@ function getThreadChannel(channel) {
 }
 function parsePersistedEventRows({ rows, }) {
     return rows.flatMap((row) => {
-        const parsed = errore.try({
-            try: () => {
-                return JSON.parse(row.event_json);
-            },
-            catch: (error) => {
-                return new Error('Failed to parse persisted event JSON', {
-                    cause: error,
-                });
-            },
+        const parsed = errore.try(() => {
+            return JSON.parse(row.event_json);
+        }, (error) => {
+            return new Error('Failed to parse persisted event JSON', {
+                cause: error,
+            });
         });
         if (parsed instanceof Error) {
             forkLogger.warn(`[fork] Skipping invalid persisted event row ${row.id}: ${parsed.message}`);
@@ -230,8 +227,9 @@ export async function handleForkSelectMenu(interaction) {
         await setThreadSession(thread.id, forkedSession.id);
         // Add user to thread so it appears in their sidebar
         await thread.members.add(interaction.user.id);
-        sessionLogger.log(`Created forked session ${forkedSession.id} in thread ${thread.id}`);
-        await sendThreadMessage(thread, `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\``);
+        const sourceThreadLink = `<#${threadChannel.id}>`;
+        sessionLogger.log(`Created forked session ${forkedSession.id} in thread ${thread.id} from source thread ${threadChannel.id} (session ${sessionId})`);
+        await sendThreadMessage(thread, `**Forked session created!**\nFrom: ${sourceThreadLink} (\`${sessionId}\`)\nNew session: \`${forkedSession.id}\``);
         // Fetch and display the last assistant messages from the forked session
         const messagesResponse = await getClient().session.messages({
             sessionID: forkedSession.id,

package/dist/commands/login.js

@@ -10,7 +10,7 @@
 //   login_text:<hash>    — text prompt modal submission
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, ModalSubmitInteraction, ButtonBuilder, ButtonStyle, ChannelType, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
-import { initializeOpencodeForDirectory, getOpencodeServerPort, } from '../opencode.js';
+import { initializeOpencodeForDirectory, getOpencodeServerPort, getOpencodeServerAuthHeaders, } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
@@ -784,18 +784,11 @@ async function startOAuthFlow(interaction, ctx, hash) {
         const hasInputs = Object.keys(ctx.inputs).length > 0;
         const authorizeUrl = new URL(`/provider/${encodeURIComponent(ctx.providerId)}/oauth/authorize`, `http://127.0.0.1:${port}`);
         authorizeUrl.searchParams.set('directory', ctx.dir);
-        // Include basic auth if OPENCODE_SERVER_PASSWORD is set,
-        // matching the opencode server's optional basicAuth middleware.
         const fetchHeaders = {
             'Content-Type': 'application/json',
             'x-opencode-directory': ctx.dir,
+            ...getOpencodeServerAuthHeaders(),
         };
-        const serverPassword = process.env.OPENCODE_SERVER_PASSWORD;
-        if (serverPassword) {
-            const username = process.env.OPENCODE_SERVER_USERNAME || 'opencode';
-            fetchHeaders['Authorization'] =
-                `Basic ${Buffer.from(`${username}:${serverPassword}`).toString('base64')}`;
-        }
         const authorizeRes = await fetch(authorizeUrl, {
             method: 'POST',
             headers: fetchHeaders,