kimaki 0.9.0 → 0.10.0

package/dist/agent-model.e2e.test.js

@@ -20,7 +20,9 @@ import { setDataDir } from './config.js';
 import { store } from './store.js';
 import { startDiscordBot } from './discord-bot.js';
 import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, } from './database.js';
-import { getPrisma } from './db.js';
+import { getDb } from './db.js';
+import * as orm from 'drizzle-orm';
+import * as schema from './schema.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
 import { chooseLockPort, cleanupTestSessions, initTestGitRepo, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
@@ -379,13 +381,9 @@ describe('agent model resolution', () => {
       `);
     }, 15_000);
     test('reply message injects replied-message context', async () => {
-        const prisma = await getPrisma();
-        await prisma.channel_agents.deleteMany({
-            where: { channel_id: TEXT_CHANNEL_ID },
-        });
-        await prisma.channel_models.deleteMany({
-            where: { channel_id: TEXT_CHANNEL_ID },
-        });
+        const db = await getDb();
+        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
+        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
         const existingThreadIds = new Set((await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
             return thread.id;
         }));
@@ -429,10 +427,8 @@ describe('agent model resolution', () => {
     }, 15_000);
     test('new thread uses channel model when channel model preference is set', async () => {
         // Clear channel agent so model resolution falls through to channel model
-        const prisma = await getPrisma();
-        await prisma.channel_agents.deleteMany({
-            where: { channel_id: TEXT_CHANNEL_ID },
-        });
+        const db = await getDb();
+        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
         // Set channel model preference — simulates /model selecting a model at channel scope
         await setChannelModel({
             channelId: TEXT_CHANNEL_ID,
@@ -480,10 +476,8 @@ describe('agent model resolution', () => {
     }, 15_000);
     test('channel model with variant preference completes without error', async () => {
         // Clear channel agent so model resolution falls through to channel model
-        const prisma = await getPrisma();
-        await prisma.channel_agents.deleteMany({
-            where: { channel_id: TEXT_CHANNEL_ID },
-        });
+        const db = await getDb();
+        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
         // Set channel model with a variant (thinking level)
         // The deterministic provider doesn't support thinking, so the variant
         // is resolved but silently dropped (no matching thinking values).
@@ -610,14 +604,10 @@ describe('agent model resolution', () => {
     }, 20_000);
     test('thread created with no agent keeps default model after channel agent is set', async () => {
         // Clear any channel agent — thread starts with default (no agent)
-        const prisma = await getPrisma();
-        await prisma.channel_agents.deleteMany({
-            where: { channel_id: TEXT_CHANNEL_ID },
-        });
+        const db = await getDb();
+        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
         // Also clear channel model so we get the pure default
-        await prisma.channel_models.deleteMany({
-            where: { channel_id: TEXT_CHANNEL_ID },
-        });
+        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
         // 1. Send a message to create a thread (no channel agent set)
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
             content: 'Reply with exactly: default-thread-msg',

package/dist/channel-reference-permissions.e2e.test.js

@@ -0,0 +1,85 @@
+// E2e tests for granting external_directory permissions from #channel references.
+import { describe, expect, test } from 'vitest';
+import fs from 'node:fs';
+import { CHANNEL_REFERENCE_EXTERNAL_DIR, CHANNEL_REFERENCE_EXTERNAL_FILE, setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { setChannelDirectory } from './database.js';
+import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001021';
+const EXTERNAL_CHANNEL_ID = '200000000000001022';
+describe('channel reference permissions', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-channel-reference-e2e',
+        extraChannels: [{ id: EXTERNAL_CHANNEL_ID, name: 'external-project' }],
+        dirName: 'qa-channel-reference-e2e',
+        username: 'channel-reference-tester',
+    });
+    test('allows referenced project channel directories on new and existing sessions', async () => {
+        fs.mkdirSync(CHANNEL_REFERENCE_EXTERNAL_DIR, { recursive: true });
+        fs.writeFileSync(CHANNEL_REFERENCE_EXTERNAL_FILE, 'referenced channel file');
+        await setChannelDirectory({
+            channelId: EXTERNAL_CHANNEL_ID,
+            directory: CHANNEL_REFERENCE_EXTERNAL_DIR,
+            channelType: 'text',
+        });
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: `Use <#${EXTERNAL_CHANNEL_ID}> CHANNEL_REFERENCE_PERMISSION_MARKER first`,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name?.includes('CHANNEL_REFERENCE_PERMISSION_MARKER') ?? false;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'channel-reference-read-done',
+            timeout: 8_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'channel-reference-read-done',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: `Use <#${EXTERNAL_CHANNEL_ID}> CHANNEL_REFERENCE_PERMISSION_MARKER followup`,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'channel-reference-read-done',
+            afterUserMessageIncludes: 'followup',
+            timeout: 8_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'channel-reference-read-done',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const text = await th.text();
+        expect(text).toMatchInlineSnapshot(`
+      "--- from: user (channel-reference-tester)
+      Use <#200000000000001022> CHANNEL_REFERENCE_PERMISSION_MARKER first
+      --- from: assistant (TestBot)
+      *using deterministic-provider/deterministic-v2*
+      ⬥ reading referenced channel directory
+      ⬥ channel-reference-read-done
+      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+      --- from: user (channel-reference-tester)
+      Use <#200000000000001022> CHANNEL_REFERENCE_PERMISSION_MARKER followup
+      --- from: assistant (TestBot)
+      ⬥ reading referenced channel directory
+      ⬥ channel-reference-read-done
+      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    `);
+        expect(text).not.toContain('Permission Required');
+    });
+});

