kimaki 0.25.0 → 0.27.0

package/src/message-formatting.test.ts

@@ -1,5 +1,8 @@
-import { describe, test, expect } from 'vitest'
-import { formatBashToolTitle, formatPart, formatTodoList, serializeEmbeds, serializePoll, serializeMessageSnapshots } from './message-formatting.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterEach, describe, test, expect } from 'vitest'
+import { formatBashToolTitle, formatPart, formatTaskToolTitle, formatTodoList, getTextAttachments, serializeEmbeds, serializePoll, serializeMessageSnapshots, TEXT_ATTACHMENT_INLINE_LIMIT_BYTES } from './message-formatting.js'
+import { getDataDir } from './config.js'
 import type { Collection, Embed, Message, MessageSnapshot, Poll } from 'discord.js'
 import type { Part } from '@opencode-ai/sdk/v2'
 
@@ -48,6 +51,105 @@ describe('formatPart', () => {
   })
 })
 
+describe('formatTaskToolTitle', () => {
+  function taskPart({
+    status,
+    input = {},
+    title = '',
+    sessionId,
+  }: {
+    status: 'running' | 'completed'
+    input?: { description?: string; subagent_type?: string }
+    title?: string
+    sessionId?: string
+  }): Extract<Part, { type: 'tool' }> {
+    const base = {
+      id: 'prt_task',
+      type: 'tool' as const,
+      tool: 'task',
+      callID: 'call_task',
+      sessionID: 'ses_parent',
+      messageID: 'msg_assistant',
+    }
+    if (status === 'completed') {
+      return {
+        ...base,
+        state: {
+          status,
+          input,
+          output: '',
+          title,
+          metadata: sessionId ? { sessionId } : {},
+          time: { start: 1, end: 2 },
+        },
+      }
+    }
+    return {
+      ...base,
+      state: {
+        status,
+        input,
+        title,
+        metadata: sessionId ? { sessionId } : {},
+        time: { start: 1 },
+      },
+    }
+  }
+
+  test('uses the running task title when OpenAI omits the description', () => {
+    expect(
+      formatTaskToolTitle(
+        taskPart({
+          status: 'running',
+          input: { subagent_type: 'general' },
+          title: 'Classify pending changes',
+          sessionId: 'ses_child',
+        }),
+      ),
+    ).toMatchInlineSnapshot(`"┣ general **Classify pending changes**"`)
+  })
+
+  test('prefers input description on running parts', () => {
+    expect(
+      formatTaskToolTitle(
+        taskPart({
+          status: 'running',
+          input: { description: 'inspect repo', subagent_type: 'explore' },
+          title: 'ignored title',
+          sessionId: 'ses_child',
+        }),
+      ),
+    ).toMatchInlineSnapshot(`"┣ explore **inspect repo**"`)
+  })
+
+  test('does not format completed parts so Discord does not post the line at the end', () => {
+    expect(
+      formatTaskToolTitle(
+        taskPart({
+          status: 'completed',
+          input: { subagent_type: 'general' },
+          title: 'Classify pending changes',
+          sessionId: 'ses_child',
+        }),
+      ),
+    ).toBe('')
+  })
+
+  test('shows queued task calls before the child session exists', () => {
+    expect(
+      formatTaskToolTitle(
+        taskPart({
+          status: 'running',
+          input: {
+            description: 'audit customer pages',
+            subagent_type: 'general',
+          },
+        }),
+      ),
+    ).toMatchInlineSnapshot(`"┣ general **audit customer pages**"`)
+  })
+})
+
 describe('formatBashToolTitle', () => {
   test('short single-line command shown in full', () => {
     expect(formatBashToolTitle({ command: 'echo hello' })).toMatchInlineSnapshot(`" _echo hello_"`)
@@ -429,3 +531,170 @@ describe('serializeMessageSnapshots', () => {
     `)
   })
 })
+
+describe('getTextAttachments', () => {
+  const originalFetch = globalThis.fetch
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  function stubFetch(impl: (url: string) => Promise<Response>) {
+    const fetchFn = async (input: string | URL | Request) => impl(String(input))
+    fetchFn.preconnect = () => {}
+    globalThis.fetch = fetchFn
+  }
+
+  function messageWithAttachments(
+    attachments: Array<{
+      id: string
+      name: string
+      contentType: string
+      url: string
+      size: number
+    }>,
+  ) {
+    return {
+      attachments: new Map(attachments.map((attachment) => {
+        return [attachment.id, attachment]
+      })),
+    } as unknown as Message
+  }
+
+  function snapshotAttachments(result: string) {
+    return result.replaceAll(getDataDir(), '<dataDir>')
+  }
+
+  test('inlines small text files and saves them locally', async () => {
+    stubFetch(async () => {
+      return new Response('hello from file', { status: 200 })
+    })
+
+    const result = await getTextAttachments(
+      messageWithAttachments([
+        {
+          id: 'att1',
+          name: 'notes.txt',
+          contentType: 'text/plain',
+          url: 'https://cdn.example/notes.txt',
+          size: 16,
+        },
+      ]),
+    )
+
+    const savedPath = path.join(getDataDir(), 'attachments', 'att1-notes.txt')
+    expect(fs.readFileSync(savedPath, 'utf8')).toBe('hello from file')
+    expect(result).toContain('https://cdn.example/notes.txt')
+    expect(result).toContain(savedPath)
+    expect(snapshotAttachments(result)).toMatchInlineSnapshot(`
+      "<attachment filename="notes.txt" mime="text/plain" size="16" url="https://cdn.example/notes.txt" path="<dataDir>/attachments/att1-notes.txt">
+      hello from file
+      </attachment>"
+    `)
+  })
+
+  test('saves large text files locally without inlining contents', async () => {
+    stubFetch(async () => {
+      return new Response('SHOULD NOT BE INLINED', { status: 200 })
+    })
+
+    const result = await getTextAttachments(
+      messageWithAttachments([
+        {
+          id: 'att2',
+          name: 'huge.log',
+          contentType: 'text/plain',
+          url: 'https://cdn.discordapp.com/attachments/1/2/huge.log',
+          size: TEXT_ATTACHMENT_INLINE_LIMIT_BYTES + 1,
+        },
+      ]),
+    )
+
+    const savedPath = path.join(getDataDir(), 'attachments', 'att2-huge.log')
+    expect(fs.readFileSync(savedPath, 'utf8')).toBe('SHOULD NOT BE INLINED')
+    expect(result).not.toContain('SHOULD NOT BE INLINED')
+    expect(result).toContain('https://cdn.discordapp.com/attachments/1/2/huge.log')
+    expect(result).toContain(savedPath)
+    expect(result).toContain('text/plain')
+    expect(result).toContain(String(TEXT_ATTACHMENT_INLINE_LIMIT_BYTES + 1))
+    expect(snapshotAttachments(result)).toMatchInlineSnapshot(`
+      "<attachment filename="huge.log" mime="text/plain" size="65537" url="https://cdn.discordapp.com/attachments/1/2/huge.log" path="<dataDir>/attachments/att2-huge.log" large="true">
+      This file is large (64 KB, text/plain). Contents were not inlined to save context. Read the local path.
+      </attachment>"
+    `)
+  })
+
+  test('still inlines large prompt.md attachments from kimaki send', async () => {
+    stubFetch(async () => {
+      return new Response('the actual long prompt', { status: 200 })
+    })
+
+    const result = await getTextAttachments(
+      messageWithAttachments([
+        {
+          id: 'att3',
+          name: 'prompt.md',
+          contentType: 'text/markdown',
+          url: 'https://cdn.example/prompt.md',
+          size: TEXT_ATTACHMENT_INLINE_LIMIT_BYTES + 1,
+        },
+      ]),
+    )
+
+    const savedPath = path.join(getDataDir(), 'attachments', 'att3-prompt.md')
+    expect(fs.readFileSync(savedPath, 'utf8')).toBe('the actual long prompt')
+    expect(result).toContain('the actual long prompt')
+    expect(result).toContain('https://cdn.example/prompt.md')
+    expect(result).toContain(savedPath)
+    expect(snapshotAttachments(result)).toMatchInlineSnapshot(`
+      "<attachment filename="prompt.md" mime="text/markdown" size="65537" url="https://cdn.example/prompt.md" path="<dataDir>/attachments/att3-prompt.md">
+      the actual long prompt
+      </attachment>"
+    `)
+  })
+
+  test('keeps small files inlined next to large file references', async () => {
+    stubFetch(async (url) => {
+      if (url.includes('small.txt')) {
+        return new Response('tiny', { status: 200 })
+      }
+      return new Response('SHOULD NOT BE INLINED', { status: 200 })
+    })
+
+    const result = await getTextAttachments(
+      messageWithAttachments([
+        {
+          id: 'att4',
+          name: 'small.txt',
+          contentType: 'text/plain',
+          url: 'https://cdn.example/small.txt',
+          size: 4,
+        },
+        {
+          id: 'att5',
+          name: 'dump.json',
+          contentType: 'application/json',
+          url: 'https://cdn.example/dump.json',
+          size: TEXT_ATTACHMENT_INLINE_LIMIT_BYTES + 50,
+        },
+      ]),
+    )
+
+    expect(result).toContain('tiny')
+    expect(result).not.toContain('SHOULD NOT BE INLINED')
+    expect(result).toContain('https://cdn.example/small.txt')
+    expect(result).toContain('https://cdn.example/dump.json')
+    expect(result).toContain(path.join(getDataDir(), 'attachments', 'att4-small.txt'))
+    expect(result).toContain(path.join(getDataDir(), 'attachments', 'att5-dump.json'))
+    expect(result).toContain('application/json')
+    expect(snapshotAttachments(result)).toMatchInlineSnapshot(`
+      "<attachment filename="small.txt" mime="text/plain" size="4" url="https://cdn.example/small.txt" path="<dataDir>/attachments/att4-small.txt">
+      tiny
+      </attachment>
+
+      <attachment filename="dump.json" mime="application/json" size="65586" url="https://cdn.example/dump.json" path="<dataDir>/attachments/att5-dump.json" large="true">
+      This file is large (64 KB, application/json). Contents were not inlined to save context. Read the local path.
+      </attachment>"
+    `)
+  })
+})

package/src/message-formatting.ts

@@ -10,10 +10,13 @@ export type DiscordFileAttachment = FilePartInput & {
   sourceUrl?: string
 }
 
+import fs from 'node:fs'
+import path from 'node:path'
 import { createLogger, LogPrefix } from './logger.js'
-import { FetchError } from './errors.js'
+import { FetchError, FilesystemOperationError } from './errors.js'
 import { processImage } from './image-utils.js'
 import { parsePatchFileCounts } from './patch-text-parser.js'
+import { getDataDir } from './config.js'
 
 // Generic message type compatible with both v1 and v2 SDK
 type GenericSessionMessage = {
@@ -261,6 +264,52 @@ export function isTextMimeType(contentType: string | null): boolean {
   return TEXT_MIME_TYPES.some((prefix) => contentType.startsWith(prefix))
 }
 
+// Small Discord "send as file" prompts stay inlined. Bigger dumps only get a URL.
+export const TEXT_ATTACHMENT_INLINE_LIMIT_BYTES = 64 * 1024
+const KIMAKI_SEND_PROMPT_ATTACHMENT_NAME = 'prompt.md'
+
+function formatAttachmentSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) {
+    const kb = bytes / 1024
+    return `${kb < 10 ? kb.toFixed(1) : kb.toFixed(0)} KB`
+  }
+  const mb = bytes / (1024 * 1024)
+  return `${mb < 10 ? mb.toFixed(1) : mb.toFixed(0)} MB`
+}
+
+function shouldInlineTextAttachment(attachment: {
+  name: string
+  size: number
+}): boolean {
+  if (attachment.name === KIMAKI_SEND_PROMPT_ATTACHMENT_NAME) return true
+  return attachment.size <= TEXT_ATTACHMENT_INLINE_LIMIT_BYTES
+}
+
+function textAttachmentAttrs(
+  attachment: { name: string; contentType: string | null; size: number; url: string },
+  extra: string[] = [],
+): string {
+  return [
+    `filename="${attachment.name}"`,
+    `mime="${attachment.contentType}"`,
+    `size="${attachment.size}"`,
+    `url="${attachment.url}"`,
+    ...extra,
+  ].join(' ')
+}
+
+function safeAttachmentBasename(name: string): string {
+  const sanitized = path.basename(name).replace(/\0/g, '')
+  if (!sanitized || sanitized === '.' || sanitized === '..') return 'attachment'
+  return sanitized
+}
+
+function localAttachmentPath(attachment: { id?: string; name: string; url: string }): string {
+  const id = attachment.id || attachment.url.slice(-12).replace(/[^a-zA-Z0-9]/g, '')
+  return path.join(getDataDir(), 'attachments', `${id}-${safeAttachmentBasename(attachment.name)}`)
+}
+
 export async function getTextAttachments(message: Message): Promise<string> {
   const textAttachments = Array.from(message.attachments.values()).filter(
     (attachment) => isTextMimeType(attachment.contentType),
@@ -270,18 +319,40 @@ export async function getTextAttachments(message: Message): Promise<string> {
     return ''
   }
 
+  const attachmentsDir = path.join(getDataDir(), 'attachments')
+  fs.mkdirSync(attachmentsDir, { recursive: true })
+
   const textContents = await Promise.all(
     textAttachments.map(async (attachment) => {
       const response = await fetch(attachment.url)
         .catch((e) => new FetchError({ url: attachment.url, cause: e }))
       if (response instanceof Error) {
-        return `<attachment filename="${attachment.name}" error="${response.message}" />`
+        return `<attachment ${textAttachmentAttrs(attachment)} error="${response.message}" />`
       }
       if (!response.ok) {
-        return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`
+        return `<attachment ${textAttachmentAttrs(attachment)} error="Failed to fetch: ${response.status}" />`
       }
-      const text = await response.text()
-      return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`
+
+      const buffer = Buffer.from(await response.arrayBuffer())
+      const savedPath = localAttachmentPath(attachment)
+      const written = await fs.promises
+        .writeFile(savedPath, buffer)
+        .catch((e) => new FilesystemOperationError({ operation: 'write attachment', cause: e }))
+      if (written instanceof Error) {
+        logger.error(`Failed to save attachment ${attachment.name}:`, written.message)
+      }
+      const pathAttr = written instanceof Error ? [] : [`path="${savedPath}"`]
+
+      if (!shouldInlineTextAttachment(attachment)) {
+        const sizeLabel = formatAttachmentSize(attachment.size)
+        return [
+          `<attachment ${textAttachmentAttrs(attachment, [...pathAttr, 'large="true"'])}>`,
+          `This file is large (${sizeLabel}, ${attachment.contentType || 'unknown type'}). Contents were not inlined to save context. Read the local path.`,
+          `</attachment>`,
+        ].join('\n')
+      }
+
+      return `<attachment ${textAttachmentAttrs(attachment, pathAttr)}>\n${buffer.toString('utf8')}\n</attachment>`
     }),
   )
 
@@ -495,6 +566,22 @@ export function getToolSummaryText(part: Part): string {
     return prompt ? `*${escapeInlineMarkdown(prompt.slice(0, 60))}*` : ''
   }
 
+  // LESSON: tool parts are sent to Discord at `running` status (see
+  // shouldSendPart in thread-session-runtime), so `state.title` from the tool
+  // result is never rendered here. Everything shown must come from state.input.
+  // `until` is already absolute; `duration` is relative, so say "for 2h" —
+  // never "until 2h".
+  if (part.tool.endsWith('kimaki_sleep')) {
+    const until = (part.state.input?.until as string) || ''
+    const duration = (part.state.input?.duration as string) || ''
+    const reason = (part.state.input?.reason as string) || ''
+    const when = until ? `until ${until}` : duration ? `for ${duration}` : ''
+    const reasonText = reason ? `_${escapeInlineMarkdown(reason)}_` : ''
+    return [when && escapeInlineMarkdown(when), reasonText]
+      .filter(Boolean)
+      .join(' ')
+  }
+
   if (!part.state.input) return ''
 
   const inputFields = Object.entries(part.state.input)
@@ -536,6 +623,24 @@ export function formatTodoList(part: Part): string {
   return `${num} **${escapeInlineMarkdown(content)}**`
 }
 
+export function formatTaskToolTitle(part: Extract<Part, { type: 'tool' }>): string {
+  // Running only. The child session can be created later when many tasks queue.
+  if (part.tool !== 'task' || part.state.status !== 'running') return ''
+
+  const description = part.state.input?.description
+  const stateTitle = part.state.title
+  const title = typeof description === 'string' && description
+    ? description
+    : typeof stateTitle === 'string'
+      ? stateTitle
+      : ''
+  if (!title) return ''
+
+  const subagentType = part.state.input?.subagent_type
+  const agent = typeof subagentType === 'string' ? subagentType : 'task'
+  return `┣ ${escapeInlineMarkdown(agent)} **${escapeInlineMarkdown(title)}**`
+}
+
 export function formatPart(part: Part, prefix?: string): string {
   const pfx = prefix ? `${prefix} ⋅ ` : ''
 

package/src/oauth-rotation-shared.ts

@@ -1,3 +1,13 @@
+/**
+ * LEGACY. Superseded by @subrouter/opencode, registered alongside the kimaki
+ * plugin in opencode.ts. This whole rotation path only cycles accounts inside
+ * one provider; subrouter also fails over to a different provider when every
+ * account of one is exhausted.
+ *
+ * Kept because opencode ships no Claude Pro/Max auth of its own, so deleting
+ * it would strand anyone still picking `anthropic/*` directly. To move to
+ * subrouter, log in again through /login and pick Subrouter.
+ */
 /**
  * Shared utilities for multi-provider OAuth account rotation.
  * Used by both anthropic-auth-state.ts and openai-auth-state.ts to avoid
@@ -245,6 +255,8 @@ export function shouldRotateAuth(status: number, bodyText: string) {
   const haystack = bodyText.toLowerCase()
   if (status === 429) return true
   if (status === 401 || status === 403) return true
+  // xAI returns 402 Payment Required when Grok Build usage balance is exhausted
+  if (status === 402) return true
   return (
     haystack.includes('rate_limit') ||
     haystack.includes('rate limit') ||
@@ -252,6 +264,7 @@ export function shouldRotateAuth(status: number, bodyText: string) {
     haystack.includes('usage_limit') ||
     haystack.includes('usage_limit_reached') ||
     haystack.includes('usage_not_included') ||
+    haystack.includes('balance exhausted') ||
     haystack.includes('invalid api key') ||
     haystack.includes('authentication_error') ||
     haystack.includes('permission_error')
@@ -262,11 +275,13 @@ export function isRateLimitRetryMessage(message: string) {
   const haystack = message.toLowerCase()
   return (
     haystack.includes('429') ||
+    haystack.includes('402') ||
     haystack.includes('usage limit') ||
     haystack.includes('rate limit') ||
     haystack.includes('rate_limit') ||
     haystack.includes('usage_limit_reached') ||
-    haystack.includes('usage_not_included')
+    haystack.includes('usage_not_included') ||
+    haystack.includes('balance exhausted')
   )
 }
 

package/src/openai-auth-plugin.ts

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * OpenAI OAuth rotation plugin for OpenCode.
  *

package/src/openai-auth-state.ts

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * OpenAI OAuth account store and rotation.
  * Mirrors anthropic-auth-state.ts but for OpenAI/Codex OAuth accounts.
@@ -183,6 +184,25 @@ export async function detectAndRememberNewOpenAIAccount(): Promise<AccountIdenti
     return undefined
   }
 
+  // Check if the identity matches an existing account even though tokens
+  // don't match (happens after token refresh rotates both tokens).
+  // Without this check we'd show a false "account added" toast.
+  if (identity.email || identity.accountId) {
+    const matchesByIdentity = store.accounts.some((account) => {
+      if (identity.accountId && account.accountId === identity.accountId) return true
+      if (identity.email && account.email?.toLowerCase() === identity.email.toLowerCase()) return true
+      return false
+    })
+    if (matchesByIdentity) {
+      await withAuthStateLock(async () => {
+        const freshStore = await loadOpenAIAccountStore()
+        upsertAccount(freshStore, { ...auth, ...identity })
+        await saveOpenAIAccountStore(freshStore)
+      })
+      return undefined
+    }
+  }
+
   // New account: upsert with identity
   await withAuthStateLock(async () => {
     const freshStore = await loadOpenAIAccountStore()

package/src/opencode-command.test.ts

@@ -1,6 +1,7 @@
 // Regression tests for Windows OpenCode command resolution and spawn args.
 
 import fs from 'node:fs'
+import { createRequire } from 'node:module'
 import os from 'node:os'
 import path from 'node:path'
 import { afterEach, beforeEach, describe, expect, test } from 'vitest'
@@ -45,6 +46,86 @@ describe('selectResolvedCommand', () => {
   })
 })
 
+describe('buildOpencodeServeArgs', () => {
+  test('always passes --hostname so opencode.json cannot bind 0.0.0.0', async () => {
+    const { buildOpencodeServeArgs } = await import('./opencode.js')
+    expect(buildOpencodeServeArgs({ port: 4096 })).toEqual([
+      'serve',
+      '--port',
+      '4096',
+      '--hostname',
+      '127.0.0.1',
+      '--print-logs',
+      '--log-level',
+      'WARN',
+    ])
+  })
+
+  test('passes --hostname when set', async () => {
+    const { buildOpencodeServeArgs } = await import('./opencode.js')
+    expect(
+      buildOpencodeServeArgs({ port: 4096, hostname: '0.0.0.0' }),
+    ).toEqual([
+      'serve',
+      '--port',
+      '4096',
+      '--hostname',
+      '0.0.0.0',
+      '--print-logs',
+      '--log-level',
+      'WARN',
+    ])
+  })
+})
+
+describe('published runtime artifacts', () => {
+  test('lists @subrouter/opencode as a runtime dependency', () => {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf8'),
+    ) as { dependencies?: Record<string, string> }
+    expect(pkg.dependencies?.['@subrouter/opencode']).toMatch(/^(workspace:\^|\^)/)
+  })
+})
+
+describe('resolveSubrouterPluginSpec', () => {
+  test('uses npm package identity in production for OpenCode deduplication', async () => {
+    const { resolveSubrouterPluginSpec } = await import('./opencode.js')
+    const require = createRequire(import.meta.url)
+    const packageJsonPath = require.resolve('@subrouter/opencode/package.json')
+    const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version
+    expect(resolveSubrouterPluginSpec({ isDev: false })).toBe(
+      `@subrouter/opencode@${version}`,
+    )
+  })
+
+  test('loads workspace source directly in development', async () => {
+    const { resolveSubrouterPluginSpec } = await import('./opencode.js')
+    expect(resolveSubrouterPluginSpec({ isDev: true })).toMatch(
+      /^file:.*\/subrouter\/opencode\/dist\/index\.js$/,
+    )
+  })
+})
+
+describe('publicOpencodeBindRequiresPassword', () => {
+  test('allows loopback without a password', async () => {
+    const { publicOpencodeBindRequiresPassword } = await import('./opencode.js')
+    expect(publicOpencodeBindRequiresPassword({ hostname: null })).toBe(false)
+    expect(publicOpencodeBindRequiresPassword({ hostname: '127.0.0.1' })).toBe(
+      false,
+    )
+    expect(publicOpencodeBindRequiresPassword({ hostname: 'localhost' })).toBe(
+      false,
+    )
+  })
+
+  test('requires a password for 0.0.0.0', async () => {
+    const { publicOpencodeBindRequiresPassword } = await import('./opencode.js')
+    expect(publicOpencodeBindRequiresPassword({ hostname: '0.0.0.0' })).toBe(
+      true,
+    )
+  })
+})
+
 describe('getSpawnCommandAndArgs', () => {
   test('wraps windows cmd shims through cmd.exe without double-quoting by node', () => {
     expect(