kimaki 0.24.0 → 0.26.0

package/dist/ipc-tools-plugin.js

@@ -56,7 +56,7 @@ const ipcToolsPlugin = async () => {
                     'The user sees a button, clicks it, and gets a file upload dialog. ' +
                     'Returns the local file paths of downloaded files in the project directory. ' +
                     'Use this when you need the user to provide files (images, documents, configs, etc.). ' +
-                    'IMPORTANT: Always call this tool last in your message, after all text parts.',
+                    'You MUST call kimaki_file_upload LAST, after ALL text. NEVER call it before your text.',
                 args: {
                     prompt: z
                         .string()
@@ -115,8 +115,9 @@ const ipcToolsPlugin = async () => {
           Use this when the user can respond by clicking one of up to 3 buttons.
           Prefer a single button whenever possible.
           Default color is white (same visual style as permission deny button).
-          If you need more than 3 options, use the question tool instead.
-          IMPORTANT: Always call this tool last in your message, after all text parts.
+          If you need more than 3 options, use \`question\` instead.
+          You MUST call kimaki_action_buttons LAST, after ALL text.
+          NEVER call kimaki_action_buttons before your text.
 
           Examples:
           - buttons: [{"label":"Yes, proceed"}]

package/dist/kimaki-opencode-plugin.js

@@ -15,6 +15,8 @@ export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { memoryOverviewPlugin } from './memory-overview-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
+export { openaiRotationPlugin } from './openai-auth-plugin.js';
+export { xaiRotationPlugin } from './xai-auth-plugin.js';
 export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
 export { subagentRateLimitPlugin } from './subagent-rate-limit-plugin.js';
 export { cacheDriftPlugin } from './cache-drift-plugin.js';

package/dist/message-formatting.js

@@ -1,10 +1,13 @@
 // OpenCode message part formatting for Discord.
 // Converts SDK message parts (text, tools, reasoning) to Discord-friendly format,
 // handles file attachments, and provides tool summary generation.
+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';
 const logger = createLogger(LogPrefix.FORMATTING);
 /**
  * Serialize Discord embeds into plain text so the AI model can read them.
@@ -210,22 +213,77 @@ export function isTextMimeType(contentType) {
     }
     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) {
+    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) {
+    if (attachment.name === KIMAKI_SEND_PROMPT_ATTACHMENT_NAME)
+        return true;
+    return attachment.size <= TEXT_ATTACHMENT_INLINE_LIMIT_BYTES;
+}
+function textAttachmentAttrs(attachment, extra = []) {
+    return [
+        `filename="${attachment.name}"`,
+        `mime="${attachment.contentType}"`,
+        `size="${attachment.size}"`,
+        `url="${attachment.url}"`,
+        ...extra,
+    ].join(' ');
+}
+function safeAttachmentBasename(name) {
+    const sanitized = path.basename(name).replace(/\0/g, '');
+    if (!sanitized || sanitized === '.' || sanitized === '..')
+        return 'attachment';
+    return sanitized;
+}
+function localAttachmentPath(attachment) {
+    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) {
     const textAttachments = Array.from(message.attachments.values()).filter((attachment) => isTextMimeType(attachment.contentType));
     if (textAttachments.length === 0) {
         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 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 text = await response.text();
-        return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`;
+        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>`;
     }));
     return textContents.join('\n\n');
 }
@@ -419,6 +477,27 @@ export function formatTodoList(part) {
     const content = activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1);
     return `${num} **${escapeInlineMarkdown(content)}**`;
 }
+export function formatTaskToolTitle(part) {
+    if (part.tool !== 'task' || part.state.status === 'pending')
+        return '';
+    const childSessionId = part.state.metadata?.sessionId;
+    if (typeof childSessionId !== 'string' || !childSessionId)
+        return '';
+    const description = part.state.input?.description;
+    const stateTitle = part.state.status === 'running' || part.state.status === 'completed'
+        ? part.state.title
+        : undefined;
+    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, prefix) {
     const pfx = prefix ? `${prefix} ⋅ ` : '';
     if (part.type === 'text') {

package/dist/message-formatting.test.js

@@ -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';
 describe('formatPart', () => {
     test('callout text does not get ⬥ prefix', () => {
         const part = {
@@ -42,6 +45,27 @@ describe('formatPart', () => {
     `);
     });
 });
