kimaki 0.26.0 → 0.28.0

package/src/default-channel-provisioning.test.ts

@@ -0,0 +1,155 @@
+// Verify startup default channels require local self-hosted guild configuration.
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterEach, beforeEach, expect, test } from 'vitest'
+import { ChannelType, Client, Events, GatewayIntentBits } from 'discord.js'
+import { DigitalDiscord } from 'discord-digital-twin/src'
+import { setDataDir } from './config.js'
+import { closeDb } from './db.js'
+import { findChannelsByDirectory, initDatabase, setChannelDirectory } from './database.js'
+import { createProjectChannels } from './channel-management.js'
+import { ensureDefaultChannelsWithWelcome } from './cli-runner.js'
+import { registerInteractionHandler } from './interaction-handler.js'
+
+const trustedGuildId = '100000000000000111'
+const otherGuildId = '100000000000000222'
+const projectChannelId = '100000000000000333'
+let directory: string
+let discord: DigitalDiscord
+let client: Client
+
+beforeEach(async () => {
+  const root = path.resolve('tmp/default-channel-provisioning')
+  fs.mkdirSync(root, { recursive: true })
+  directory = fs.mkdtempSync(path.join(root, 'run-'))
+  setDataDir(directory)
+  await closeDb()
+  await initDatabase()
+  discord = new DigitalDiscord({
+    dbUrl: `file:${path.join(directory, 'discord.db')}`,
+    users: [{ id: '100000000000000555', username: 'server-owner' }],
+    guilds: [
+      { id: trustedGuildId, name: 'Configured', ownerId: '100000000000000555', channels: [
+        { id: projectChannelId, name: 'project', type: ChannelType.GuildText },
+      ] },
+      { id: otherGuildId, name: 'Unconfigured', ownerId: '100000000000000555', channels: [
+        { name: 'project', type: ChannelType.GuildText, topic: directory },
+      ] },
+    ],
+  })
+  await discord.start()
+  client = new Client({
+    intents: [GatewayIntentBits.Guilds],
+    rest: { api: discord.restUrl, version: '10' },
+  })
+  const ready = new Promise<void>((resolve) => client.once(Events.ClientReady, () => resolve()))
+  await client.login(discord.botToken)
+  await ready
+})
+
+afterEach(async () => {
+  await client?.destroy()
+  await discord?.stop()
+  await closeDb()
+  fs.rmSync(directory, { recursive: true, force: true })
+})
+
+test('self-hosted startup does not configure any guild without a live local mapping', async () => {
+  await setChannelDirectory({
+    channelId: '100000000000000444',
+    directory,
+    channelType: 'text',
+    guildId: otherGuildId,
+  })
+  const before = await findChannelsByDirectory({})
+  const created = await ensureDefaultChannelsWithWelcome({
+    guilds: [...client.guilds.cache.values()], discordClient: client,
+    appId: discord.botUserId, isGatewayMode: false,
+  })
+  expect(created).toEqual([])
+  expect(await findChannelsByDirectory({})).toEqual(before)
+  for (const guild of client.guilds.cache.values()) {
+    expect((await guild.channels.fetch()).size).toBe(1)
+  }
+})
+
+test('setup commands require a local channel mapping even for the server owner', async () => {
+  registerInteractionHandler({ discordClient: client, appId: discord.botUserId })
+  const channel = discord.channel(projectChannelId)
+  // An invalid project name keeps the regression safe even when the guard fails.
+  const options = [{ name: 'name', type: 3, value: '---' }]
+  const ignored = await channel.user('100000000000000555').runSlashCommand({
+    name: 'create-new-project', options,
+  })
+  for (let attempt = 0; attempt < 10; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, 20))
+    expect((await channel.getInteractionResponse(ignored.id))?.acknowledged ?? false).toBe(false)
+  }
+  expect(await findChannelsByDirectory({})).toEqual([])
+
+  await setChannelDirectory({ channelId: projectChannelId, directory, channelType: 'text' })
+  const allowed = await channel.user('100000000000000555').runSlashCommand({
+    name: 'create-new-project', options,
+  })
+  await channel.waitForInteractionAck({ interactionId: allowed.id })
+  await channel.waitForBotReply()
+  expect(await channel.text()).toMatchInlineSnapshot(`
+    "--- from: assistant (TestBot)
+    Invalid project name"
+  `)
+})
+
+for (const setup of ['legacy mapping', 'explicit onboarding']) {
+  test(`self-hosted startup provisions only the configured guild after ${setup}`, async () => {
+    const guild = client.guilds.cache.get(trustedGuildId)!
+    if (setup === 'legacy mapping') {
+      await setChannelDirectory({ channelId: projectChannelId, directory, channelType: 'text' })
+    } else {
+      await createProjectChannels({ guild, projectDirectory: path.join(directory, 'project'), analyticsSource: 'onboarding' })
+    }
+    expect((await findChannelsByDirectory({}))[0]?.guild_id).toBeNull()
+    // Fetching actual guild channels must work even when startup cache is empty.
+    guild.channels.cache.clear()
+    const created = await ensureDefaultChannelsWithWelcome({
+      guilds: [...client.guilds.cache.values()], discordClient: client,
+      appId: discord.botUserId, isGatewayMode: false,
+    })
+    for (const channel of created) {
+      expect(await discord.channel(channel.id).text()).toMatchInlineSnapshot(`
+        "--- from: assistant (TestBot)
+        **Kimaki** lets you code from Discord. Send a message in any project channel and an AI agent edits code, runs commands, and searches your codebase — all on your machine.
+        **What you can do:**
+        - Use \`/add-project\` to create a Discord channel linked to one OpenCode project (git repo)
+        - Collaborate with teammates in the same session
+        - Upload images and files, the bot can share screenshots back
+        Want to build an example browser game? Respond in this thread."
+      `)
+    }
+    expect(created.map((channel) => channel.guildId)).toEqual([trustedGuildId])
+    expect((await client.guilds.cache.get(otherGuildId)!.channels.fetch()).size).toBe(1)
+    expect(await ensureDefaultChannelsWithWelcome({
+      guilds: [...client.guilds.cache.values()], discordClient: client,
+      appId: discord.botUserId, isGatewayMode: false,
+    })).toEqual([])
+  })
+}
+
+test('gateway startup provisions every proxy-authorized guild without local mappings', async () => {
+  const created = await ensureDefaultChannelsWithWelcome({
+    guilds: [...client.guilds.cache.values()], discordClient: client,
+    appId: discord.botUserId, isGatewayMode: true,
+  })
+  for (const channel of created) {
+    expect(await discord.channel(channel.id).text()).toMatchInlineSnapshot(`
+      "--- from: assistant (TestBot)
+      **Kimaki** lets you code from Discord. Send a message in any project channel and an AI agent edits code, runs commands, and searches your codebase — all on your machine.
+      **What you can do:**
+      - Use \`/add-project\` to create a Discord channel linked to one OpenCode project (git repo)
+      - Collaborate with teammates in the same session
+      - Upload images and files, the bot can share screenshots back
+      Want to build an example browser game? Respond in this thread."
+    `)
+  }
+  expect(created.map((channel) => channel.guildId).sort()).toEqual([trustedGuildId, otherGuildId])
+  expect(await findChannelsByDirectory({})).toHaveLength(2)
+})

