kimaki 0.26.0 → 0.28.0

package/src/discord-utils.test.ts

@@ -3,9 +3,13 @@ import { afterEach, describe, expect, test } from 'vitest'
 import {
   hasKimakiAdminPermission,
   hasKimakiBotPermission,
+  raceDiscordRename,
+  resolveFooterMentionUserId,
   resolveGuildMessageMember,
+  resolveThreadFooterMentionUserId,
   splitMarkdownForDiscord,
 } from './discord-utils.js'
+import type { ThreadChannel } from 'discord.js'
 import { store } from './store.js'
 
 describe('splitMarkdownForDiscord', () => {
@@ -292,3 +296,175 @@ describe('resolveGuildMessageMember', () => {
     await expect(resolveGuildMessageMember(message)).resolves.toBe(null)
   })
 })
+
+describe('resolveFooterMentionUserId', () => {
+  test('uses the session user when it is not the bot', () => {
+    expect(resolveFooterMentionUserId({
+      sessionUserId: 'user-1',
+      botUserId: 'bot-1',
+      threadOwnerId: 'bot-1',
+      members: [
+        { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+        { id: 'user-2', bot: false, joinedTimestamp: 2 },
+      ],
+    })).toBe('user-1')
+  })
+
+  test('skips bots and uses the earliest human member when the bot created the thread', () => {
+    expect(resolveFooterMentionUserId({
+      sessionUserId: 'bot-1',
+      botUserId: 'bot-1',
+      threadOwnerId: 'bot-1',
+      members: [
+        { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+        { id: 'other-bot', bot: true, joinedTimestamp: 2 },
+        { id: 'user-3', bot: false, joinedTimestamp: 4 },
+        { id: 'user-2', bot: false, joinedTimestamp: 3 },
+      ],
+    })).toBe('user-2')
+  })
+
+  test('does not mention anyone when the bot created the thread and no human member exists', () => {
+    expect(resolveFooterMentionUserId({
+      sessionUserId: 'bot-1',
+      botUserId: 'bot-1',
+      threadOwnerId: 'bot-1',
+      members: [
+        { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+        { id: 'other-bot', bot: true, joinedTimestamp: 2 },
+      ],
+    })).toBeUndefined()
+  })
+
+  test('uses the first human member when the bot created the thread and no session user is set', () => {
+    expect(resolveFooterMentionUserId({
+      sessionUserId: undefined,
+      botUserId: 'bot-1',
+      threadOwnerId: 'bot-1',
+      members: [
+        { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+        { id: 'user-2', bot: false, joinedTimestamp: 2 },
+      ],
+    })).toBe('user-2')
+  })
+
+  test('does not mention a member whose bot flag is unknown', () => {
+    expect(resolveFooterMentionUserId({
+      sessionUserId: undefined,
+      botUserId: 'bot-1',
+      threadOwnerId: 'bot-1',
+      members: [
+        { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+        { id: 'maybe-user', joinedTimestamp: 2 },
+      ],
+    })).toBeUndefined()
+  })
+})
+
+function fakeThread({
+  ownerId,
+  botUserId,
+  members,
+  onFetch,
+}: {
+  ownerId: string
+  botUserId: string
+  members: Array<{ id: string; bot?: boolean; joinedTimestamp?: number | null }>
+  onFetch?: () => Promise<Map<string, { id: string; user?: { bot?: boolean }; joinedTimestamp?: number | null }>>
+}): ThreadChannel {
+  const cache = new Map(members.map((member) => [
+    member.id,
+    {
+      id: member.id,
+      user: member.bot === undefined ? undefined : { bot: member.bot },
+      joinedTimestamp: member.joinedTimestamp ?? null,
+    },
+  ]))
+  return {
+    ownerId,
+    client: { user: { id: botUserId } },
+    members: {
+      cache,
+      fetch: onFetch ?? (() => {
+        throw new Error('should not fetch thread members')
+      }),
+    },
+  } as ThreadChannel
+}
+
+describe('resolveThreadFooterMentionUserId', () => {
+  test('does not fetch when a human session user is already known', async () => {
+    await expect(resolveThreadFooterMentionUserId({
+      sessionUserId: 'user-1',
+      thread: fakeThread({
+        ownerId: 'bot-1',
+        botUserId: 'bot-1',
+        members: [{ id: 'bot-1', bot: true }],
+      }),
+    })).resolves.toBe('user-1')
+  })
+
+  test('does not fetch when the thread owner is not the bot', async () => {
+    await expect(resolveThreadFooterMentionUserId({
+      sessionUserId: undefined,
+      thread: fakeThread({
+        ownerId: 'user-1',
+        botUserId: 'bot-1',
+        members: [{ id: 'user-1', bot: false }],
+      }),
+    })).resolves.toBeUndefined()
+  })
+
+  test('uses cached humans without fetching', async () => {
+    await expect(resolveThreadFooterMentionUserId({
+      sessionUserId: undefined,
+      thread: fakeThread({
+        ownerId: 'bot-1',
+        botUserId: 'bot-1',
+        members: [
+          { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+          { id: 'user-2', bot: false, joinedTimestamp: 2 },
+        ],
+      }),
+    })).resolves.toBe('user-2')
+  })
+
+  test('fetches only when the bot owns the thread and no human is cached', async () => {
+    let fetched = false
+    const thread = fakeThread({
+      ownerId: 'bot-1',
+      botUserId: 'bot-1',
+      members: [{ id: 'bot-1', bot: true, joinedTimestamp: 1 }],
+      onFetch: async () => {
+        fetched = true
+        return new Map([
+          ['bot-1', { id: 'bot-1', user: { bot: true }, joinedTimestamp: 1 }],
+          ['user-2', { id: 'user-2', user: { bot: false }, joinedTimestamp: 2 }],
+        ])
+      },
+    })
+    await expect(resolveThreadFooterMentionUserId({
+      sessionUserId: undefined,
+      thread,
+    })).resolves.toBe('user-2')
+    expect(fetched).toBe(true)
+  })
+})
+
+describe('raceDiscordRename', () => {
+  test('returns timeout when rename hangs', async () => {
+    const result = await raceDiscordRename({
+      rename: new Promise(() => {}),
+      timeoutMs: 20,
+    })
+    expect(result).toBe('timeout')
+  })
+
+  test('returns rename result when it finishes first', async () => {
+    const result = await raceDiscordRename({
+      rename: Promise.resolve('ok'),
+      timeoutMs: 1000,
+    })
+    expect(result).toBe('ok')
+  })
+})

package/src/discord-utils.ts

@@ -21,6 +21,11 @@ import type { OpencodeClient } from '@opencode-ai/sdk/v2'
 import { discordApiUrl } from './discord-urls.js'
 import { Lexer } from 'marked'
 import { splitTablesFromMarkdown } from './format-tables.js'
+import {
+  sessionPartContent,
+  shouldLeadWithBlankLine,
+  type SessionChunk,
+} from './message-formatting.js'
 import { getChannelDirectory, getThreadWorktreeOrWorkspace } from './database.js'
 import { DiscordOperationError } from './errors.js'
 import { limitHeadingDepth } from './limit-heading-depth.js'
@@ -254,12 +259,6 @@ export async function archiveThread({
     if (updateResult instanceof Error) {
       discordLogger.warn(`[archive-thread] ${updateResult.message}`)
     }
-
-    const abortResult = await client.session.abort({ sessionID: sessionId })
-      .catch((e) => new Error('Failed to abort session', { cause: e }))
-    if (abortResult instanceof Error) {
-      discordLogger.warn(`[archive-thread] ${abortResult.message}`)
-    }
   }
 
   if (archiveDelay > 0) {
@@ -275,6 +274,27 @@ export async function archiveThread({
   })
 }
 
+export const DISCORD_THREAD_RENAME_TIMEOUT_MS = 3000
+
+// Discord rename can hang on the 3rd call (~2 per 10 min). Race so it never blocks.
+export async function raceDiscordRename<T>({
+  rename,
+  timeoutMs = DISCORD_THREAD_RENAME_TIMEOUT_MS,
+}: {
+  rename: Promise<T>
+  timeoutMs?: number
+}): Promise<T | 'timeout'> {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs)
+  return Promise.race([
+    rename,
+    new Promise<'timeout'>((resolve) => {
+      timeoutSignal.addEventListener('abort', () => {
+        resolve('timeout')
+      })
+    }),
+  ])
+}
+
 /**
  * Add a user as a thread member so the thread shows up in their Discord left
  * sidebar. Discord only lists threads you are a member of, so a scheduled
@@ -312,6 +332,91 @@ export async function ensureThreadMember({
   if (addMemberResult instanceof Error) return addMemberResult
 }
 
+export type FooterMentionMember = {
+  id: string
+  bot?: boolean
+  joinedTimestamp?: number | null
+}
+
+export function resolveFooterMentionUserId({
+  sessionUserId,
+  botUserId,
+  threadOwnerId,
+  members,
+}: {
+  sessionUserId: string | undefined
+  botUserId: string | undefined
+  threadOwnerId: string | undefined
+  members: FooterMentionMember[]
+}): string | undefined {
+  if (sessionUserId && sessionUserId !== botUserId) return sessionUserId
+  if (!botUserId || threadOwnerId !== botUserId) return undefined
+  const humans = members
+    .filter((member) => member.id && member.id !== botUserId && member.bot === false)
+    .sort((a, b) => {
+      const aJoined = a.joinedTimestamp ?? Number.POSITIVE_INFINITY
+      const bJoined = b.joinedTimestamp ?? Number.POSITIVE_INFINITY
+      if (aJoined !== bJoined) return aJoined - bJoined
+      return a.id.localeCompare(b.id)
+    })
+  return humans[0]?.id
+}
+
+function footerMentionMembersFromCache(thread: ThreadChannel): FooterMentionMember[] {
+  return [...thread.members.cache.values()].map((member) => ({
+    id: member.id,
+    bot: member.user?.bot,
+    joinedTimestamp: member.joinedTimestamp ?? null,
+  }))
+}
+
+export async function resolveThreadFooterMentionUserId({
+  sessionUserId,
+  thread,
+}: {
+  sessionUserId: string | undefined
+  thread: ThreadChannel
+}): Promise<string | undefined> {
+  const botUserId = thread.client.user?.id
+  if (sessionUserId && sessionUserId !== botUserId) return sessionUserId
+  if (!botUserId || thread.ownerId !== botUserId) return undefined
+
+  const cached = footerMentionMembersFromCache(thread)
+  if (cached.some((member) => member.bot === false && member.id !== botUserId)) {
+    return resolveFooterMentionUserId({
+      sessionUserId,
+      botUserId,
+      threadOwnerId: thread.ownerId ?? undefined,
+      members: cached,
+    })
+  }
+
+  const fetched = await thread.members.fetch().catch((e) => {
+    return new DiscordOperationError({ operation: 'fetchThreadMembers', cause: e })
+  })
+  if (fetched instanceof Error) {
+    discordLogger.warn(`[FOOTER] Failed to fetch thread members: ${fetched.message}`)
+    return resolveFooterMentionUserId({
+      sessionUserId,
+      botUserId,
+      threadOwnerId: thread.ownerId ?? undefined,
+      members: cached,
+    })
+  }
+
+  const members = [...fetched.values()].map((member) => ({
+    id: member.id,
+    bot: member.user?.bot,
+    joinedTimestamp: member.joinedTimestamp ?? null,
+  }))
+  return resolveFooterMentionUserId({
+    sessionUserId,
+    botUserId,
+    threadOwnerId: thread.ownerId ?? undefined,
+    members,
+  })
+}
+
 /** Remove Discord mentions from text so they don't appear in thread titles */
 export function stripMentions(text: string): string {
   return text
@@ -611,7 +716,7 @@ export function splitMarkdownForDiscord({
 }
 
 export async function sendThreadMessage(
-  thread: ThreadChannel,
+  thread: ThreadChannel | TextChannel,
   content: string,
   options?: { flags?: number },
 ): Promise<Message> {
@@ -675,6 +780,46 @@ export async function sendThreadMessage(
   return firstMessage!
 }
 
+export async function sendSessionPartMessage(
+  thread: ThreadChannel,
+  content: string,
+  options?: {
+    leadWithBlankLine?: boolean
+    flags?: number
+  },
+): Promise<Message> {
+  return sendThreadMessage(
+    thread,
+    sessionPartContent({
+      content,
+      leadWithBlankLine: options?.leadWithBlankLine === true,
+    }),
+    { flags: options?.flags },
+  )
+}
+
+export async function sendSessionPartBatches({
+  thread,
+  batches,
+}: {
+  thread: ThreadChannel
+  batches: SessionChunk[]
+}) {
+  const sent: Array<{ partIds: string[]; message: Message }> = []
+  let previousKind: SessionChunk['kind'] | undefined
+  for (const batch of batches) {
+    const message = await sendSessionPartMessage(thread, batch.content, {
+      leadWithBlankLine: shouldLeadWithBlankLine({
+        previousKind,
+        nextKind: batch.kind,
+      }),
+    })
+    previousKind = batch.kind
+    sent.push({ partIds: batch.partIds, message })
+  }
+  return sent
+}
+
 export function isThreadChannelType(type: number): boolean {
   return [
     ChannelType.PublicThread,

package/src/errors.ts

@@ -24,6 +24,12 @@ export class ServerNotReadyError extends errore.createTaggedError({
     'OpenCode client for directory "$directory" is not available because the shared server is not ready',
 }) {}
 
+export class OpencodeIncompatibleVersionError extends errore.createTaggedError({
+  name: 'OpencodeIncompatibleVersionError',
+  message:
+    'Kimaki is not compatible with OpenCode version $version. Install an OpenCode 1.x release.',
+}) {}
+
 export class ApiKeyMissingError extends errore.createTaggedError({
   name: 'ApiKeyMissingError',
   message: '$service API key is required',
@@ -117,6 +123,11 @@ export class OpenCodeSdkError extends errore.createTaggedError({
   message: 'OpenCode SDK call failed: $operation',
 }) {}
 
+export class InvalidModelError extends errore.createTaggedError({
+  name: 'InvalidModelError',
+  message: 'Invalid model "$model": $reason',
+}) {}
+
 export class FilesystemOperationError extends errore.createTaggedError({
   name: 'FilesystemOperationError',
   message: 'Filesystem operation failed: $operation',
@@ -214,6 +225,7 @@ export type OpenCodeErrors =
   | DirectoryNotAccessibleError
   | ServerStartError
   | ServerNotReadyError
+  | OpencodeIncompatibleVersionError
 
 export type SessionErrors =
   | SessionNotFoundError

package/src/exec-async.ts

@@ -1,32 +1,41 @@
-import { exec } from 'node:child_process'
+import { exec, execFile } from 'node:child_process'
 import { promisify } from 'node:util'
 
 const DEFAULT_EXEC_TIMEOUT_MS = 10_000
 
 const _execAsync = promisify(exec)
+const _execFileAsync = promisify(execFile)
 
 export function execAsync(
-  command: string,
+  command: string | { command: string; args: string[] },
   options?: Parameters<typeof _execAsync>[1],
 ): Promise<{ stdout: string; stderr: string }> {
-  const timeoutMs =
-    (options as { timeout?: number })?.timeout || DEFAULT_EXEC_TIMEOUT_MS
-  const execPromise = _execAsync(command, options) as Promise<{
-    stdout: string
-    stderr: string
-  }> & { child?: import('node:child_process').ChildProcess }
+  const timeoutMs = options?.timeout || DEFAULT_EXEC_TIMEOUT_MS
+  const childPromise =
+    typeof command === 'string'
+      ? _execAsync(command, options)
+      : _execFileAsync(command.command, command.args, options)
+  const execPromise = childPromise.then(({ stdout, stderr }) => {
+    return {
+      stdout: typeof stdout === 'string' ? stdout : stdout.toString(),
+      stderr: typeof stderr === 'string' ? stderr : stderr.toString(),
+    }
+  })
+  const commandLabel = typeof command === 'string'
+    ? command
+    : [command.command, ...command.args].join(' ')
   let timer: ReturnType<typeof setTimeout> | undefined
   const timeoutPromise = new Promise<never>((_, reject) => {
     timer = setTimeout(() => {
-      const pid = execPromise.child?.pid
+      const pid = childPromise.child?.pid
       if (pid) {
         try {
           process.kill(-pid, 'SIGTERM')
         } catch {
-          execPromise.child?.kill('SIGTERM')
+          childPromise.child?.kill('SIGTERM')
         }
       }
-      reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`))
+      reject(new Error(`Command timed out after ${timeoutMs}ms: ${commandLabel}`))
     }, timeoutMs)
   })
   return Promise.race([execPromise, timeoutPromise]).finally(() => {

package/src/external-directory-permissions.e2e.test.ts

@@ -81,18 +81,22 @@ describe('external directory permissions', () => {
       "--- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER first
       --- from: assistant (TestBot)
-      *using deterministic-provider/deterministic-v2*
-      ⬥ reading external directory
+      > *using deterministic-provider/deterministic-v2*
+      > reading external directory
+
       ┣ read *probe.txt*
-      ⬥ external-directory-probe-done
-      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+
+      > external-directory-probe-done
+      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
       --- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER followup
       --- from: assistant (TestBot)
-      ⬥ reading external directory
+      > reading external directory
+
       ┣ read *probe.txt*
-      ⬥ external-directory-probe-done
-      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+
+      > external-directory-probe-done
+      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
     `)
     expect(text).not.toContain('Permission Required')
   })

package/src/external-directory-project-deny.e2e.test.ts

@@ -67,10 +67,12 @@ describe('external directory project deny', () => {
       "--- from: user (external-directory-deny-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER denied
       --- from: assistant (TestBot)
-      *using deterministic-provider/deterministic-v2*
-      ⬥ reading external directory
+      > *using deterministic-provider/deterministic-v2*
+      > reading external directory
+
       ┣ read *probe.txt*
-      ⬥ external-directory-probe-denied"
+
+      > external-directory-probe-denied"
     `)
 
     // A deny is silent: it must not fall back to asking the user.