kimaki 0.25.0 → 0.26.0

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/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();

package/dist/schema.js

@@ -164,6 +164,20 @@ export const scheduled_tasks = sqliteCore.sqliteTable('scheduled_tasks', {
     sqliteCore.index('scheduled_tasks_channel_id_status_idx').on(table.channel_id, table.status),
     sqliteCore.index('scheduled_tasks_thread_id_status_idx').on(table.thread_id, table.status),
 ]);
+export const scheduled_task_runs = sqliteCore.sqliteTable('scheduled_task_runs', {
+    id: sqliteCore.integer('id', { mode: 'number' }).primaryKey({ autoIncrement: true }).notNull(),
+    scheduled_task_id: sqliteCore.integer('scheduled_task_id', { mode: 'number' }).notNull().references(() => scheduled_tasks.id, { onDelete: 'cascade', onUpdate: 'cascade' }),
+    status: sqliteCore.text('status', { enum: ['pending', 'running', 'completed', 'skipped', 'failed'] }).notNull().default('pending'),
+    thread_id: sqliteCore.text('thread_id'),
+    session_id: sqliteCore.text('session_id'),
+    project_directory: sqliteCore.text('project_directory'),
+    started_at: datetime('started_at').notNull(),
+    completed_at: datetime('completed_at'),
+    error: sqliteCore.text('error'),
+}, (table) => [
+    sqliteCore.index('scheduled_task_runs_task_status_idx').on(table.scheduled_task_id, table.status),
+    sqliteCore.index('scheduled_task_runs_session_status_idx').on(table.session_id, table.status),
+]);
 export const session_start_sources = sqliteCore.sqliteTable('session_start_sources', {
     session_id: sqliteCore.text('session_id').primaryKey().notNull(),
     schedule_kind: sqliteCore.text('schedule_kind', { enum: ['at', 'cron'] }).notNull(),
@@ -215,6 +229,7 @@ export const relations = defineRelations({
     channel_mention_mode,
     global_models,
     scheduled_tasks,
+    scheduled_task_runs,
     session_start_sources,
     forum_sync_configs,
     ipc_requests,
@@ -278,8 +293,12 @@ export const relations = defineRelations({
     scheduled_tasks: {
         channel: r.one.channel_directories({ from: r.scheduled_tasks.channel_id, to: r.channel_directories.channel_id }),
         thread: r.one.thread_sessions({ from: r.scheduled_tasks.thread_id, to: r.thread_sessions.thread_id }),
+        runs: r.many.scheduled_task_runs(),
         session_start_sources: r.many.session_start_sources(),
     },
+    scheduled_task_runs: {
+        scheduled_task: r.one.scheduled_tasks({ from: r.scheduled_task_runs.scheduled_task_id, to: r.scheduled_tasks.id }),
+    },
     session_start_sources: {
         scheduled_task: r.one.scheduled_tasks({ from: r.session_start_sources.scheduled_task_id, to: r.scheduled_tasks.id }),
     },

package/dist/session-handler/event-stream-state.js

@@ -184,6 +184,153 @@ export function getCurrentTurnStartTime({ events, sessionId, upToIndex, }) {
 function getTokenTotal(tokens) {
     return tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write;
 }
+function emptyTurnTokenUsage() {
+    return {
+        input: 0,
+        output: 0,
+        reasoning: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        total: 0,
+        cost: 0,
+        model: undefined,
+        providerID: undefined,
+        assistantMessageCount: 0,
+        userMessageId: undefined,
+    };
+}
+// Latest billed token snapshot for the current user turn.
+// Sums the last message.updated tokens per assistant message id so streaming
+// updates are not double-counted. Scoped to sessionId so subagent idles
+// report their own usage.
+export function getLatestTurnTokenUsage({ events, sessionId, upToIndex, }) {
+    const latestUserMessage = getLatestUserMessage({
+        events,
+        sessionId,
+        upToIndex,
+    });
+    if (!latestUserMessage) {
+        return emptyTurnTokenUsage();
+    }
+    const end = upToIndex ?? events.length - 1;
+    const latestByMessageId = new Map();
+    for (let i = 0; i <= end; i++) {
+        const entry = events[i];
+        if (!entry) {
+            continue;
+        }
+        const event = entry.event;
+        if (event.type !== 'message.updated') {
+            continue;
+        }
+        const info = event.properties.info;
+        if (info.sessionID !== sessionId || info.role !== 'assistant') {
+            continue;
+        }
+        if (info.parentID !== latestUserMessage.id) {
+            continue;
+        }
+        latestByMessageId.set(info.id, info);
+    }
+    if (latestByMessageId.size === 0) {
+        return {
+            ...emptyTurnTokenUsage(),
+            userMessageId: latestUserMessage?.id,
+        };
+    }
+    const usage = emptyTurnTokenUsage();
+    usage.userMessageId = latestUserMessage.id;
+    usage.assistantMessageCount = latestByMessageId.size;
+    for (const message of latestByMessageId.values()) {
+        if (message.tokens) {
+            usage.input += message.tokens.input;
+            usage.output += message.tokens.output;
+            usage.reasoning += message.tokens.reasoning;
+            usage.cacheRead += message.tokens.cache.read;
+            usage.cacheWrite += message.tokens.cache.write;
+            usage.total += message.tokens.total ?? getTokenTotal(message.tokens);
+        }
+        usage.cost += message.cost;
+        usage.model = message.modelID;
+        usage.providerID = message.providerID;
+    }
+    return usage;
+}
+function findFirstUserMessageIndex({ events, userMessageId, upToIndex, }) {
+    for (let i = 0; i <= upToIndex; i++) {
+        const event = events[i]?.event;
+        if (event?.type !== 'message.updated') {
+            continue;
+        }
+        if (event.properties.info.id === userMessageId) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function findPreviousIdleIndexInTurn({ events, sessionId, firstUserMessageIndex, beforeIndex, }) {
+    for (let i = beforeIndex - 1; i > firstUserMessageIndex; i--) {
+        const event = events[i]?.event;
+        if (event?.type === 'session.idle' && event.properties.sessionID === sessionId) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function subtractTokenUsage({ current, previous, }) {
+    return {
+        input: current.input - previous.input,
+        output: current.output - previous.output,
+        reasoning: current.reasoning - previous.reasoning,
+        cacheRead: current.cacheRead - previous.cacheRead,
+        cacheWrite: current.cacheWrite - previous.cacheWrite,
+        total: current.total - previous.total,
+        cost: current.cost - previous.cost,
+        model: current.model,
+        providerID: current.providerID,
+        assistantMessageCount: current.assistantMessageCount,
+        userMessageId: current.userMessageId,
+    };
+}
+// Tokens billed since the previous session.idle in this user turn.
+// Survives process restart because both idles stay in the event buffer.
+export function getIdleTokenUsageDelta({ events, sessionId, idleEventIndex, }) {
+    const current = getLatestTurnTokenUsage({
+        events,
+        sessionId,
+        upToIndex: idleEventIndex,
+    });
+    if (!current.userMessageId) {
+        return undefined;
+    }
+    const firstUserMessageIndex = findFirstUserMessageIndex({
+        events,
+        userMessageId: current.userMessageId,
+        upToIndex: idleEventIndex,
+    });
+    if (firstUserMessageIndex === undefined) {
+        return undefined;
+    }
+    const previousIdleIndex = findPreviousIdleIndexInTurn({
+        events,
+        sessionId,
+        firstUserMessageIndex,
+        beforeIndex: idleEventIndex,
+    });
+    if (previousIdleIndex === undefined) {
+        return current.total > 0 ? current : undefined;
+    }
+    const previous = getLatestTurnTokenUsage({
+        events,
+        sessionId,
+        upToIndex: previousIdleIndex,
+    });
+    const delta = subtractTokenUsage({ current, previous });
+    if (delta.total <= 0) {
+        return undefined;
+    }
+    return delta;
+}
 // Scans backward for most recent message.updated with role=assistant for sessionId.
 // Extracts model, providerID, agent, tokensUsed.
 export function getLatestRunInfo({ events, sessionId, upToIndex, }) {