package/dist/cli-commands/bot.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';

package/dist/cli-commands/maintenance.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';

package/dist/cli-commands/misc.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';

package/dist/cli-commands/project.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -70,10 +70,10 @@ cli
         guild = foundGuild;
     }
     else {
-        const existingChannelId = await (await getPrisma()).channel_directories.findFirst({
+        const existingChannelId = await (await getDb()).query.channel_directories.findFirst({
             where: { channel_type: 'text' },
             orderBy: { created_at: 'desc' },
-            select: { channel_id: true },
+            columns: { channel_id: true },
         }).then((row) => row?.channel_id);
         if (existingChannelId) {
             try {
@@ -168,8 +168,8 @@ cli
     .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
     .action(async (options) => {
     await initDatabase();
-    const prisma = await getPrisma();
-    const channels = await prisma.channel_directories.findMany({
+    const db = await getDb();
+    const channels = await db.query.channel_directories.findMany({
         where: { channel_type: 'text' },
         orderBy: { created_at: 'desc' },
     });

package/dist/cli-commands/send.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -20,7 +20,7 @@ import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-e
 import { createDiscordRest } from '../discord-urls.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js';
-import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
+import { execAsync, resolveSessionWorkingDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
@@ -36,7 +36,7 @@ cli
     .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
     .option('--notify-only', 'Create notification thread without starting AI session')
     .option('--worktree [name]', 'Create git worktree for session (name optional, derives from thread name)')
-    .option('--cwd <path>', 'Start session in an existing git worktree directory instead of the main project directory')
+    .option('--cwd <path>', 'Start session in an existing project subfolder or git worktree directory')
     .option('-u, --user <user>', 'Discord user ID, mention, or username to add to thread')
     .option('--agent <agent>', 'Agent to use for the session')
     .option('--model <model>', 'Model to use (format: provider/model)')
@@ -104,6 +104,7 @@ cli
             }
             process.exit(EXIT_NO_RESTART);
         }
+        const waitStartedAtMs = options.wait ? Date.now() : undefined;
         if (!existingThreadMode && options.worktree && notifyOnly) {
             cliLogger.error('Cannot use --worktree with --notify-only');
             process.exit(EXIT_NO_RESTART);
@@ -208,10 +209,10 @@ cli
                     });
                     // Get guild from existing channels or first available
                     const guild = await (async () => {
-                        const existingChannelId = await (await getPrisma()).channel_directories.findFirst({
+                        const existingChannelId = await (await getDb()).query.channel_directories.findFirst({
                             where: { channel_type: 'text' },
                             orderBy: { created_at: 'desc' },
-                            select: { channel_id: true },
+                            columns: { channel_id: true },
                         }).then((row) => row?.channel_id);
                         if (existingChannelId) {
                             try {
@@ -340,6 +341,7 @@ cli
                 await waitAndOutputSession({
                     threadId: targetThreadId,
                     projectDirectory: channelConfig.directory,
+                    waitStartedAtMs,
                 });
             }
             process.exit(0);
@@ -356,10 +358,10 @@ cli
             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;
-        // Validate --cwd is an existing git worktree of the project
+        // Validate --cwd is inside the project or an existing git worktree.
         let resolvedCwd;
         if (options.cwd) {
-            const cwdResult = await validateWorktreeDirectory({
+            const cwdResult = await resolveSessionWorkingDirectory({
                 projectDirectory,
                 candidatePath: options.cwd,
             });
@@ -367,7 +369,7 @@ cli
                 cliLogger.error(cwdResult.message);
                 process.exit(EXIT_NO_RESTART);
             }
-            resolvedCwd = cwdResult;
+            resolvedCwd = cwdResult.directory;
         }
         const resolvedUser = await resolveDiscordUserOption({
             user: options.user,
@@ -483,6 +485,7 @@ cli
             await waitAndOutputSession({
                 threadId: threadData.id,
                 projectDirectory,
+                waitStartedAtMs,
             });
         }
         process.exit(0);

package/dist/cli-commands/session.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getThreadWorktree } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -26,6 +26,30 @@ import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializ
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 const cli = goke();
+async function resolveSessionDirectoryFromDatabase({ sessionId, }) {
+    const threadId = await getThreadIdBySessionId(sessionId);
+    if (threadId) {
+        const worktree = await getThreadWorktree(threadId);
+        if (worktree?.status === 'ready' && worktree.worktree_directory) {
+            return worktree.worktree_directory;
+        }
+        const { token: botToken } = await resolveBotCredentials({});
+        const rest = createDiscordRest(botToken);
+        const threadData = (await rest.get(Routes.channel(threadId)));
+        if (!isThreadChannelType(threadData.type)) {
+            return new Error(`Channel is not a thread: ${threadId}`);
+        }
+        if (!threadData.parent_id) {
+            return new Error(`Thread has no parent channel: ${threadId}`);
+        }
+        const channelConfig = await getChannelDirectory(threadData.parent_id);
+        if (!channelConfig) {
+            return new Error(`Thread parent channel is not configured with a project directory: ${threadData.parent_id}`);
+        }
+        return channelConfig.directory;
+    }
+    return new Error(`Session is not linked to a Kimaki thread in the local database: ${sessionId}`);
+}
 cli
     .command('session list', 'List all OpenCode sessions, marking which were started via Kimaki')
     .option('--project <path>', 'Project directory to list sessions for (defaults to cwd)')
@@ -47,9 +71,9 @@ cli
             process.exit(0);
         }
         // Look up which sessions were started via kimaki (have a thread mapping)
-        const prisma = await getPrisma();
-        const threadSessions = await prisma.thread_sessions.findMany({
-            select: { thread_id: true, session_id: true },
+        const db = await getDb();
+        const threadSessions = await db.query.thread_sessions.findMany({
+            columns: { thread_id: true, session_id: true },
         });
         const sessionToThread = new Map(threadSessions
             .filter((row) => row.session_id !== '')
@@ -162,6 +186,30 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('session wait <sessionId>', 'Wait for a session to finish, then print its conversation as markdown')
+    .action(async (sessionId) => {
+    try {
+        await initDatabase();
+        const projectDirectory = await resolveSessionDirectoryFromDatabase({
+            sessionId,
+        });
+        if (projectDirectory instanceof Error) {
+            cliLogger.error(projectDirectory.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const { waitAndOutputExistingSession } = await import('../wait-session.js');
+        await waitAndOutputExistingSession({
+            sessionId,
+            projectDirectory,
+        });
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('session search <query>', 'Search past sessions for text or /regex/flags in the selected project')
     .option('--project <path>', 'Project directory (defaults to cwd)')
@@ -223,9 +271,9 @@ cli
             cliLogger.log('No sessions found');
             process.exit(0);
         }
-        const prisma = await getPrisma();
-        const threadSessions = await prisma.thread_sessions.findMany({
-            select: { thread_id: true, session_id: true },
+        const db = await getDb();
+        const threadSessions = await db.query.thread_sessions.findMany({
+            columns: { thread_id: true, session_id: true },
         });
         const sessionToThread = new Map(threadSessions
             .filter((row) => row.session_id !== '')

package/dist/cli-commands/task.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';

package/dist/cli-commands/user.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -89,25 +89,25 @@ cli
 });
 cli
     .command('tunnel', 'Expose a local port via tunnel')
-    .option('-p, --port <port>', 'Local port to expose (required)')
+    .option('-p, --port <port>', 'Local port to expose (optional when command output reveals one)')
     .option('-t, --tunnel-id [id]', 'Custom tunnel ID (only for services safe to expose publicly; prefer random default)')
     .option('-h, --host [host]', 'Local host (default: localhost)')
     .option('-s, --server [url]', 'Tunnel server URL')
     .option('-k, --kill', 'Kill any existing process on the port before starting')
     .action(async (options) => {
-    const { runTunnel, parseCommandFromArgv, CLI_NAME } = await import('traforo/run-tunnel');
-    if (!options.port) {
-        cliLogger.error('Error: --port is required');
-        cliLogger.error(`\nUsage: kimaki tunnel -p <port> [-- command]`);
+    const { runTunnel, parseCommandFromArgv } = await import('traforo/run-tunnel');
+    const { command } = parseCommandFromArgv(process.argv);
+    if (!options.port && command.length === 0) {
+        cliLogger.error('Error: --port is required unless a command is provided after --');
+        cliLogger.error(`\nUsage: kimaki tunnel [-- command]`);
+        cliLogger.error(`   or: kimaki tunnel --port <port>`);
         process.exit(EXIT_NO_RESTART);
     }
-    const port = parseInt(options.port, 10);
-    if (isNaN(port) || port < 1 || port > 65535) {
+    const port = options.port ? parseInt(options.port, 10) : undefined;
+    if (options.port && (!port || port < 1 || port > 65535)) {
         cliLogger.error(`Error: Invalid port number: ${options.port}`);
         process.exit(EXIT_NO_RESTART);
     }
-    // Parse command after -- from argv
-    const { command } = parseCommandFromArgv(process.argv);
     await runTunnel({
         port,
         tunnelId: options.tunnelId || undefined,

package/dist/cli-runner.js

@@ -3,7 +3,9 @@
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, select, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl, generateDiscordInstallUrlForBot, KIMAKI_GATEWAY_APP_ID, KIMAKI_WEBSITE_URL, abbreviatePath, } from './utils.js';
 import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, createProjectChannels, createDefaultKimakiChannel, } from './discord-bot.js';
-import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getPrisma, } from './database.js';
+import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getDb, } from './database.js';
+import * as orm from 'drizzle-orm';
+import * as dbSchema from './schema.js';
 import { selectResolvedCommand } from './opencode-command.js';
 import { Events, ChannelType, Routes, AttachmentBuilder, } from 'discord.js';
 import { discordApiUrl, getDiscordRestApiUrl, getGatewayProxyRestBaseUrl, getInternetReachableBaseUrl } from './discord-urls.js';
@@ -327,8 +329,8 @@ export async function resolveGatewayInstallCredentials() {
     if (!KIMAKI_GATEWAY_APP_ID) {
         return new Error('Gateway mode is not available yet. KIMAKI_GATEWAY_APP_ID is not configured.');
     }
-    const prisma = await getPrisma();
-    const gatewayBot = await prisma.bot_tokens.findUnique({
+    const db = await getDb();
+    const gatewayBot = await db.query.bot_tokens.findFirst({
         where: { app_id: KIMAKI_GATEWAY_APP_ID },
     });
     if (gatewayBot?.client_id && gatewayBot.client_secret) {
@@ -687,7 +689,7 @@ export async function resolveCredentials({ forceRestartOnboarding, forceGateway,
     // directly. This lets users switch back and forth between modes without
     // re-running the onboarding wizard each time.
     const hasGatewayCreds = (forceGateway && existingBot?.mode !== 'gateway')
-        ? await (await getPrisma()).bot_tokens.findUnique({
+        ? await (await getDb()).query.bot_tokens.findFirst({
             where: { app_id: KIMAKI_GATEWAY_APP_ID },
         })
         : undefined;
@@ -1029,10 +1031,9 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
     // processes (send, upload-to-discord, project list) pick the correct bot.
     // getBotTokenWithMode() orders by last_used_at DESC as cross-process
     // source of truth.
-    await (await getPrisma()).bot_tokens.update({
-        where: { app_id: appId },
-        data: { last_used_at: new Date() },
-    });
+    await (await getDb()).update(dbSchema.bot_tokens)
+        .set({ last_used_at: new Date() })
+        .where(orm.eq(dbSchema.bot_tokens.app_id, appId));
     // skipChannelSetup: when true, skip interactive project/channel selection
     // and go straight to bot startup. Channel sync happens in the background.
     //
@@ -1041,9 +1042,9 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
     // Force channel setup when: first-time quick-start with no channels configured
     // and TTY is available, or user explicitly passed --add-channels.
     const isHeadlessGateway = isGatewayMode && !canUseInteractivePrompts();
-    const hasConfiguredTextChannels = Boolean(await (await getPrisma()).channel_directories.findFirst({
+    const hasConfiguredTextChannels = Boolean(await (await getDb()).query.channel_directories.findFirst({
         where: { channel_type: 'text' },
-        select: { channel_id: true },
+        columns: { channel_id: true },
     }));
     const skipChannelSetup = isHeadlessGateway || (() => {
         // Wizard source always shows channel setup (user just completed onboarding)

package/dist/cli-send-thread.e2e.test.js

@@ -23,7 +23,7 @@ import { startDiscordBot } from './discord-bot.js';
 import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelMentionMode, setChannelVerbosity, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, stopOpencodeServer, } from './opencode.js';
-import { chooseLockPort, cleanupTestSessions, initTestGitRepo, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { chooseAvailableLockPort, cleanupTestSessions, initTestGitRepo, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
 import YAML from 'yaml';
 const TEST_USER_ID = '200000000000000830';
 const TEXT_CHANNEL_ID = '200000000000000831';
@@ -113,7 +113,7 @@ describe('kimaki send --channel thread creation', () => {
     beforeAll(async () => {
         testStartTime = Date.now();
         directories = createRunDirectories();
-        const lockPort = chooseLockPort({ key: 'cli-send-thread-e2e' });
+        const lockPort = await chooseAvailableLockPort({ key: 'cli-send-thread-e2e' });
         process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
         setDataDir(directories.dataDir);
         previousDefaultVerbosity = store.getState().defaultVerbosity;

package/dist/commands/last-sessions.js

@@ -3,25 +3,26 @@
 // clickable thread links and project names via Discord CV2 components.
 import { ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'discord.js';
 import path from 'node:path';
-import { getPrisma } from '../db.js';
+import { getDb } from '../db.js';
 import { getChannelDirectory } from '../database.js';
 import { splitTablesFromMarkdown } from '../format-tables.js';
 import { formatTimeAgo } from './worktrees.js';
 const MAX_ROWS = 20;
 async function fetchRecentSessions({ client, }) {
-    const prisma = await getPrisma();
+    const db = await getDb();
     // Fetch all thread sessions with their most recent event timestamp.
-    // Prisma doesn't support ORDER BY aggregated subquery, so we fetch all
-    // sessions with their latest event and sort in JS.
-    const sessions = await prisma.thread_sessions.findMany({
-        select: {
+    // Fetch all sessions with their latest event and sort in JS.
+    const sessions = await db.query.thread_sessions.findMany({
+        columns: {
             thread_id: true,
             session_id: true,
             created_at: true,
+        },
+        with: {
             session_events: {
                 orderBy: { timestamp: 'desc' },
-                take: 1,
-                select: { timestamp: true },
+                limit: 1,
+                columns: { timestamp: true },
             },
         },
     });

package/dist/commands/unset-model.js

@@ -1,7 +1,9 @@
 // /unset-model-override command - Remove model overrides and use default instead.
 import { ChatInputCommandInteraction, ChannelType, MessageFlags, } from 'discord.js';
 import { getChannelModel, getSessionModel, getThreadSession, clearSessionModel, } from '../database.js';
-import { getPrisma } from '../db.js';
+import { getDb } from '../db.js';
+import * as orm from 'drizzle-orm';
+import * as schema from '../schema.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
@@ -90,10 +92,8 @@ export async function handleUnsetModelCommand({ interaction, appId, }) {
     }
     else if (channelPref) {
         // Clear channel override
-        const prisma = await getPrisma();
-        await prisma.channel_models.deleteMany({
-            where: { channel_id: targetChannelId },
-        });
+        const db = await getDb();
+        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, targetChannelId));
         clearedType = 'channel';
         clearedModel = channelPref.modelId;
         unsetModelLogger.log(`[UNSET-MODEL] Cleared channel model for ${targetChannelId}`);

package/dist/commands/verbosity.js

@@ -5,7 +5,7 @@
 // 'text_only': only shows text responses
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, MessageFlags, ChannelType, } from 'discord.js';
 import { getChannelVerbosity, setChannelVerbosity, } from '../database.js';
-import { getPrisma } from '../db.js';
+import { getDb } from '../db.js';
 import { store } from '../store.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const verbosityLogger = createLogger(LogPrefix.VERBOSITY);
@@ -45,8 +45,8 @@ function resolveChannelId(channel) {
  * Returns the override value if it exists, null otherwise.
  */
 async function getChannelVerbosityOverride(channelId) {
-    const prisma = await getPrisma();
-    const row = await prisma.channel_verbosity.findUnique({
+    const db = await getDb();
+    const row = await db.query.channel_verbosity.findFirst({
         where: { channel_id: channelId },
     });
     if (row?.verbosity) {