package/src/discord-bot.ts

@@ -23,6 +23,7 @@ import {
   getChannelMentionMode,
   getChannelDirectory,
   cancelAllPendingIpcRequests,
+  consumeSessionSleepWake,
   deleteChannelDirectoryById,
   createPendingWorkspace,
   setWorkspaceReady,
@@ -33,6 +34,7 @@ import {
 import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js'
 import { resolveSessionWorkingDirectory, git, isGitRepositoryRoot } from './worktrees.js'
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js'
+import { STATUS_PREFIX } from './message-formatting.js'
 import {
   escapeBackticksInCodeBlocks,
   splitMarkdownForDiscord,
@@ -88,6 +90,8 @@ import {
   getRuntime,
   getOrCreateRuntime,
   disposeRuntime,
+  reserveThreadIngress,
+  runInThreadIngressSlot,
 } from './session-handler/thread-session-runtime.js'
 import { runShellCommand } from './commands/run-command.js'
 import { registerInteractionHandler } from './interaction-handler.js'
@@ -112,7 +116,7 @@ export {
   closeDatabase,
   getChannelDirectory,
 } from './database.js'
-export { initializeOpencodeForDirectory } from './opencode.js'
+export { initializeOpencodeForDirectory, assertCompatibleOpencodeVersion } from './opencode.js'
 export {
   escapeBackticksInCodeBlocks,
   splitMarkdownForDiscord,
@@ -144,6 +148,11 @@ import path from 'node:path'
 import dedent from 'string-dedent'
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js'
 import { writeHeapSnapshot, startHeapMonitor } from './heap-monitor.js'
+import {
+  flushCpuProfiling,
+  startStdinCpuProfListener,
+  stopStdinCpuProfListener,
+} from './cpu-profiler.js'
 import { startTaskRunner } from './task-runner.js'
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
 // Each session's event.subscribe() holds a connection; without enough connections,
@@ -435,8 +444,8 @@ export async function startDiscordBot({
       discordLogger.error(
         `[GATEWAY] Shard ${shardId} exceeded ${MAX_RECONNECT_ATTEMPTS} reconnect attempts, self-restarting`,
       )
-      // Self-restart: cleanup, then exit non-zero so the bin.ts wrapper
-      // restarts us. Without the wrapper this exits after logging a warning.
+      // Self-restart: cleanup, then SIGKILL so the bin.ts wrapper
+      // restarts us. Without the wrapper this dies after logging a warning.
       void selfRestart('gateway-reconnect-limit')
     }
   })
@@ -473,6 +482,11 @@ export async function startDiscordBot({
   })
 
   discordClient.on(Events.MessageCreate, async (message: Message) => {
+    const threadIngressSlot =
+      message.channel.isThread() || message.channel.type === ChannelType.GuildText
+        ? reserveThreadIngress(message.channel.id)
+        : undefined
+    await runInThreadIngressSlot(threadIngressSlot, async () => {
     try {
       const isSelfBotMessage = Boolean(
         discordClient.user && message.author?.id === discordClient.user.id,
@@ -727,6 +741,7 @@ export async function startDiscordBot({
         ) {
           const shellCmd = message.content.slice(1).trim()
           if (shellCmd) {
+            threadIngressSlot?.release()
             const shellDir =
               worktreeInfo?.status === 'ready' &&
               worktreeInfo.workspace_directory
@@ -752,6 +767,7 @@ export async function startDiscordBot({
             ? extractBtwSuffix(message.content || '')
             : null
         if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
+          threadIngressSlot?.release()
           const btwSdkDir =
             worktreeInfo?.status === 'ready' &&
             worktreeInfo.workspace_directory
@@ -821,7 +837,8 @@ export async function startDiscordBot({
         // Cancel interactive UI when a real user sends a message.
         // Context-only messages (user-to-user replies) should not interrupt
         // the active run or dismiss pending UI.
-        if (!message.author.bot && !isCliInjectedPrompt && !isLeadingMentionToOtherUser) {
+        const dismissSourceUi = async () => {
+          if (message.author.bot || isCliInjectedPrompt || isLeadingMentionToOtherUser) return
           cancelPendingActionButtons(thread.id)
           cancelHtmlActionsForThread(thread.id)
           const dismissedPermission = await cancelPendingPermission(thread.id)
@@ -839,6 +856,27 @@ export async function startDiscordBot({
           }
           void cancelPendingFileUpload(thread.id)
         }
+        if (!hasVoiceAttachment) {
+          await dismissSourceUi()
+        }
+
+        // A sleep wake only becomes a turn if it can still claim its own row.
+        // The claim fails when the user cancelled the sleep while the wake was
+        // being posted, so the superseded wake is dropped instead of starting a
+        // turn the user already replaced. Cancellation for every other kind of
+        // message happens inside runtime.enqueueIncoming().
+        const isSleepWake = Boolean(promptMarker?.sleepWake)
+        if (isSleepWake) {
+          const claimedWake = promptMarker?.sleepId
+            ? await consumeSessionSleepWake({ deliveryId: promptMarker.sleepId })
+            : false
+          if (!claimedWake) {
+            discordLogger.log(
+              `[SLEEP] ignoring superseded wake in thread ${thread.id}`,
+            )
+            return
+          }
+        }
 
         // Expensive pre-processing (voice transcription, context fetch,
         // attachment download) runs inside the runtime's serialized
@@ -859,6 +897,7 @@ export async function startDiscordBot({
           permissions: cliInjectedPermissions,
           injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
           parentSessionId: cliInjectedParentSessionId,
+          isSleepWake: isSleepWake || undefined,
           noReply: isLeadingMentionToOtherUser || undefined,
           sessionStartSource: sessionStartSource
             ? {
@@ -867,8 +906,8 @@ export async function startDiscordBot({
                 scheduledTaskRunId: sessionStartSource.scheduledTaskRunId,
               }
             : undefined,
-          preprocess: () => {
-            return preprocessExistingThreadMessage({
+          preprocess: async () => {
+            const result = await preprocessExistingThreadMessage({
               message,
               thread,
               projectDirectory: resolvedProjectDir,
@@ -877,6 +916,12 @@ export async function startDiscordBot({
               hasVoiceAttachment,
               appId: currentAppId,
             })
+            // Routing must finish before touching source UI. This chain is separate
+            // from dispatchAction, so abort waiting does not block session events.
+            if (hasVoiceAttachment && !result.skip) {
+              await dismissSourceUi()
+            }
+            return result
           },
         })
 
@@ -955,6 +1000,7 @@ export async function startDiscordBot({
         if (message.content?.startsWith('!')) {
           const shellCmd = message.content.slice(1).trim()
           if (shellCmd) {
+            threadIngressSlot?.release()
             const loadingReply = await message.reply({
               content: `Running \`${shellCmd.slice(0, 1900)}\`...`,
             })
@@ -1038,14 +1084,9 @@ export async function startDiscordBot({
           })
         }
 
-        const sessionDirectory = await (async () => {
-          if (!worktreePromise) {
-            return projectDirectory
-          }
-          const result = await worktreePromise
-          if (result instanceof Error) return projectDirectory
-          return result
-        })()
+        const worktreeResult = worktreePromise ? await worktreePromise : projectDirectory
+        if (worktreeResult instanceof Error) return
+        const sessionDirectory = worktreeResult
 
         const channelRuntime = getOrCreateRuntime({
           threadId: thread.id,
@@ -1094,6 +1135,7 @@ export async function startDiscordBot({
         )
       }
     }
+    })
   })
 
   // Handle user message edits to update queued messages.
@@ -1149,7 +1191,7 @@ export async function startDiscordBot({
           )
           await sendThreadMessage(
             channel,
-            `⬦ **${displayName}** removed message from queue`,
+            `${STATUS_PREFIX}**${displayName}** removed message from queue`,
           )
         } else {
           discordLogger.log(
@@ -1157,7 +1199,7 @@ export async function startDiscordBot({
           )
           await sendThreadMessage(
             channel,
-            `⬦ **${displayName}** edited queued message`,
+            `${STATUS_PREFIX}**${displayName}** edited queued message`,
           )
         }
       }
@@ -1188,7 +1230,7 @@ export async function startDiscordBot({
       )
       await sendThreadMessage(
         channel,
-        `⬦ **${removed.username}** removed message from queue`,
+        `${STATUS_PREFIX}**${removed.username}** removed message from queue`,
       )
     } catch (error) {
       discordLogger.error(
@@ -1392,17 +1434,9 @@ export async function startDiscordBot({
 
       const botThreadStartSource = parseSessionStartSourceFromMarker(marker)
 
-      const sessionDirectory = await (async () => {
-        if (cwdDirectory) {
-          return cwdDirectory
-        }
-        if (!worktreePromise) {
-          return projectDirectory
-        }
-        const result = await worktreePromise
-        if (result instanceof Error) return projectDirectory
-        return result
-      })()
+      const worktreeResult = worktreePromise ? await worktreePromise : undefined
+      if (worktreeResult instanceof Error) return
+      const sessionDirectory = cwdDirectory ?? worktreeResult ?? projectDirectory
 
       const runtime = getOrCreateRuntime({
         threadId: thread.id,
@@ -1505,6 +1539,7 @@ export async function startDiscordBot({
   }
 
   startHeapMonitor()
+  startStdinCpuProfListener()
   const stopTaskRunner = startTaskRunner({ token })
   const stopRuntimeIdleSweeper = startRuntimeIdleSweeper()
 
@@ -1533,6 +1568,14 @@ export async function startDiscordBot({
     global.shuttingDown = true
 
     try {
+      stopStdinCpuProfListener()
+      const flushed = await flushCpuProfiling()
+      if (flushed instanceof Error) {
+        discordLogger.warn(
+          'Failed to flush CPU profile on shutdown:',
+          flushed.message,
+        )
+      }
       await stopRuntimeIdleSweeper()
       await stopTaskRunner()
 
@@ -1626,13 +1669,11 @@ export async function startDiscordBot({
     })
   })
 
-  // Self-restart: exit with code 1 so the bin.ts wrapper restarts us with
-  // exponential backoff and crash-loop detection. When running without the
-  // wrapper (e.g. `tsx src/cli.ts`), the process just exits and the user
-  // sees the non-zero exit code — they should use `tsx src/bin.ts` instead
-  // for auto-restart support. The previous detached-spawn fallback was
-  // unreliable: process.exit(0) could kill the child before it started,
-  // there was no backoff between restarts, and spawn failures were silent.
+  // Self-restart: die so the bin.ts wrapper restarts us with exponential
+  // backoff and crash-loop detection. process.exit() can hang joining native
+  // worker threads after Discord gateway failures, so SIGKILL instead.
+  // When running without the wrapper (e.g. `tsx src/cli.ts`), the process
+  // just dies — use `tsx src/bin.ts` for auto-restart support.
   let selfRestarting = false
   async function selfRestart(reason: string) {
     if (selfRestarting) {
@@ -1641,6 +1682,7 @@ export async function startDiscordBot({
     }
     selfRestarting = true
     discordLogger.log(`Self-restarting (reason: ${reason})...`)
+    setTimeout(() => process.kill(process.pid, 'SIGKILL'), 15_000)
     try {
       await handleShutdown(reason, { skipExit: true })
     } catch (error) {
@@ -1652,7 +1694,7 @@ export async function startDiscordBot({
         'No restart wrapper detected. Run via `tsx src/bin.ts` (dev) or `kimaki` (npm) for auto-restart on crash.',
       )
     }
-    process.exit(1)
+    process.kill(process.pid, 'SIGKILL')
   }
 
   process.on('SIGUSR2', () => {

package/src/discord-command-registration.test.ts

@@ -0,0 +1,20 @@
+// Tests Discord slash command payloads for quick agent commands.
+
+import { describe, expect, test } from 'vitest'
+import { buildQuickAgentSlashCommand } from './discord-command-registration.js'
+
+describe('buildQuickAgentSlashCommand', () => {
+  test('puts variant last after prompt', () => {
+    const command = buildQuickAgentSlashCommand({
+      commandName: 'plan-agent',
+      description: 'Switch to plan agent',
+    }).toJSON()
+
+    expect(command.options?.map((option) => option.name)).toMatchInlineSnapshot(`
+      [
+        "prompt",
+        "variant",
+      ]
+    `)
+  })
+})

package/src/discord-command-registration.ts

@@ -65,6 +65,32 @@ function truncateCommandDescription(description: string): string {
   return description.slice(0, 100)
 }
 
+export function buildQuickAgentSlashCommand({
+  commandName,
+  description,
+}: {
+  commandName: string
+  description: string
+}) {
+  return new SlashCommandBuilder()
+    .setName(commandName)
+    .setDescription(truncateCommandDescription(description))
+    .setDMPermission(false)
+    .addStringOption((opt) =>
+      opt
+        .setName('prompt')
+        .setDescription('Send a prompt with this agent')
+        .setRequired(false),
+    )
+    .addStringOption((opt) =>
+      opt
+        .setName('variant')
+        .setDescription('Model thinking level for this agent')
+        .setRequired(false)
+        .setAutocomplete(true),
+    )
+}
+
 export async function registerCommands({
   token,
   appId,
@@ -156,8 +182,22 @@ export async function registerCommands({
     new SlashCommandBuilder()
       .setName('merge-worktree')
       .setDescription(
-        truncateCommandDescription('Squash-merge worktree into default branch. Aborts if main has uncommitted changes.'),
+        truncateCommandDescription('Merge worktree commits into the default branch'),
       )
+      .addStringOption((option) => {
+        option
+          .setName('strategy')
+          .setDescription(
+            truncateCommandDescription('How to merge commits (default: keep commits)'),
+          )
+          .setRequired(false)
+          .addChoices(
+            { name: 'Keep commits (rebase)', value: 'rebase' },
+            { name: 'Squash into one commit', value: 'squash' },
+          )
+
+        return option
+      })
       .addStringOption((option) => {
         option
           .setName('target-branch')
@@ -491,17 +531,7 @@ export async function registerCommands({
     })
 
     commands.push(
-      new SlashCommandBuilder()
-        .setName(commandName)
-        .setDescription(truncateCommandDescription(description))
-        .setDMPermission(false)
-        .addStringOption((opt) =>
-          opt
-            .setName('prompt')
-            .setDescription('Send a prompt with this agent')
-            .setRequired(false),
-        )
-        .toJSON(),
+      buildQuickAgentSlashCommand({ commandName, description }).toJSON(),
     )
   }