kimaki 0.25.0 → 0.26.0

package/src/cli-runner.ts

@@ -57,7 +57,6 @@ import { discordApiUrl, getDiscordRestApiUrl, getGatewayProxyRestBaseUrl, getInt
 import crypto from 'node:crypto'
 import path from 'node:path'
 import fs from 'node:fs'
-import os from 'node:os'
 import { spawn } from 'node:child_process'
 import { createLogger, LogPrefix } from './logger.js'
 import { notifyError } from './sentry.js'
@@ -206,6 +205,44 @@ export async function resolveBotCredentials({ appIdOverride }: { appIdOverride?:
 
 export { isThreadChannelType }
 
+/** Wrap long lines so prompt.md is readable in Discord's attachment preview. */
+function wrapPromptAttachmentText(prompt: string): string {
+  return prompt
+    .split('\n')
+    .flatMap((line) => {
+      if (line.length <= 120) {
+        return [line]
+      }
+      const wrapped: string[] = []
+      let remaining = line
+      const maxCol = 120
+      // Only soft-break at a space if it's reasonably close to maxCol,
+      // otherwise hard-break to avoid tiny fragments from early spaces
+      const minSoftBreak = 90
+      while (remaining.length > maxCol) {
+        const lastSpace = remaining.lastIndexOf(' ', maxCol)
+        const useSoftBreak = lastSpace >= minSoftBreak
+        const breakAt = useSoftBreak ? lastSpace : maxCol
+        wrapped.push(remaining.slice(0, breakAt))
+        // Only consume the separator space on soft breaks
+        remaining = useSoftBreak
+          ? remaining.slice(breakAt + 1)
+          : remaining.slice(breakAt)
+      }
+      if (remaining.length > 0) {
+        wrapped.push(remaining)
+      }
+      return wrapped
+    })
+    .join('\n')
+}
+
+function promptAttachmentBlob(text: string) {
+  return new Blob([new Uint8Array(Buffer.from(text, 'utf8'))], {
+    type: 'text/markdown',
+  })
+}
+
 export async function sendDiscordMessageWithOptionalAttachment({
   channelId,
   prompt,
@@ -219,7 +256,8 @@ export async function sendDiscordMessageWithOptionalAttachment({
   prompt: string
   botToken: string
   embeds?: Array<{ color: number; footer: { text: string } }>
-  rest: REST
+  /** Only `post` is used (short prompt / split paths). Accept a narrow shape so tests need no cast. */
+  rest: Pick<REST, 'post'>
   /** When true, long messages are split into multiple Discord messages instead of
    *  being attached as a file. Useful for notify-only messages where the content
    *  should be directly visible in the channel. */
@@ -246,24 +284,26 @@ export async function sendDiscordMessageWithOptionalAttachment({
     }
 
     // When prompt exceeds Discord's limit, attach it as prompt.md alongside
-    // user files so nothing is silently lost.
+    // user files so nothing is silently lost. Build prompt.md from memory so
+    // parallel kimaki send processes never share or unlink a temp path.
     const isLongPrompt = prompt.length > discordMaxLength
     const content = isLongPrompt
       ? `Prompt attached as file (${prompt.length} chars)\n\n> ${prompt.slice(0, 100).replace(/\n/g, ' ')}...`
       : prompt
 
-    // Build attachment metadata: user files + optional prompt.md
-    const allFiles: Array<{ filePath: string; filename: string; mimeType: string }> = files.map((file) => ({
-      filePath: file,
-      filename: path.basename(file),
-      mimeType: mime.getType(file) || 'application/octet-stream',
-    }))
+    const allFiles: Array<{ data: Uint8Array; filename: string; mimeType: string }> =
+      files.map((file) => ({
+        data: new Uint8Array(fs.readFileSync(file)),
+        filename: path.basename(file),
+        mimeType: mime.getType(file) || 'application/octet-stream',
+      }))
 
     if (isLongPrompt) {
-      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-prompt-'))
-      const tmpFile = path.join(tmpDir, 'prompt.md')
-      fs.writeFileSync(tmpFile, prompt)
-      allFiles.push({ filePath: tmpFile, filename: 'prompt.md', mimeType: 'text/markdown' })
+      allFiles.push({
+        data: new Uint8Array(Buffer.from(prompt, 'utf8')),
+        filename: 'prompt.md',
+        mimeType: 'text/markdown',
+      })
     }
 
     const attachments = allFiles.map((f, index) => ({
@@ -283,10 +323,9 @@ export async function sendDiscordMessageWithOptionalAttachment({
     )
 
     for (const [index, f] of allFiles.entries()) {
-      const buffer = fs.readFileSync(f.filePath)
       formData.append(
         `files[${index}]`,
-        new Blob([buffer], { type: f.mimeType }),
+        new Blob([f.data], { type: f.mimeType }),
         f.filename,
       )
     }
@@ -344,82 +383,42 @@ export async function sendDiscordMessageWithOptionalAttachment({
 
   const preview = prompt.slice(0, 100).replace(/\n/g, ' ')
   const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`
+  // In-memory Blob only — no temp file. Parallel send must never share a path.
+  const formData = new FormData()
+  formData.append(
+    'payload_json',
+    JSON.stringify({
+      content: summaryContent,
+      attachments: [{ id: 0, filename: 'prompt.md' }],
+      embeds,
+      allowed_mentions: { parse: store.getState().allowedMentions },
+    }),
+  )
+  formData.append(
+    'files[0]',
+    promptAttachmentBlob(wrapPromptAttachmentText(prompt)),
+    'prompt.md',
+  )
 
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-prompt-'))
-  const tmpFile = path.join(tmpDir, 'prompt.md')
-  // Wrap long lines so the file is readable in Discord's preview
-  // (Discord doesn't wrap text in file attachments)
-  const wrappedPrompt = prompt
-    .split('\n')
-    .flatMap((line) => {
-      if (line.length <= 120) {
-        return [line]
-      }
-      const wrapped: string[] = []
-      let remaining = line
-      const maxCol = 120
-      // Only soft-break at a space if it's reasonably close to maxCol,
-      // otherwise hard-break to avoid tiny fragments from early spaces
-      const minSoftBreak = 90
-      while (remaining.length > maxCol) {
-        const lastSpace = remaining.lastIndexOf(' ', maxCol)
-        const useSoftBreak = lastSpace >= minSoftBreak
-        const breakAt = useSoftBreak ? lastSpace : maxCol
-        wrapped.push(remaining.slice(0, breakAt))
-        // Only consume the separator space on soft breaks
-        remaining = useSoftBreak
-          ? remaining.slice(breakAt + 1)
-          : remaining.slice(breakAt)
-      }
-      if (remaining.length > 0) {
-        wrapped.push(remaining)
-      }
-      return wrapped
-    })
-    .join('\n')
-  fs.writeFileSync(tmpFile, wrappedPrompt)
-
-  try {
-    const formData = new FormData()
-    formData.append(
-      'payload_json',
-      JSON.stringify({
-        content: summaryContent,
-        attachments: [{ id: 0, filename: 'prompt.md' }],
-        embeds,
-        allowed_mentions: { parse: store.getState().allowedMentions },
-      }),
-    )
-    const buffer = fs.readFileSync(tmpFile)
-    formData.append(
-      'files[0]',
-      new Blob([buffer], { type: 'text/markdown' }),
-      'prompt.md',
-    )
-
-    const starterMessageResponse = await fetch(
-      discordApiUrl(`/channels/${channelId}/messages`),
-      {
-        method: 'POST',
-        headers: {
-          Authorization: `Bot ${botToken}`,
-        },
-        body: formData,
+  const starterMessageResponse = await fetch(
+    discordApiUrl(`/channels/${channelId}/messages`),
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Bot ${botToken}`,
       },
-    )
-
-    if (!starterMessageResponse.ok) {
-      const error = await starterMessageResponse.text()
-      throw new Error(
-        `Discord API error: ${starterMessageResponse.status} - ${error}`,
-      )
-    }
+      body: formData,
+    },
+  )
 
-    return (await starterMessageResponse.json()) as { id: string }
-  } finally {
-    fs.unlinkSync(tmpFile)
-    fs.rmdirSync(tmpDir)
+  if (!starterMessageResponse.ok) {
+    const error = await starterMessageResponse.text()
+    throw new Error(
+      `Discord API error: ${starterMessageResponse.status} - ${error}`,
+    )
   }
+
+  return (await starterMessageResponse.json()) as { id: string }
 }
 
 export function formatRelativeTime(target: Date): string {
@@ -465,7 +464,7 @@ export type GuildMemberSearchResult = {
 
 export type DiscordUserTarget = {
   id: string
-  username: string
+  username?: string
 }
 
 export function isGuildMemberSearchResult(value: object | null): value is GuildMemberSearchResult {
@@ -615,7 +614,7 @@ export async function resolveDiscordUserOption({
   const directUserId = getDiscordUserIdFromUserOption(user)
   if (directUserId) {
     cliLogger.log(`Using Discord user ID: ${directUserId}`)
-    return { id: directUserId, username: directUserId }
+    return { id: directUserId }
   }
 
   cliLogger.log(`Searching for user "${user}" in guild...`)

package/src/commands/agent.ts

@@ -11,6 +11,7 @@ import {
   ChannelType,
   ThreadAutoArchiveDuration,
   type ThreadChannel,
+  type TextChannel,
   MessageFlags,
 } from 'discord.js'
 import crypto from 'node:crypto'
@@ -32,7 +33,11 @@ import {
 } from '../discord-utils.js'
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js'
 import { createLogger, LogPrefix } from '../logger.js'
-import { getCurrentModelInfo } from './model.js'
+import {
+  formatModelSource,
+  getCurrentModelInfo,
+  type CurrentModelInfo,
+} from './model.js'
 import { isGitRepositoryRoot } from '../worktrees.js'
 import {
   formatAutoWorktreeName,
@@ -45,24 +50,18 @@ import { store } from '../store.js'
 const agentLogger = createLogger(LogPrefix.AGENT)
 
 const AGENT_CONTEXT_TTL_MS = 10 * 60 * 1000
-const pendingAgentContexts = new Map<
-  string,
-  {
-    dir: string
-    channelId: string
-    sessionId?: string
-    isThread: boolean
-  }
->()
+const pendingAgentContexts = new Map<string, AgentCommandContext>()
 
 /**
  * Context for agent commands, containing channel/session info.
  */
 export type AgentCommandContext = {
   dir: string
+  workingDirectory: string
   channelId: string
   sessionId?: string
   isThread: boolean
+  appId: string
 }
 
 export type CurrentAgentInfo =
@@ -188,6 +187,7 @@ async function resolveQuickAgentNameFromInteraction({
  */
 export async function resolveAgentCommandContext({
   interaction,
+  appId,
 }: {
   interaction: ChatInputCommandInteraction
   appId: string
@@ -207,41 +207,40 @@ export async function resolveAgentCommandContext({
     ChannelType.AnnouncementThread,
   ].includes(channel.type)
 
-  let projectDirectory: string | undefined
-  let targetChannelId: string
-  let sessionId: string | undefined
-
-  if (isThread) {
-    const thread = channel as ThreadChannel
-    const textChannel = await resolveTextChannel(thread)
-    const metadata = await getKimakiMetadata(textChannel)
-    projectDirectory = metadata.projectDirectory
-    targetChannelId = textChannel?.id || channel.id
-
-    sessionId = await getThreadSession(thread.id)
-  } else if (channel.type === ChannelType.GuildText) {
-    const metadata = await getKimakiMetadata(channel)
-    projectDirectory = metadata.projectDirectory
-    targetChannelId = channel.id
-  } else {
+  if (
+    !isThread &&
+    channel.type !== ChannelType.GuildText
+  ) {
     await interaction.editReply({
       content: 'This command can only be used in text channels or threads',
     })
     return null
   }
 
-  if (!projectDirectory) {
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+  if (!resolved) {
     await interaction.editReply({
       content: 'This channel is not configured with a project directory',
     })
     return null
   }
 
+  const textChannel = isThread
+    ? await resolveTextChannel(channel as ThreadChannel)
+    : undefined
+  const sessionId = isThread
+    ? await getThreadSession(channel.id)
+    : undefined
+
   return {
-    dir: projectDirectory,
-    channelId: targetChannelId,
+    dir: resolved.projectDirectory,
+    workingDirectory: resolved.workingDirectory,
+    channelId: textChannel?.id || channel.id,
     sessionId,
     isThread,
+    appId,
   }
 }
 
@@ -270,6 +269,60 @@ export async function setAgentForContext({
   }
 }
 
+function formatAgentModelLine(modelInfo: CurrentModelInfo): string {
+  if (modelInfo.type === 'none') return ''
+  const source = formatModelSource({
+    type: modelInfo.type,
+    agentName: modelInfo.type === 'agent' ? modelInfo.agentName : undefined,
+  })
+  const line = `\nModel: *${modelInfo.model}* (${source})`
+  if (modelInfo.type !== 'session' && modelInfo.type !== 'channel') {
+    return line
+  }
+  return `${line}\nThis model comes from a ${modelInfo.type} override. Use /model and press Clear override if you want this agent's model.`
+}
+
+function formatAgentPreferenceReply({
+  agentName,
+  previousAgentName,
+  modelInfo,
+  scope,
+}: {
+  agentName: string
+  previousAgentName?: string
+  modelInfo: CurrentModelInfo
+  scope: 'session' | 'channel'
+}): string {
+  const sameAgent = previousAgentName === agentName
+  const verb = sameAgent ? 'Using' : 'Switched to'
+  const previousText =
+    !sameAgent && previousAgentName ? ` (was **${previousAgentName}**)` : ''
+  const modelText = formatAgentModelLine(modelInfo)
+  if (scope === 'session') {
+    return `${verb} **${agentName}** agent for this session${previousText}${modelText}\nThe agent will change on the next message.`
+  }
+  return `${verb} **${agentName}** agent for this channel${previousText}${modelText}\nAll new sessions will use this agent.`
+}
+
+async function resolveAgentModelInfo({
+  context,
+  agentName,
+}: {
+  context: AgentCommandContext
+  agentName: string
+}): Promise<CurrentModelInfo> {
+  const getClient = await initializeOpencodeForDirectory(context.dir)
+  if (getClient instanceof Error) return { type: 'none' }
+  return getCurrentModelInfo({
+    sessionId: context.sessionId,
+    channelId: context.channelId,
+    appId: context.appId,
+    agentPreference: agentName,
+    getClient,
+    directory: context.workingDirectory,
+  })
+}
+
 export async function handleAgentCommand({
   interaction,
   appId,
@@ -292,7 +345,7 @@ export async function handleAgentCommand({
     }
 
     const agentsResponse = await getClient().app.agents({
-      directory: context.dir,
+      directory: context.workingDirectory,
     })
 
     if (!agentsResponse.data || agentsResponse.data.length === 0) {
@@ -392,19 +445,30 @@ export async function handleAgentSelectMenu(
   }
 
   try {
+    const previousAgent = await getCurrentAgentInfo({
+      sessionId: context.sessionId,
+      channelId: context.channelId,
+    })
+    const previousAgentName =
+      previousAgent.type !== 'none' ? previousAgent.agent : undefined
+
     await setAgentForContext({ context, agentName: selectedAgent })
+    const modelInfo = await resolveAgentModelInfo({
+      context,
+      agentName: selectedAgent,
+    })
+    const scope =
+      context.isThread && context.sessionId ? 'session' : 'channel'
 
-    if (context.isThread && context.sessionId) {
-      await interaction.editReply({
-        content: `Agent preference set for this session: **${selectedAgent}**\nThe agent will change on the next message.`,
-        components: [],
-      })
-    } else {
-      await interaction.editReply({
-        content: `Agent preference set for this channel: **${selectedAgent}**\nAll new sessions in this channel will use this agent.`,
-        components: [],
-      })
-    }
+    await interaction.editReply({
+      content: formatAgentPreferenceReply({
+        agentName: selectedAgent,
+        previousAgentName,
+        modelInfo,
+        scope,
+      }),
+      components: [],
+    })
 
     pendingAgentContexts.delete(contextHash)
   } catch (error) {
@@ -465,51 +529,23 @@ export async function handleQuickAgentCommand({
     const previousAgentName =
       previousAgent.type !== 'none' ? previousAgent.agent : undefined
 
-    if (previousAgentName === resolvedAgentName) {
-      await command.editReply({
-        content: `Already using **${resolvedAgentName}** agent`,
-      })
-      return
-    }
-
-    // Set the agent preference in DB for this context.
     await setAgentForContext({ context, agentName: resolvedAgentName })
 
-    const previousText = previousAgentName
-      ? ` (was **${previousAgentName}**)`
-      : ''
-
-    // Resolve the model that will now be used for the new agent so we can
-    // show it in the reply. setAgentForContext already cleared any session
-    // model preference, so getCurrentModelInfo falls through to the agent's
-    // configured model (or channel/global/default).
-    const modelInfo = await (async () => {
-      const getClient = await initializeOpencodeForDirectory(context.dir)
-      if (getClient instanceof Error) {
-        return { type: 'none' as const }
-      }
-      return getCurrentModelInfo({
-        sessionId: context.sessionId,
-        channelId: context.channelId,
-        appId,
-        agentPreference: resolvedAgentName,
-        getClient,
-        directory: context.dir,
-      })
-    })()
-
-    const modelText =
-      modelInfo.type === 'none' ? '' : `\nModel: *${modelInfo.model}*`
+    const modelInfo = await resolveAgentModelInfo({
+      context,
+      agentName: resolvedAgentName,
+    })
+    const scope =
+      context.isThread && context.sessionId ? 'session' : 'channel'
 
-    if (context.isThread && context.sessionId) {
-      await command.editReply({
-        content: `Switched to **${resolvedAgentName}** agent for this session${previousText}${modelText}\nThe agent will change on the next message.`,
-      })
-    } else {
-      await command.editReply({
-        content: `Switched to **${resolvedAgentName}** agent for this channel${previousText}${modelText}\nAll new sessions will use this agent.`,
-      })
-    }
+    await command.editReply({
+      content: formatAgentPreferenceReply({
+        agentName: resolvedAgentName,
+        previousAgentName,
+        modelInfo,
+        scope,
+      }),
+    })
   } catch (error) {
     agentLogger.error('Error in quick agent command:', error)
     await command.editReply({

package/src/commands/model.ts

@@ -150,6 +150,31 @@ export type CurrentModelInfo =
     }
   | { type: 'none' }
 
+export function formatModelSource({
+  type,
+  agentName,
+}: {
+  type: CurrentModelInfo['type'] | string
+  agentName?: string
+}): string {
+  switch (type) {
+    case 'session':
+      return 'session override'
+    case 'agent':
+      return `agent "${agentName}"`
+    case 'channel':
+      return 'channel override'
+    case 'global':
+      return 'global default'
+    case 'opencode-config':
+    case 'opencode-recent':
+    case 'opencode-provider-default':
+      return 'opencode default'
+    default:
+      return 'none'
+  }
+}
+
 function parseModelId(
   modelString: string,
 ): { providerID: string; modelID: string } | undefined {