+describe('formatTaskToolTitle', () => {
+    test('uses the completed task title when OpenAI omits the description', () => {
+        const part = {
+            id: 'prt_task',
+            type: 'tool',
+            tool: 'task',
+            callID: 'call_task',
+            sessionID: 'ses_parent',
+            messageID: 'msg_assistant',
+            state: {
+                status: 'completed',
+                input: { subagent_type: 'general' },
+                output: '',
+                title: 'Classify pending changes',
+                metadata: { sessionId: 'ses_child' },
+                time: { start: 1, end: 2 },
+            },
+        };
+        expect(formatTaskToolTitle(part)).toMatchInlineSnapshot(`"┣ general **Classify pending changes**"`);
+    });
+});
 describe('formatBashToolTitle', () => {
     test('short single-line command shown in full', () => {
         expect(formatBashToolTitle({ command: 'echo hello' })).toMatchInlineSnapshot(`" _echo hello_"`);
@@ -356,3 +380,137 @@ describe('serializeMessageSnapshots', () => {
     `);
     });
 });
+describe('getTextAttachments', () => {
+    const originalFetch = globalThis.fetch;
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    function stubFetch(impl) {
+        const fetchFn = async (input) => impl(String(input));
+        fetchFn.preconnect = () => { };
+        globalThis.fetch = fetchFn;
+    }
+    function messageWithAttachments(attachments) {
+        return {
+            attachments: new Map(attachments.map((attachment) => {
+                return [attachment.id, attachment];
+            })),
+        };
+    }
+    function snapshotAttachments(result) {
+        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/dist/message-preprocessing.js

@@ -10,9 +10,9 @@ import { DiscordOperationError, OpenCodeSdkError } from './errors.js';
 import { resolveMentions, getFileAttachments, getTextAttachments, } from './message-formatting.js';
 import { processVoiceAttachment } from './voice-handler.js';
 import { isVoiceAttachment } from './voice-attachment.js';
-import { buildExternalDirectoryPermissionRules, initializeOpencodeForDirectory, } from './opencode.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
 import { getCompactSessionContext, getLastSessionId } from './markdown.js';
-import { getThreadSession, listTrackedTextChannels } from './database.js';
+import { getThreadSession } from './database.js';
 import * as errore from 'errore';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
@@ -88,23 +88,6 @@ async function getRepliedMessageContext({ message, }) {
         text: repliedText,
     };
 }
-export async function getChannelReferencePermissionRules({ message, }) {
-    const channelIds = [...message.mentions.channels.keys()];
-    if (channelIds.length === 0) {
-        return [];
-    }
-    const mentionedChannelIds = new Set(channelIds);
-    const referencedChannels = (await listTrackedTextChannels()).filter((channel) => {
-        return mentionedChannelIds.has(channel.channel_id);
-    });
-    const resolvedDirectories = new Set(referencedChannels.map((channel) => channel.directory.replaceAll('\\', '/')));
-    return [...resolvedDirectories].flatMap((directory) => {
-        return buildExternalDirectoryPermissionRules({
-            resolvedPattern: directory,
-            action: 'allow',
-        });
-    });
-}
 /**
  * Pre-process a message in an existing thread (thread already has a session or
  * needs a new one). Handles voice transcription, text/file attachments, and
@@ -188,7 +171,6 @@ export async function preprocessExistingThreadMessage({ message, thread, project
         lastSessionContext,
         agents,
     });
-    const permissionRules = await getChannelReferencePermissionRules({ message });
     if (voiceResult) {
         messageContent = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`;
     }
@@ -217,7 +199,6 @@ export async function preprocessExistingThreadMessage({ message, thread, project
         prompt,
         images: fileAttachments.length > 0 ? fileAttachments : undefined,
         repliedMessage,
-        permissionRules,
         mode: qs.forceQueue || voiceResult?.queueMessage ? 'local-queue' : 'opencode',
         agent: voiceResult?.agent,
     };
@@ -243,7 +224,6 @@ export async function preprocessNewSessionMessage({ message, thread, projectDire
     }
     let prompt = resolveMentions(message);
     const repliedMessage = await getRepliedMessageContext({ message });
-    const permissionRules = await getChannelReferencePermissionRules({ message });
     const voiceResult = await processVoiceAttachment({
         message,
         thread,
@@ -293,7 +273,6 @@ export async function preprocessNewSessionMessage({ message, thread, projectDire
         prompt: finalPrompt,
         images: fileAttachments.length > 0 ? fileAttachments : undefined,
         repliedMessage,
-        permissionRules,
         mode: qs.forceQueue || voiceResult?.queueMessage ? 'local-queue' : 'opencode',
         agent: voiceResult?.agent,
     };
@@ -317,7 +296,6 @@ export async function preprocessNewThreadMessage({ message, thread, projectDirec
     }
     let messageContent = resolveMentions(message);
     const repliedMessage = await getRepliedMessageContext({ message });
-    const permissionRules = await getChannelReferencePermissionRules({ message });
     const voiceResult = await processVoiceAttachment({
         message,
         thread,
@@ -353,7 +331,6 @@ export async function preprocessNewThreadMessage({ message, thread, projectDirec
         prompt,
         images: fileAttachments.length > 0 ? fileAttachments : undefined,
         repliedMessage,
-        permissionRules,
         mode: qs.forceQueue || voiceResult?.queueMessage ? 'local-queue' : 'opencode',
         agent: voiceResult?.agent,
     };

package/dist/oauth-rotation-shared.js

@@ -178,12 +178,16 @@ export function shouldRotateAuth(status, bodyText) {
         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') ||
         haystack.includes('usage limit') ||
         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'));
@@ -191,11 +195,13 @@ export function shouldRotateAuth(status, bodyText) {
 export function isRateLimitRetryMessage(message) {
     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'));
 }
 export function isTokenRefreshError(message) {
     const haystack = message.toLowerCase();

package/dist/openai-auth-state.js

@@ -134,6 +134,26 @@ export async function detectAndRememberNewOpenAIAccount() {
         }
         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();