kimaki 0.4.78 → 0.4.80

package/src/parse-permission-rules.test.ts

@@ -0,0 +1,127 @@
+// Tests for parsePermissionRules() from opencode.ts
+import { describe, test, expect } from 'vitest'
+import { parsePermissionRules } from './opencode.js'
+
+describe('parsePermissionRules', () => {
+  test('simple tool:action format', () => {
+    expect(parsePermissionRules(['bash:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `)
+  })
+
+  test('multiple rules', () => {
+    expect(parsePermissionRules(['bash:deny', 'edit:deny', 'read:allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "edit",
+        },
+        {
+          "action": "allow",
+          "pattern": "*",
+          "permission": "read",
+        },
+      ]
+    `)
+  })
+
+  test('tool:pattern:action format', () => {
+    expect(parsePermissionRules(['bash:git *:allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "allow",
+          "pattern": "git *",
+          "permission": "bash",
+        },
+      ]
+    `)
+  })
+
+  test('wildcard permission', () => {
+    expect(parsePermissionRules(['*:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "*",
+        },
+      ]
+    `)
+  })
+
+  test('case-insensitive action', () => {
+    expect(parsePermissionRules(['bash:DENY', 'edit:Allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+        {
+          "action": "allow",
+          "pattern": "*",
+          "permission": "edit",
+        },
+      ]
+    `)
+  })
+
+  test('trims whitespace', () => {
+    expect(parsePermissionRules([' bash : deny '])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `)
+  })
+
+  test('skips invalid entries', () => {
+    expect(parsePermissionRules(['', 'bash', 'bash:invalid', ':deny'])).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('handles non-array input defensively', () => {
+    expect(parsePermissionRules(undefined)).toMatchInlineSnapshot(`[]`)
+    expect(parsePermissionRules(null)).toMatchInlineSnapshot(`[]`)
+    expect(parsePermissionRules('bash:deny')).toMatchInlineSnapshot(`[]`)
+    expect(parsePermissionRules(123)).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('handles non-string array items', () => {
+    expect(parsePermissionRules([123, null, 'bash:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `)
+  })
+
+  test('ask action', () => {
+    expect(parsePermissionRules(['webfetch:ask'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "ask",
+          "pattern": "*",
+          "permission": "webfetch",
+        },
+      ]
+    `)
+  })
+})

package/src/queue-drain-after-interactive-ui.e2e.test.ts

@@ -0,0 +1,151 @@
+// E2e test: queued messages must drain immediately when the session is idle,
+// even if action buttons are still pending. The isSessionBusy check is
+// sufficient — hasPendingInteractiveUi() should NOT block queue drain.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForFooterMessage,
+} from './test-utils.js'
+import { getThreadSession } from './database.js'
+import {
+  pendingActionButtonContexts,
+  showActionButtons,
+} from './commands/action-buttons.js'
+
+const TEXT_CHANNEL_ID = '200000000000001020'
+
+describe('queue drain with pending interactive UI', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-drain-interactive-ui',
+    dirName: 'qa-drain-interactive-ui',
+    username: 'drain-ui-tester',
+  })
+
+  test(
+    'queued message drains immediately while action buttons are still pending',
+    async () => {
+      // 1. Create a thread with a first completed reply
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: drain-button-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: drain-button-setup'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'ok',
+        timeout: 4_000,
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      // 2. Show action buttons (session is idle, buttons are pending)
+      const currentSessionId = await getThreadSession(thread.id)
+      if (!currentSessionId) {
+        throw new Error('Expected thread session id')
+      }
+
+      const channel = await ctx.botClient.channels.fetch(thread.id)
+      if (!channel || !channel.isThread()) {
+        throw new Error('Expected Discord thread channel')
+      }
+
+      await showActionButtons({
+        thread: channel,
+        sessionId: currentSessionId,
+        directory: ctx.directories.projectDirectory,
+        buttons: [{ label: 'Pending button', color: 'white' }],
+      })
+
+      // Verify buttons are pending
+      const start = Date.now()
+      while (Date.now() - start < 4_000) {
+        const entry = [...pendingActionButtonContexts.entries()].find(([, context]) => {
+          return context.thread.id === thread.id && Boolean(context.messageId)
+        })
+        if (entry) {
+          break
+        }
+        await new Promise<void>((resolve) => {
+          setTimeout(resolve, 100)
+        })
+      }
+      expect(
+        [...pendingActionButtonContexts.values()].some((c) => {
+          return c.thread.id === thread.id
+        }),
+      ).toBe(true)
+
+      // 3. Queue a message via /queue while buttons are still pending.
+      //    The queue should drain immediately because session is idle.
+      //    Currently FAILS: hasPendingInteractiveUi() blocks tryDrainQueue().
+      const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-button-drain' }],
+        })
+
+      const queueAck = await th.waitForInteractionAck({
+        interactionId: queueInteractionId,
+        timeout: 4_000,
+      })
+      if (!queueAck.messageId) {
+        throw new Error('Expected /queue response message id')
+      }
+
+      // 4. Queued message should dispatch immediately (not stay "Queued").
+      //    The dispatch indicator should appear quickly.
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: '» **drain-ui-tester:** Reply with exactly: post-button-drain',
+        timeout: 4_000,
+      })
+
+      // 5. Wait for the footer after the drained message completes
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: '» **drain-ui-tester:**',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      const timeline = await th.text({ showInteractions: true })
+      expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (drain-ui-tester)
+        Reply with exactly: drain-button-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        **Action Required**
+        [user interaction]
+        » **drain-ui-tester:** Reply with exactly: post-button-drain
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+    },
+    20_000,
+  )
+})

package/src/session-handler/thread-runtime-state.ts

@@ -36,9 +36,12 @@ export type QueuedMessage = {
   command?: { name: string; arguments: string }
   // First-dispatch-only overrides — used when creating a new session.
   // Subsequent queue drains ignore these since the session already exists.
-  // Set by --agent/--model flags on kimaki send or slash commands.
+  // Set by --agent/--model/--permission flags on kimaki send or slash commands.
   agent?: string
   model?: string
+  // Raw permission rule strings ("tool:action" or "tool:pattern:action").
+  // Parsed and merged into session permissions on creation.
+  permissions?: string[]
   // Tracking fields for scheduled tasks. Stored in the DB via
   // setSessionStartSource() after the session is created, so the session
   // list can show which sessions were started by scheduled tasks.

package/src/session-handler/thread-session-runtime.ts

@@ -24,6 +24,7 @@ import {
   getOpencodeClient,
   initializeOpencodeForDirectory,
   buildSessionPermissions,
+  parsePermissionRules,
   subscribeOpencodeServerLifecycle,
 } from '../opencode.js'
 import { isAbortError } from '../utils.js'
@@ -426,6 +427,14 @@ export type IngressInput = {
   // First-dispatch-only overrides (used when creating a new session)
   agent?: string
   model?: string
+  /**
+   * Raw permission rule strings from --permission flag ("tool:action" or
+   * "tool:pattern:action"). Parsed into PermissionRuleset entries by
+   * parsePermissionRules() and appended after buildSessionPermissions()
+   * so they win via opencode's findLast() evaluation. Only used on
+   * session creation (first dispatch).
+   */
+  permissions?: string[]
   sessionStartSource?: { scheduleKind: 'at' | 'cron'; scheduledTaskId?: number }
   /** Optional guard for retries: skip enqueue when session has changed. */
   expectedSessionId?: string
@@ -911,12 +920,16 @@ export class ThreadSessionRuntime {
     const compacted = structuredClone(event)
 
     if (compacted.type === 'message.updated') {
-      if (compacted.properties.info.role !== 'user') {
-        return compacted
-      }
-      delete compacted.properties.info.system
-      delete compacted.properties.info.summary
-      delete compacted.properties.info.tools
+      // Strip heavy fields from ALL roles. Derivation only needs lightweight
+      // metadata (id, role, sessionID, parentID, time, finish, error, modelID,
+      // providerID, mode, tokens). The parts array on assistant messages grows
+      // with every tool call and was the primary OOM vector — 1000 buffer entries
+      // each carrying the full cumulative parts array reached 4GB+.
+      const info = compacted.properties.info as Record<string, unknown>
+      delete info.system
+      delete info.summary
+      delete info.tools
+      delete info.parts
       return compacted
     }
 
@@ -1171,8 +1184,16 @@ export class ThreadSessionRuntime {
   // Subtask sessions also bypass — they're tracked in subtaskSessions.
 
   private async handleEvent(event: OpenCodeEvent): Promise<void> {
-    // Push into bounded event buffer for waitForEvent() consumers.
-    this.appendEventToBuffer(event)
+    // Skip message.part.delta from the event buffer — no derivation function
+    // (isSessionBusy, doesLatestUserTurnHaveNaturalCompletion, waitForEvent,
+    // etc.) uses them. During long streaming responses they flood the 1000-slot
+    // buffer, evicting session.status busy events that isSessionBusy needs,
+    // causing tryDrainQueue to drain the local queue while the session is
+    // actually still busy. This was the root cause of "? queue" messages
+    // interrupting instead of queuing.
+    if (event.type !== 'message.part.delta') {
+      this.appendEventToBuffer(event)
+    }
 
     const sessionId = this.state?.sessionId
 
@@ -1903,6 +1924,7 @@ export class ThreadSessionRuntime {
             await sendThreadMessage(
               this.thread,
               `Failed to show action buttons: ${showResult.message}`,
+              { flags: NOTIFY_MESSAGE_FLAGS },
             )
           }
         },
@@ -2164,6 +2186,7 @@ export class ThreadSessionRuntime {
     await sendThreadMessage(
       this.thread,
       `✗ opencode session error: ${errorMessage}`,
+      { flags: NOTIFY_MESSAGE_FLAGS },
     )
     await this.persistEventBufferDebounced.flush()
 
@@ -2457,7 +2480,9 @@ export class ThreadSessionRuntime {
       // Helper: stop typing and drain queued local messages on error.
       const cleanupOnError = async (errorMessage: string) => {
         this.stopTyping()
-        await sendThreadMessage(this.thread, errorMessage)
+        await sendThreadMessage(this.thread, errorMessage, {
+          flags: NOTIFY_MESSAGE_FLAGS,
+        })
         await this.tryDrainQueue({ showIndicator: true })
       }
 
@@ -2465,6 +2490,7 @@ export class ThreadSessionRuntime {
       const sessionResult = await this.ensureSession({
         prompt: input.prompt,
         agent: input.agent,
+        permissions: input.permissions,
         sessionStartScheduleKind: input.sessionStartSource?.scheduleKind,
         sessionStartScheduledTaskId: input.sessionStartSource?.scheduledTaskId,
       })
@@ -2720,6 +2746,7 @@ export class ThreadSessionRuntime {
       command: input.command,
       agent: input.agent,
       model: input.model,
+      permissions: input.permissions,
       sessionStartScheduleKind: input.sessionStartSource?.scheduleKind,
       sessionStartScheduledTaskId: input.sessionStartSource?.scheduledTaskId,
     }
@@ -2736,7 +2763,6 @@ export class ThreadSessionRuntime {
       const willDrainNow = stateAfterEnqueue
         ? (
           stateAfterEnqueue.queueItems.length > 0
-          && !this.hasPendingInteractiveUi()
           && !this.isMainSessionBusy()
         )
         : false
@@ -2819,6 +2845,16 @@ export class ThreadSessionRuntime {
           preprocess: undefined,
         }
 
+        const hasPromptText = resolvedInput.prompt.trim().length > 0
+        const hasImages = (resolvedInput.images?.length || 0) > 0
+        if (!hasPromptText && !hasImages && !resolvedInput.command) {
+          logger.warn(
+            `[INGRESS] Skipping empty preprocessed input threadId=${this.threadId}`,
+          )
+          resolveOuter({ queued: false })
+          return
+        }
+
         // Route with the resolved mode through normal paths.
         // Await the enqueue so session state (ensureSession, setThreadSession)
         // is persisted before the next message's preprocessing reads it.
@@ -2961,9 +2997,11 @@ export class ThreadSessionRuntime {
     if (thread.queueItems.length === 0) {
       return
     }
-    if (this.hasPendingInteractiveUi()) {
-      return
-    }
+    // Interactive UI (action buttons, questions, permissions) does NOT block
+    // queue drain. The isSessionBusy check is sufficient: questions and
+    // permissions keep the OpenCode session busy, so drain is naturally
+    // blocked. Action buttons are fire-and-forget (session already idle),
+    // so queued messages should dispatch immediately.
 
     const sessionBusy = thread.sessionId
       ? isSessionBusy({ events: this.eventBuffer, sessionId: thread.sessionId })
@@ -3030,6 +3068,7 @@ export class ThreadSessionRuntime {
     const sessionResult = await this.ensureSession({
       prompt: input.prompt,
       agent: input.agent,
+      permissions: input.permissions,
       sessionStartScheduleKind: input.sessionStartScheduleKind,
       sessionStartScheduledTaskId: input.sessionStartScheduledTaskId,
     })
@@ -3038,6 +3077,7 @@ export class ThreadSessionRuntime {
       await sendThreadMessage(
         this.thread,
         `✗ ${sessionResult.message}`,
+        { flags: NOTIFY_MESSAGE_FLAGS },
       )
       // Show indicator: this dispatch failed, so the next queued message
       // has been waiting — the user needs to see which one is starting.
@@ -3084,6 +3124,7 @@ export class ThreadSessionRuntime {
       await sendThreadMessage(
         this.thread,
         `Failed to resolve agent: ${earlyAgentResult.message}`,
+        { flags: NOTIFY_MESSAGE_FLAGS },
       )
       // Show indicator: dispatch failed mid-setup, next queued message was waiting.
       await this.tryDrainQueue({ showIndicator: true })
@@ -3124,6 +3165,7 @@ export class ThreadSessionRuntime {
       await sendThreadMessage(
         this.thread,
         `Failed to resolve model: ${earlyModelResult.message}`,
+        { flags: NOTIFY_MESSAGE_FLAGS },
       )
       // Show indicator: dispatch failed mid-setup, next queued message was waiting.
       await this.tryDrainQueue({ showIndicator: true })
@@ -3284,6 +3326,7 @@ export class ThreadSessionRuntime {
           await sendThreadMessage(
             this.thread,
             '✗ Command timed out after 30 seconds. Try a shorter command or run it with /run-shell-command.',
+            { flags: NOTIFY_MESSAGE_FLAGS },
           )
           await this.dispatchAction(() => {
             return this.tryDrainQueue({ showIndicator: true })
@@ -3308,6 +3351,7 @@ export class ThreadSessionRuntime {
         await sendThreadMessage(
           this.thread,
           `✗ Unexpected bot Error: ${commandResponse.message}`,
+          { flags: NOTIFY_MESSAGE_FLAGS },
         )
         await this.dispatchAction(() => {
           return this.tryDrainQueue({ showIndicator: true })
@@ -3328,7 +3372,9 @@ export class ThreadSessionRuntime {
         logger.error(`[DISPATCH] ${apiError.message}`)
         void notifyError(apiError, 'OpenCode API error during command')
         this.stopTyping()
-        await sendThreadMessage(this.thread, `✗ ${apiError.message}`)
+        await sendThreadMessage(this.thread, `✗ ${apiError.message}`, {
+          flags: NOTIFY_MESSAGE_FLAGS,
+        })
         await this.dispatchAction(() => {
           return this.tryDrainQueue({ showIndicator: true })
         })
@@ -3375,7 +3421,9 @@ export class ThreadSessionRuntime {
       logger.error(`[DISPATCH] Prompt API call failed: ${errorMessage}`)
       void notifyError(errorObject, 'OpenCode API error during local queue prompt')
       this.stopTyping()
-      await sendThreadMessage(this.thread, `✗ OpenCode API error: ${errorMessage}`)
+      await sendThreadMessage(this.thread, `✗ OpenCode API error: ${errorMessage}`, {
+        flags: NOTIFY_MESSAGE_FLAGS,
+      })
       await this.dispatchAction(() => {
         return this.tryDrainQueue({ showIndicator: true })
       })
@@ -3393,11 +3441,14 @@ export class ThreadSessionRuntime {
   private async ensureSession({
     prompt,
     agent,
+    permissions,
     sessionStartScheduleKind,
     sessionStartScheduledTaskId,
   }: {
     prompt: string
     agent?: string
+    /** Raw "tool:action" strings from --permission flag */
+    permissions?: string[]
     sessionStartScheduleKind?: 'at' | 'cron'
     sessionStartScheduledTaskId?: number
   }): Promise<
@@ -3458,10 +3509,15 @@ export class ThreadSessionRuntime {
       // access its own project directory (and worktree origin if applicable)
       // without prompts. These override the server-level 'ask' default via
       // opencode's findLast() rule evaluation.
-      const sessionPermissions = buildSessionPermissions({
-        directory: this.sdkDirectory,
-        originalRepoDirectory,
-      })
+      // CLI --permission rules are appended after base rules so they win
+      // via opencode's findLast() evaluation.
+      const sessionPermissions = [
+        ...buildSessionPermissions({
+          directory: this.sdkDirectory,
+          originalRepoDirectory,
+        }),
+        ...parsePermissionRules(permissions ?? []),
+      ]
       const sessionResponse = await getClient().session.create({
         title: sessionTitle,
         directory: this.sdkDirectory,
@@ -3620,7 +3676,13 @@ export class ThreadSessionRuntime {
     const footerText = `*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*`
     this.stopTyping()
 
-    await sendThreadMessage(this.thread, footerText, { flags: NOTIFY_MESSAGE_FLAGS })
+    // Skip notification if there's a queued message next — the user only
+    // needs to be notified when the entire queue finishes.
+    const queuedNext =
+      (threadState.getThreadState(this.threadId)?.queueItems.length ?? 0) > 0
+    await sendThreadMessage(this.thread, footerText, {
+      flags: queuedNext ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
+    })
     logger.log(
       `DURATION: Session completed in ${sessionDuration}, model ${runInfo.model}, tokens ${runInfo.tokensUsed}`,
     )