kimaki 0.4.78 → 0.4.80

package/src/undo-redo.e2e.test.ts

@@ -0,0 +1,207 @@
+// E2e test for /undo command.
+// Validates that:
+// 1. After /undo, session.revert state is set (files reverted, revert boundary marked)
+// 2. Messages are NOT deleted yet (they stay until next prompt cleans them up)
+// 3. On the next user message, reverted messages are cleaned up by OpenCode's
+//    SessionRevert.cleanup() and the model only sees pre-revert messages
+//
+// This matches the OpenCode TUI behavior (use-session-commands.tsx):
+// - Pass the user message ID (not assistant ID)
+// - Don't delete messages — just mark session as reverted
+// - Cleanup happens automatically on next promptAsync()
+//
+// Uses opencode-deterministic-provider (no real LLM calls).
+// Poll timeouts: 4s max, 100ms interval.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import { waitForFooterMessage } from './test-utils.js'
+import { getThreadSession } from './database.js'
+import { initializeOpencodeForDirectory } from './opencode.js'
+
+const TEXT_CHANNEL_ID = '200000000000001200'
+
+const e2eTest = describe
+
+e2eTest('/undo sets revert state and cleans up on next prompt', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-undo-e2e',
+    dirName: 'qa-undo-e2e',
+    username: 'undo-tester',
+  })
+
+  test(
+    'undo sets revert state, next message cleans up reverted messages',
+    async () => {
+      // 1. Send a message and wait for complete session (footer)
+      await ctx.discord
+        .channel(TEXT_CHANNEL_ID)
+        .user(TEST_USER_ID)
+        .sendMessage({
+          content: 'Reply with exactly: undo-test-message',
+        })
+
+      const thread = await ctx.discord
+        .channel(TEXT_CHANNEL_ID)
+        .waitForThread({
+          timeout: 4_000,
+          predicate: (t) => {
+            return t.name === 'Reply with exactly: undo-test-message'
+          },
+        })
+
+      const th = ctx.discord.thread(thread.id)
+      await th.waitForBotReply({ timeout: 4_000 })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+      })
+
+      // 2. Get session ID and verify it has messages
+      const sessionId = await getThreadSession(thread.id)
+      expect(sessionId).toBeTruthy()
+
+      const getClient = await initializeOpencodeForDirectory(
+        ctx.directories.projectDirectory,
+      )
+      if (getClient instanceof Error) {
+        throw getClient
+      }
+
+      const beforeMessages = await getClient().session.messages({
+        sessionID: sessionId!,
+        directory: ctx.directories.projectDirectory,
+      })
+      const beforeCount = (beforeMessages.data || []).length
+      expect(beforeCount).toBeGreaterThan(0)
+
+      const beforeUserMessages = (beforeMessages.data || []).filter((m) => {
+        return m.info.role === 'user'
+      })
+      const beforeAssistantMessages = (beforeMessages.data || []).filter(
+        (m) => {
+          return m.info.role === 'assistant'
+        },
+      )
+      expect(beforeUserMessages.length).toBeGreaterThan(0)
+      expect(beforeAssistantMessages.length).toBeGreaterThan(0)
+
+      // Verify no revert state yet
+      const beforeSession = await getClient().session.get({
+        sessionID: sessionId!,
+      })
+      expect(beforeSession.data?.revert).toBeFalsy()
+
+      // 3. Run /undo command
+      const { id: undoInteractionId } = await th
+        .user(TEST_USER_ID)
+        .runSlashCommand({ name: 'undo' })
+
+      const undoAck = await th.waitForInteractionAck({
+        interactionId: undoInteractionId,
+        timeout: 4_000,
+      })
+      expect(undoAck).toBeDefined()
+
+      // Wait for the undo reply to appear (deferred reply gets edited)
+      if (undoAck.messageId) {
+        const start = Date.now()
+        while (Date.now() - start < 4_000) {
+          const messages = await th.getMessages()
+          const undoMessage = messages.find((m) => {
+            return m.id === undoAck.messageId
+          })
+          if (undoMessage && undoMessage.content.length > 0) {
+            break
+          }
+          await new Promise((r) => {
+            setTimeout(r, 100)
+          })
+        }
+      }
+
+      // 4. Verify session now has revert state set
+      const afterSession = await getClient().session.get({
+        sessionID: sessionId!,
+      })
+      expect(afterSession.data?.revert).toBeTruthy()
+      expect(afterSession.data?.revert?.messageID).toBeTruthy()
+
+      // Messages should still exist (not deleted — cleanup happens on next prompt)
+      const afterMessages = await getClient().session.messages({
+        sessionID: sessionId!,
+        directory: ctx.directories.projectDirectory,
+      })
+      expect((afterMessages.data || []).length).toBe(beforeCount)
+
+      // 5. Send a new message — this triggers SessionRevert.cleanup()
+      // which removes reverted messages before processing the new prompt
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: after-undo-message',
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'after-undo-message',
+      })
+
+      // 6. Verify reverted messages were cleaned up
+      const finalMessages = await getClient().session.messages({
+        sessionID: sessionId!,
+        directory: ctx.directories.projectDirectory,
+      })
+      const finalAssistantMessages = (finalMessages.data || []).filter(
+        (m) => {
+          return m.info.role === 'assistant'
+        },
+      )
+
+      // The original assistant message should have been cleaned up,
+      // only the new one (from after-undo-message) should remain
+      const originalAssistantStillExists = finalAssistantMessages.some(
+        (m) => {
+          return m.parts.some((p) => {
+            return p.type === 'text' && 'text' in p && p.text === 'ok'
+          })
+        },
+      )
+      // The first "ok" response was reverted and should be cleaned up.
+      // The new response for "after-undo-message" should produce a fresh "ok".
+      // We verify the total count dropped: the original user+assistant pair
+      // was removed, and replaced by just the new user+assistant pair.
+      expect(finalAssistantMessages.length).toBeLessThanOrEqual(
+        beforeAssistantMessages.length,
+      )
+
+      // Revert state should be cleared after cleanup
+      const finalSession = await getClient().session.get({
+        sessionID: sessionId!,
+      })
+      expect(finalSession.data?.revert).toBeFalsy()
+
+      // 7. Snapshot the Discord thread
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (undo-tester)
+        Reply with exactly: undo-test-message
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        Undone - reverted last assistant message
+        --- from: user (undo-tester)
+        Reply with exactly: after-undo-message
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+    },
+    20_000,
+  )
+})

