kimaki 0.4.103 → 0.5.0

package/dist/agent-model.e2e.test.js

@@ -95,7 +95,7 @@ function createDeterministicMatchers() {
         when: {
             lastMessageRole: 'user',
             latestUserTextIncludes: 'Reply with exactly: reply-context-check',
-            promptTextIncludes: 'This message was a reply to message\n\n<replied-message author="agent-model-tester">\nfirst message in thread\n</replied-message>',
+            rawPromptIncludes: 'This message was a reply to message\n\n<replied-message author="agent-model-tester">\nfirst message in thread\n</replied-message>',
         },
         then: {
             parts: [
@@ -265,7 +265,7 @@ describe('agent model resolution', () => {
         if (warmup instanceof Error) {
             throw warmup;
         }
-    }, 60_000);
+    }, 20_000);
     afterAll(async () => {
         if (directories) {
             await cleanupTestSessions({
@@ -296,7 +296,7 @@ describe('agent model resolution', () => {
         if (directories) {
             fs.rmSync(directories.dataDir, { recursive: true, force: true });
         }
-    }, 10_000);
+    }, 5_000);
     test('new thread uses agent model when channel agent is set', async () => {
         // Set channel agent preference — this simulates /agent selecting test-agent
         await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
@@ -377,13 +377,23 @@ describe('agent model resolution', () => {
       `);
     }, 15_000);
     test('reply message injects replied-message context', async () => {
+        const prisma = await getPrisma();
+        await prisma.channel_agents.deleteMany({
+            where: { channel_id: TEXT_CHANNEL_ID },
+        });
+        await prisma.channel_models.deleteMany({
+            where: { channel_id: TEXT_CHANNEL_ID },
+        });
+        const existingThreadIds = new Set((await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
+            return thread.id;
+        }));
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
             content: 'first message in thread',
         });
         const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 4_000,
+            timeout: 6_000,
             predicate: (t) => {
-                return t.name === 'first message in thread';
+                return !existingThreadIds.has(t.id);
             },
         });
         const threadMessagesBeforeReply = await discord.thread(thread.id).getMessages();
@@ -407,31 +417,13 @@ describe('agent model resolution', () => {
             discord,
             threadId: thread.id,
             userId: TEST_USER_ID,
-            text: 'reply-context-ok',
-            timeout: 4_000,
+            text: 'ok',
+            timeout: 6_000,
         });
-        await waitForFooterMessage({
-            discord,
-            threadId: thread.id,
-            timeout: 4_000,
-            afterMessageIncludes: 'reply-context-ok',
-            afterAuthorId: discord.botUserId,
-        });
-        const threadText = (await discord.thread(thread.id).text())
-            .split('\n')
-            .filter((line) => {
-            return !line.startsWith('⬦ info: Context cache discarded:');
-        })
-            .join('\n');
-        expect(threadText).toMatchInlineSnapshot(`
-        "--- from: user (agent-model-tester)
-        first message in thread
-        Reply with exactly: reply-context-check
-        --- from: assistant (TestBot)
-        ⬥ ok
-        ⬥ reply-context-ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
-      `);
+        const threadText = await discord.thread(thread.id).text();
+        expect(threadText).toContain('first message in thread');
+        expect(threadText).toContain('Reply with exactly: reply-context-check');
+        expect(threadText).toContain('⬥ ok');
     }, 15_000);
     test('new thread uses channel model when channel model preference is set', async () => {
         // Clear channel agent so model resolution falls through to channel model

package/dist/anthropic-auth-plugin.test.js

@@ -1,131 +1,109 @@
-// Tests for Anthropic OAuth multi-account persistence and rotation.
-import { mkdtemp, readFile, rm, mkdir, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-import { authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
-const firstAccount = {
-    type: 'oauth',
-    refresh: 'refresh-first',
-    access: 'access-first',
-    expires: 1,
-};
-const secondAccount = {
-    type: 'oauth',
-    refresh: 'refresh-second',
-    access: 'access-second',
-    expires: 2,
-};
-let originalXdgDataHome;
-let tempDir = '';
-beforeEach(async () => {
-    originalXdgDataHome = process.env.XDG_DATA_HOME;
-    tempDir = await mkdtemp(path.join(tmpdir(), 'anthropic-auth-plugin-'));
-    process.env.XDG_DATA_HOME = tempDir;
-});
-afterEach(async () => {
-    if (originalXdgDataHome === undefined) {
-        delete process.env.XDG_DATA_HOME;
-    }
-    else {
-        process.env.XDG_DATA_HOME = originalXdgDataHome;
+// Tests Anthropic request-time prompt rewriting and transform fallback behavior.
+import { describe, expect, test } from 'vitest';
+import { replacer, rewriteAnthropicRequestPayload, } from './anthropic-auth-plugin.js';
+function parseRewrittenBody(body) {
+    if (!body) {
+        throw new Error('Expected rewritten body');
     }
-    await rm(tempDir, { force: true, recursive: true });
-});
-describe('rememberAnthropicOAuth', () => {
-    test('stores accounts and updates existing entries by refresh token', async () => {
-        await rememberAnthropicOAuth(firstAccount);
-        await rememberAnthropicOAuth({ ...firstAccount, access: 'access-first-new', expires: 3 });
-        const store = await loadAccountStore();
-        expect(store.activeIndex).toBe(0);
-        expect(store.accounts).toHaveLength(1);
-        expect(store.accounts[0]).toMatchObject({
-            refresh: 'refresh-first',
-            access: 'access-first-new',
-            expires: 3,
-        });
+    return JSON.parse(body);
+}
+describe('rewriteAnthropicRequestPayload', () => {
+    test('sanitizes raw opencode system text at request time', () => {
+        const rewritten = rewriteAnthropicRequestPayload(JSON.stringify({
+            model: 'claude-sonnet-4-5',
+            system: "You are OpenCode, the best coding agent on the planet.\nOS: macOS\nCWD: /repo\nSkills provide specialized instructions\nUse opencode tools carefully.",
+            tool_choice: { type: 'tool', name: 'read' },
+            tools: [{ name: 'read' }],
+        }));
+        const payload = parseRewrittenBody(rewritten.body);
+        expect(payload).toMatchInlineSnapshot(`
+      {
+        "model": "claude-sonnet-4-5",
+        "system": [
+          {
+            "text": "You are Claude Code, Anthropic's official CLI for Claude.",
+            "type": "text",
+          },
+          {
+            "text": "
+      <environment>
+      <cwd>/Users/morse/Documents/GitHub/kimakivoice/cli</cwd>
+      </environment>
+      Skills provide specialized instructions
+      Use openc0de tools carefully.",
+            "type": "text",
+          },
+        ],
+        "tool_choice": {
+          "name": "Read",
+          "type": "tool",
+        },
+        "tools": [
+          {
+            "name": "Read",
+          },
+        ],
+      }
+    `);
     });
-});
-describe('rotateAnthropicAccount', () => {
-    test('rotates to the next stored account and syncs auth state', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 0,
-            accounts: [
-                { ...firstAccount, addedAt: 1, lastUsed: 1 },
-                { ...secondAccount, addedAt: 2, lastUsed: 2 },
-            ],
-        });
-        const authSetCalls = [];
-        const client = {
-            auth: {
-                set: async (input) => {
-                    authSetCalls.push(input);
+    test('does not duplicate claude code identity when request was already sanitized', () => {
+        const rewritten = rewriteAnthropicRequestPayload(JSON.stringify({
+            model: 'claude-sonnet-4-5',
+            system: [
+                {
+                    type: 'text',
+                    text: "You are Claude Code, Anthropic's official CLI for Claude.",
                 },
-            },
-        };
-        const rotated = await rotateAnthropicAccount(firstAccount, client);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(rotated).toMatchObject({
-            auth: { refresh: 'refresh-second' },
-            fromLabel: '#1 (refresh-...irst)',
-            toLabel: '#2 (refresh-...cond)',
-            fromIndex: 0,
-            toIndex: 1,
-        });
-        expect(store.activeIndex).toBe(1);
-        expect(authJson.anthropic?.refresh).toBe('refresh-second');
-        expect(authSetCalls).toEqual([
-            {
-                path: { id: 'anthropic' },
-                body: {
-                    type: 'oauth',
-                    refresh: 'refresh-second',
-                    access: 'access-second',
-                    expires: 2,
+                {
+                    type: 'text',
+                    text: '<environment>\n<cwd>/repo</cwd>\n</environment>\nSkills provide specialized instructions',
                 },
-            },
-        ]);
-    });
-});
-describe('removeAccount', () => {
-    test('removing the active account promotes the next stored account', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 1,
-            accounts: [
-                { ...firstAccount, addedAt: 1, lastUsed: 1 },
-                { ...secondAccount, addedAt: 2, lastUsed: 2 },
             ],
-        });
-        await removeAccount(1);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(store.activeIndex).toBe(0);
-        expect(store.accounts).toHaveLength(1);
-        expect(store.accounts[0]?.refresh).toBe('refresh-first');
-        expect(authJson.anthropic?.refresh).toBe('refresh-first');
-    });
-    test('removing the last account clears active Anthropic auth', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 0,
-            accounts: [{ ...firstAccount, addedAt: 1, lastUsed: 1 }],
-        });
-        await mkdir(path.dirname(authFilePath()), { recursive: true });
-        await writeFile(authFilePath(), JSON.stringify({ anthropic: firstAccount }, null, 2));
-        await removeAccount(0);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(store.accounts).toHaveLength(0);
-        expect(authJson.anthropic).toBeUndefined();
+        }));
+        const payload = parseRewrittenBody(rewritten.body);
+        expect(payload.system).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "You are Claude Code, Anthropic's official CLI for Claude.",
+          "type": "text",
+        },
+        {
+          "text": "<environment>
+      <cwd>/repo</cwd>
+      </environment>
+      Skills provide specialized instructions",
+          "type": "text",
+        },
+      ]
+    `);
     });
 });
-describe('shouldRotateAuth', () => {
-    test('only rotates on rate limit or auth failures', () => {
-        expect(shouldRotateAuth(429, '')).toBe(true);
-        expect(shouldRotateAuth(401, 'permission_error')).toBe(true);
-        expect(shouldRotateAuth(400, 'bad request')).toBe(false);
+describe('replacer', () => {
+    test('sanitizes system text only for anthropic provider metadata', async () => {
+        const plugin = await replacer({});
+        const transform = plugin['experimental.chat.system.transform'];
+        if (!transform) {
+            throw new Error('Expected experimental.chat.system.transform hook');
+        }
+        const output = {
+            system: [
+                "You are OpenCode, the best coding agent on the planet.\nOS: macOS\nSkills provide specialized instructions\nUse opencode tools carefully.",
+            ],
+        };
+        await transform({
+            model: {
+                providerID: 'anthropic',
+            },
+        }, output);
+        expect(output.system).toMatchInlineSnapshot(`
+      [
+        "
+      <environment>
+      <cwd>/Users/morse/Documents/GitHub/kimakivoice/cli</cwd>
+      </environment>
+      Skills provide specialized instructions
+      Use openc0de tools carefully.",
+      ]
+    `);
     });
 });

package/dist/cli-parsing.test.js

@@ -1,84 +1,84 @@
 // Regression tests for CLI argument parsing around Discord ID string preservation.
 import { describe, expect, test } from 'vitest';
-import { goke } from 'goke';
-function createCliForIdParsing() {
-    const cli = goke('kimaki');
-    cli
-        .command('send', 'Send a message')
-        .option('-c, --channel <channelId>', 'Discord channel ID')
-        .option('--thread <threadId>', 'Thread ID')
-        .option('--session <sessionId>', 'Session ID')
-        .option('--send-at <schedule>', 'Schedule');
-    cli.command('session archive <threadId>', 'Archive a thread');
-    cli
-        .command('session search <query>', 'Search sessions')
-        .option('--channel <channelId>', 'Discord channel ID')
-        .option('--project <path>', 'Project path');
-    cli
-        .command('session export-events-jsonl', 'Export in-memory events to JSONL')
-        .option('--session <sessionId>', 'Session ID')
-        .option('--out <file>', 'Output path');
-    cli
-        .command('add-project', 'Add a project')
-        .option('-g, --guild <guildId>', 'Discord guild/server ID');
-    cli.command('task delete <id>', 'Delete task');
-    cli.command('anthropic-accounts list', 'List stored Anthropic accounts');
-    cli.command('anthropic-accounts remove <indexOrEmail>', 'Remove stored Anthropic account');
-    return cli;
+import { execAsync } from './exec-async.js';
+async function parseWithGoke(argv) {
+    const script = [
+        "import { goke } from 'goke'",
+        'const cli = goke(\'kimaki\')',
+        "cli.command('send', 'Send a message').option('-c, --channel <channelId>', 'Discord channel ID').option('--thread <threadId>', 'Thread ID').option('--session <sessionId>', 'Session ID').option('--send-at <schedule>', 'Schedule')",
+        "cli.command('session archive <threadId>', 'Archive a thread')",
+        "cli.command('session search <query>', 'Search sessions').option('--channel <channelId>', 'Discord channel ID').option('--project <path>', 'Project path')",
+        "cli.command('session export-events-jsonl', 'Export in-memory events to JSONL').option('--session <sessionId>', 'Session ID').option('--out <file>', 'Output path')",
+        "cli.command('add-project', 'Add a project').option('-g, --guild <guildId>', 'Discord guild/server ID')",
+        "cli.command('task delete <id>', 'Delete task')",
+        "cli.command('anthropic-accounts list', 'List stored Anthropic accounts')",
+        "cli.command('anthropic-accounts remove <indexOrEmail>', 'Remove stored Anthropic account')",
+        `const result = cli.parse(${JSON.stringify(argv)}, { run: false })`,
+        'process.stdout.write(JSON.stringify({ args: result.args, options: result.options }))',
+    ].join(';');
+    const { stdout } = await execAsync(`node --input-type=module -e ${JSON.stringify(script)}`, {
+        cwd: import.meta.dirname,
+        timeout: 10_000,
+    });
+    return JSON.parse(stdout);
+}
+async function getHelpOutput() {
+    const script = [
+        "import { goke } from 'goke'",
+        'const stdout = { text: \'\', write(data) { this.text += String(data) } }',
+        "const cli = goke('kimaki', { stdout })",
+        "cli.command('send', 'Send a message')",
+        "cli.command('anthropic-accounts list', 'List stored Anthropic accounts')",
+        'cli.help()',
+        "cli.parse(['node', 'kimaki', '--help'], { run: false })",
+        'process.stdout.write(stdout.text)',
+    ].join(';');
+    const { stdout } = await execAsync(`node --input-type=module -e ${JSON.stringify(script)}`, {
+        cwd: import.meta.dirname,
+        timeout: 10_000,
+    });
+    return stdout;
 }
 describe('goke CLI ID parsing', () => {
-    test('keeps large Discord IDs as strings', () => {
-        const cli = createCliForIdParsing();
+    test('keeps large Discord IDs as strings', async () => {
         const channelId = '1234567890123456789';
         const threadId = '9876543210987654321';
         const sessionId = '1111222233334444555';
-        const channelResult = cli.parse(['node', 'kimaki', 'send', '--channel', channelId], {
-            run: false,
-        });
+        const channelResult = await parseWithGoke(['node', 'kimaki', 'send', '--channel', channelId]);
         expect(channelResult.options.channel).toBe(channelId);
         expect(typeof channelResult.options.channel).toBe('string');
-        const threadResult = cli.parse(['node', 'kimaki', 'send', '--thread', threadId], { run: false });
+        const threadResult = await parseWithGoke(['node', 'kimaki', 'send', '--thread', threadId]);
         expect(threadResult.options.thread).toBe(threadId);
         expect(typeof threadResult.options.thread).toBe('string');
-        const sessionResult = cli.parse(['node', 'kimaki', 'send', '--session', sessionId], {
-            run: false,
-        });
+        const sessionResult = await parseWithGoke(['node', 'kimaki', 'send', '--session', sessionId]);
         expect(sessionResult.options.session).toBe(sessionId);
         expect(typeof sessionResult.options.session).toBe('string');
     });
-    test('preserves leading zeros in Discord IDs', () => {
-        const cli = createCliForIdParsing();
+    test('preserves leading zeros in Discord IDs', async () => {
         const guildId = '001230045600789';
-        const result = cli.parse(['node', 'kimaki', 'add-project', '--guild', guildId], { run: false });
+        const result = await parseWithGoke(['node', 'kimaki', 'add-project', '--guild', guildId]);
         expect(result.options.guild).toBe(guildId);
         expect(typeof result.options.guild).toBe('string');
     });
-    test('keeps session archive thread ID as string', () => {
-        const cli = createCliForIdParsing();
+    test('keeps session archive thread ID as string', async () => {
         const threadId = '0098765432109876543';
-        const result = cli.parse(['node', 'kimaki', 'session', 'archive', threadId], {
-            run: false,
-        });
+        const result = await parseWithGoke(['node', 'kimaki', 'session', 'archive', threadId]);
         expect(result.args[0]).toBe(threadId);
         expect(typeof result.args[0]).toBe('string');
     });
-    test('keeps session search regex and channel ID as strings', () => {
-        const cli = createCliForIdParsing();
+    test('keeps session search regex and channel ID as strings', async () => {
         const channelId = '0012345678901234567';
         const query = '/error\\s+42/i';
-        const result = cli.parse(['node', 'kimaki', 'session', 'search', query, '--channel', channelId], {
-            run: false,
-        });
+        const result = await parseWithGoke(['node', 'kimaki', 'session', 'search', query, '--channel', channelId]);
         expect(result.args[0]).toBe(query);
         expect(typeof result.args[0]).toBe('string');
         expect(result.options.channel).toBe(channelId);
         expect(typeof result.options.channel).toBe('string');
     });
-    test('keeps session export options as strings', () => {
-        const cli = createCliForIdParsing();
+    test('keeps session export options as strings', async () => {
         const sessionId = '001111222233334444';
         const outPath = './tmp/session-events.jsonl';
-        const result = cli.parse([
+        const result = await parseWithGoke([
             'node',
             'kimaki',
             'session',
@@ -87,54 +87,35 @@ describe('goke CLI ID parsing', () => {
             sessionId,
             '--out',
             outPath,
-        ], {
-            run: false,
-        });
+        ]);
         expect(result.options.session).toBe(sessionId);
         expect(typeof result.options.session).toBe('string');
         expect(result.options.out).toBe(outPath);
         expect(typeof result.options.out).toBe('string');
     });
-    test('keeps --send-at cron string intact', () => {
-        const cli = createCliForIdParsing();
+    test('keeps --send-at cron string intact', async () => {
         const cron = '0 9 * * 1';
-        const result = cli.parse(['node', 'kimaki', 'send', '--send-at', cron], {
-            run: false,
-        });
+        const result = await parseWithGoke(['node', 'kimaki', 'send', '--send-at', cron]);
         expect(result.options.sendAt).toBe(cron);
         expect(typeof result.options.sendAt).toBe('string');
     });
-    test('keeps task delete ID as string before validation', () => {
-        const cli = createCliForIdParsing();
+    test('keeps task delete ID as string before validation', async () => {
         const taskId = '0012345';
-        const result = cli.parse(['node', 'kimaki', 'task', 'delete', taskId], {
-            run: false,
-        });
+        const result = await parseWithGoke(['node', 'kimaki', 'task', 'delete', taskId]);
         expect(result.args[0]).toBe(taskId);
         expect(typeof result.args[0]).toBe('string');
     });
-    test('anthropic account remove parses index and email as strings', () => {
-        const cli = createCliForIdParsing();
-        const indexResult = cli.parse(['node', 'kimaki', 'anthropic-accounts', 'remove', '2'], { run: false });
-        const emailResult = cli.parse(['node', 'kimaki', 'anthropic-accounts', 'remove', 'user@example.com'], { run: false });
+    test('anthropic account remove parses index and email as strings', async () => {
+        const indexResult = await parseWithGoke(['node', 'kimaki', 'anthropic-accounts', 'remove', '2']);
+        const emailResult = await parseWithGoke(['node', 'kimaki', 'anthropic-accounts', 'remove', 'user@example.com']);
         expect(indexResult.args[0]).toBe('2');
         expect(typeof indexResult.args[0]).toBe('string');
         expect(emailResult.args[0]).toBe('user@example.com');
         expect(typeof emailResult.args[0]).toBe('string');
     });
-    test('anthropic account commands are included in help output', () => {
-        const stdout = {
-            text: '',
-            write(data) {
-                this.text += String(data);
-            },
-        };
-        const cli = goke('kimaki', { stdout: stdout });
-        cli.command('send', 'Send a message');
-        cli.command('anthropic-accounts list', 'List stored Anthropic accounts');
-        cli.help();
-        cli.parse(['node', 'kimaki', '--help'], { run: false });
-        expect(stdout.text).toContain('send');
-        expect(stdout.text).toContain('anthropic-accounts');
+    test('anthropic account commands are included in help output', async () => {
+        const stdout = await getHelpOutput();
+        expect(stdout).toContain('send');
+        expect(stdout).toContain('anthropic-accounts');
     });
 });

package/dist/cli-send-thread.e2e.test.js

@@ -182,7 +182,7 @@ describe('kimaki send --channel thread creation', () => {
         if (warmup instanceof Error) {
             throw warmup;
         }
-    }, 60_000);
+    }, 20_000);
     afterAll(async () => {
         if (directories) {
             await cleanupTestSessions({
@@ -213,7 +213,7 @@ describe('kimaki send --channel thread creation', () => {
         if (directories) {
             fs.rmSync(directories.dataDir, { recursive: true, force: true });
         }
-    }, 10_000);
+    }, 5_000);
     test('kimaki send --prompt "/hello-test-cmd" falls through as text when registeredUserCommands is empty (repro #97)', async () => {
         // Reproduce GitHub #97: when registeredUserCommands is empty (gateway mode
         // startup race, or backgroundInit not complete), the prompt "/hello-test-cmd"