package/src/utils.ts

@@ -86,6 +86,7 @@ export function generateDiscordInstallUrlForBot({
   clientId,
   clientSecret,
   gatewayCallbackUrl,
+  reachableUrl,
 }: {
   appId: string
   mode: BotMode
@@ -94,6 +95,9 @@ export function generateDiscordInstallUrlForBot({
   /** Optional external URL to redirect to after OAuth completes instead of the
    *  default success page. The website appends ?guild_id=<id> before redirecting. */
   gatewayCallbackUrl?: string
+  /** When set (KIMAKI_INTERNET_REACHABLE_URL), the website stores this URL in
+   *  gateway_clients.reachable_url so the gateway-proxy connects outbound. */
+  reachableUrl?: string
 }): Error | string {
   if (mode !== 'gateway') {
     return generateBotInstallUrl({ clientId: appId })
@@ -115,6 +119,9 @@ export function generateDiscordInstallUrlForBot({
   if (gatewayCallbackUrl) {
     url.searchParams.set('kimakiCallbackUrl', gatewayCallbackUrl)
   }
+  if (reachableUrl) {
+    url.searchParams.set('reachableUrl', reachableUrl)
+  }
   return url.toString()
 }
 

package/src/voice-attachment.ts

@@ -0,0 +1,51 @@
+// Voice attachment detection helpers.
+// Normalizes Discord attachment heuristics for voice-message detection so
+// message routing, transcription, and empty-prompt guards all agree even when
+// Discord omits contentType on uploaded audio attachments.
+
+import path from 'node:path'
+
+const VOICE_ATTACHMENT_EXTENSIONS = new Set<string>([
+  '.m4a',
+  '.mp3',
+  '.mp4',
+  '.oga',
+  '.ogg',
+  '.opus',
+  '.wav',
+])
+
+export type VoiceAttachmentLike = {
+  contentType?: string | null
+  name?: string | null
+  duration?: number | null
+  waveform?: string | null
+}
+
+export function getVoiceAttachmentMatchReason(
+  attachment: VoiceAttachmentLike,
+): string | null {
+  const contentType = attachment.contentType?.trim().toLowerCase() || ''
+  if (contentType.startsWith('audio/')) {
+    return `contentType:${contentType}`
+  }
+
+  if (typeof attachment.duration === 'number' && attachment.duration > 0) {
+    return `duration:${attachment.duration}`
+  }
+
+  if (attachment.waveform?.trim()) {
+    return 'waveform'
+  }
+
+  const extension = path.extname(attachment.name || '').toLowerCase()
+  if (VOICE_ATTACHMENT_EXTENSIONS.has(extension)) {
+    return `extension:${extension}`
+  }
+
+  return null
+}
+
+export function isVoiceAttachment(attachment: VoiceAttachmentLike): boolean {
+  return getVoiceAttachmentMatchReason(attachment) !== null
+}

package/src/voice-handler.ts

@@ -10,11 +10,9 @@ import {
   entersState,
   type VoiceConnection,
 } from '@discordjs/voice'
-import { exec } from 'node:child_process'
 import fs, { createWriteStream } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
-import { promisify } from 'node:util'
 import { Transform, type TransformCallback } from 'node:stream'
 import * as prism from 'prism-media'
 import dedent from 'string-dedent'
@@ -40,11 +38,17 @@ import {
   sendThreadMessage,
   escapeDiscordFormatting,
   SILENT_MESSAGE_FLAGS,
+  NOTIFY_MESSAGE_FLAGS,
   hasKimakiBotPermission,
 } from './discord-utils.js'
 import { transcribeAudio, type TranscriptionResult } from './voice.js'
 import { FetchError } from './errors.js'
 import { store } from './store.js'
+import {
+  getVoiceAttachmentMatchReason,
+  isVoiceAttachment,
+} from './voice-attachment.js'
+import { execAsync } from './worktrees.js'
 
 import { createLogger, LogPrefix } from './logger.js'
 import { notifyError } from './sentry.js'
@@ -285,7 +289,7 @@ export async function setupVoiceHandling({
           if (textChannel?.isTextBased() && 'send' in textChannel) {
             await textChannel.send({
               content: `⚠️ Voice session error: ${String(error).slice(0, 1900)}`,
-              flags: SILENT_MESSAGE_FLAGS,
+              flags: NOTIFY_MESSAGE_FLAGS,
             })
           }
         } catch (e) {
@@ -469,13 +473,15 @@ export async function processVoiceAttachment({
   lastSessionContext,
 }: ProcessVoiceAttachmentArgs): Promise<TranscriptionResult | null> {
   const audioAttachment = Array.from(message.attachments.values()).find(
-    (attachment) => attachment.contentType?.startsWith('audio/'),
+    (attachment) => isVoiceAttachment(attachment),
   )
 
   if (!audioAttachment) return null
 
+  const attachmentMatchReason = getVoiceAttachmentMatchReason(audioAttachment)
+
   voiceLogger.log(
-    `Detected audio attachment: ${audioAttachment.name} (${audioAttachment.contentType})`,
+    `Detected audio attachment: ${audioAttachment.name} (${audioAttachment.contentType || 'no contentType'}, ${attachmentMatchReason || 'unknown reason'})`,
   )
 
   await sendThreadMessage(thread, '🎤 Transcribing voice message...')
@@ -529,6 +535,7 @@ export async function processVoiceAttachment({
     await sendThreadMessage(
       thread,
       `⚠️ Failed to download audio: ${audioResponse.message}`,
+      { flags: NOTIFY_MESSAGE_FLAGS },
     )
     return null
   }
@@ -541,7 +548,6 @@ export async function processVoiceAttachment({
   if (projectDirectory) {
     try {
       voiceLogger.log(`Getting project file tree from ${projectDirectory}`)
-      const execAsync = promisify(exec)
       const { stdout } = await execAsync('git ls-files | tree --fromfile -a', {
         cwd: projectDirectory,
       })
@@ -620,7 +626,9 @@ export async function processVoiceAttachment({
       Error: (e) => e.message,
     })
     voiceLogger.error(`Transcription failed:`, transcription)
-    await sendThreadMessage(thread, `⚠️ Transcription failed: ${errMsg}`)
+    await sendThreadMessage(thread, `⚠️ Transcription failed: ${errMsg}`, {
+      flags: NOTIFY_MESSAGE_FLAGS,
+    })
     return null
   }
 

package/src/voice-message.e2e.test.ts

@@ -526,6 +526,101 @@ e2eTest('voice message handling', () => {
     8_000,
   )
 
+  test(
+    'voice attachment without content type still transcribes and avoids empty prompt dispatch',
+    async () => {
+      setDeterministicTranscription({
+        transcription: 'Investigate the missing content type path',
+        queueMessage: false,
+      })
+
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: '',
+        attachments: [
+          {
+            id: 'voice-no-content-type',
+            filename: 'voice-message.ogg',
+            size: 1024,
+            url: 'https://fake-cdn.discord.test/voice-no-content-type.ogg',
+            proxy_url: 'https://fake-cdn.discord.test/voice-no-content-type.ogg',
+          },
+        ],
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name?.includes('Investigate the missing content type path') ?? false
+        },
+      })
+
+      const th = discord.thread(thread.id)
+
+      await waitForBotMessageContaining({
+        discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'Transcribing voice message',
+        timeout: 4_000,
+      })
+
+      await waitForBotMessageContaining({
+        discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'Investigate the missing content type path',
+        timeout: 4_000,
+      })
+
+      await waitForFooterMessage({
+        discord,
+        threadId: thread.id,
+        timeout: 4_000,
+      })
+
+      const finalState = await waitForThreadState({
+        threadId: thread.id,
+        predicate: (state) => {
+          return Boolean(state.sessionId) && state.queueItems.length === 0
+        },
+        timeout: 4_000,
+        description: 'voice attachment without content type settled',
+      })
+
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (voice-tester)
+        [attachment: voice-message.ogg]
+        --- from: assistant (TestBot)
+        🎤 Transcribing voice message...
+        📝 **Transcribed message:** Investigate the missing content type path
+        ⬥ session-reply
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+
+      const messages = await waitForSessionMessages({
+        projectDirectory: directories.projectDirectory,
+        sessionID: finalState.sessionId!,
+        timeout: 4_000,
+        description: 'voice attachment without content type dispatched once',
+        predicate: (all) => {
+          const userTexts = getUserTexts(all)
+          return userTexts.some((text) => {
+            return text.includes('Investigate the missing content type path')
+          })
+        },
+      })
+
+      const userTexts = getUserTexts(messages)
+      expect(userTexts).not.toContain('')
+      expect(
+        userTexts.some((text) => {
+          return text.includes('Investigate the missing content type path')
+        }),
+      ).toBe(true)
+    },
+    8_000,
+  )
+
   // ── Test 2: Voice message in thread with idle session ──
 
   test(

package/src/voice.test.ts

@@ -11,6 +11,10 @@ import {
   normalizeAudioMediaType,
   getOpenAIAudioConversionStrategy,
 } from './voice.js'
+import {
+  getVoiceAttachmentMatchReason,
+  isVoiceAttachment,
+} from './voice-attachment.js'
 
 describe('audio media type routing', () => {
   test('normalizes m4a aliases to audio/mp4', () => {
@@ -31,6 +35,38 @@ describe('audio media type routing', () => {
   })
 })
 
+describe('voice attachment detection', () => {
+  test('detects voice attachments by content type, extension, and waveform metadata', () => {
+    expect(
+      [
+        getVoiceAttachmentMatchReason({
+          name: 'voice-message.ogg',
+          contentType: 'audio/ogg',
+        }),
+        getVoiceAttachmentMatchReason({
+          name: 'voice-message.ogg',
+          contentType: null,
+        }),
+        getVoiceAttachmentMatchReason({
+          name: 'upload.bin',
+          contentType: null,
+          waveform: 'abc123',
+        }),
+        isVoiceAttachment({
+          name: 'notes.txt',
+          contentType: null,
+        }),
+      ]).toMatchInlineSnapshot(`
+      [
+        "contentType:audio/ogg",
+        "extension:.ogg",
+        "waveform",
+        false,
+      ]
+    `)
+  })
+})
+
 describe('extractTranscription', () => {
   test('extracts transcription from tool call', () => {
     const result = extractTranscription([

package/src/onboarding-tutorial-plugin.ts

@@ -1,93 +0,0 @@
-// OpenCode plugin that injects onboarding tutorial system instructions.
-// Detects TUTORIAL_WELCOME_TEXT in any text part of the session (the thread
-// starter content appears in the user prompt via "Context from thread:..."
-// prepended by message-preprocessing.ts). When found, injects
-// ONBOARDING_TUTORIAL_INSTRUCTIONS as a synthetic system-reminder.
-//
-// Exported from opencode-plugin.ts — each export is treated as a separate
-// plugin by OpenCode's plugin loader.
-
-import type { Plugin } from '@opencode-ai/plugin'
-import crypto from 'node:crypto'
-import * as errore from 'errore'
-import {
-  createLogger,
-  formatErrorWithStack,
-  LogPrefix,
-} from './logger.js'
-import { notifyError } from './sentry.js'
-import {
-  ONBOARDING_TUTORIAL_INSTRUCTIONS,
-  TUTORIAL_WELCOME_TEXT,
-} from './onboarding-tutorial.js'
-
-const logger = createLogger(LogPrefix.OPENCODE)
-
-const onboardingTutorialPlugin: Plugin = async () => {
-  // Track sessions where tutorial instructions have been injected.
-  // Once injected, never inject again for the same session.
-  const sessionTutorialInjected = new Set<string>()
-
-  return {
-    'chat.message': async (input, output) => {
-      const hookResult = await errore.tryAsync({
-        try: async () => {
-          const { sessionID } = input
-          if (sessionTutorialInjected.has(sessionID)) {
-            return
-          }
-
-          // Check ALL text parts (including system/synthetic) for the
-          // welcome text. The thread starter content is prepended to the
-          // user prompt by message-preprocessing.ts as "Context from thread:".
-          const hasTutorialContext = output.parts.some((part) => {
-            return part.type === 'text' && part.text.includes(TUTORIAL_WELCOME_TEXT)
-          })
-          if (!hasTutorialContext) {
-            return
-          }
-
-          sessionTutorialInjected.add(sessionID)
-
-          // Use messageID from the first text part for the synthetic injection
-          const firstText = output.parts.find((part) => {
-            return part.type === 'text'
-          })
-          if (!firstText) {
-            return
-          }
-
-          output.parts.push({
-            id: `prt_${crypto.randomUUID()}`,
-            sessionID,
-            messageID: firstText.messageID,
-            type: 'text' as const,
-            text: `<system-reminder>\n${ONBOARDING_TUTORIAL_INSTRUCTIONS}\n</system-reminder>`,
-            synthetic: true,
-          })
-        },
-        catch: (error) => {
-          return new Error('onboarding tutorial hook failed', { cause: error })
-        },
-      })
-      if (hookResult instanceof Error) {
-        logger.warn(
-          `[onboarding-tutorial-plugin] ${formatErrorWithStack(hookResult)}`,
-        )
-        void notifyError(hookResult, 'onboarding tutorial plugin hook failed')
-      }
-    },
-
-    event: async ({ event }) => {
-      if (event.type !== 'session.deleted') {
-        return
-      }
-      const id = event.properties?.info?.id
-      if (id) {
-        sessionTutorialInjected.delete(id)
-      }
-    },
-  }
-}
-
-export { onboardingTutorialPlugin }