kimaki 0.4.24 → 0.4.26

package/bin.js

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+
+// CLI entrypoint with automatic restart capability.
+// Spawns the main CLI and restarts it on non-zero exit codes with throttling.
+// Exit codes 0, 130 (SIGINT), 143 (SIGTERM), or 64 (EXIT_NO_RESTART) terminate cleanly.
+
 import { spawn } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
@@ -62,4 +67,4 @@ async function run() {
 run().catch(err => {
   console.error('Fatal error:', err)
   process.exit(1)
-})
+})

package/dist/acp-client.test.js

@@ -0,0 +1,149 @@
+// ACP client integration test for the OpenCode ACP server.
+import { afterAll, beforeAll, expect, test } from 'vitest';
+import { spawn } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+import { ClientSideConnection, PROTOCOL_VERSION, ndJsonStream, } from '@agentclientprotocol/sdk';
+const UPDATE_TIMEOUT_MS = 5000;
+class TestClient {
+    updates = [];
+    listeners = [];
+    async requestPermission(params) {
+        const firstOption = params.options[0];
+        if (!firstOption) {
+            return { outcome: { outcome: 'cancelled' } };
+        }
+        return {
+            outcome: {
+                outcome: 'selected',
+                optionId: firstOption.optionId,
+            },
+        };
+    }
+    async sessionUpdate(params) {
+        this.updates.push(params);
+        const matching = this.listeners.filter((listener) => {
+            return listener.predicate(params);
+        });
+        this.listeners = this.listeners.filter((listener) => {
+            return !matching.includes(listener);
+        });
+        matching.forEach((listener) => {
+            clearTimeout(listener.timeout);
+            listener.resolve(params);
+        });
+    }
+    resetUpdates() {
+        this.updates = [];
+    }
+    waitForUpdate({ predicate, timeoutMs = UPDATE_TIMEOUT_MS, }) {
+        const existing = this.updates.find((update) => {
+            return predicate(update);
+        });
+        if (existing) {
+            return Promise.resolve(existing);
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.listeners = this.listeners.filter((listener) => {
+                    return listener.resolve !== resolve;
+                });
+                reject(new Error('Timed out waiting for session update'));
+            }, timeoutMs);
+            const listener = {
+                predicate,
+                resolve,
+                reject,
+                timeout,
+            };
+            this.listeners = [...this.listeners, listener];
+        });
+    }
+}
+let serverProcess = null;
+let connection = null;
+let client = null;
+let initResult = null;
+let sessionId = null;
+beforeAll(async () => {
+    serverProcess = spawn('opencode', ['acp', '--port', '0', '--cwd', process.cwd()], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (!serverProcess.stdin || !serverProcess.stdout) {
+        throw new Error('Failed to open ACP stdio streams');
+    }
+    const input = Writable.toWeb(serverProcess.stdin);
+    const output = Readable.toWeb(serverProcess.stdout);
+    const localClient = new TestClient();
+    client = localClient;
+    const stream = ndJsonStream(input, output);
+    connection = new ClientSideConnection(() => localClient, stream);
+    initResult = await connection.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientCapabilities: {
+            fs: {
+                readTextFile: false,
+                writeTextFile: false,
+            },
+            terminal: false,
+        },
+    });
+}, 30000);
+afterAll(async () => {
+    if (serverProcess) {
+        serverProcess.kill('SIGTERM');
+        await new Promise((resolve) => {
+            setTimeout(resolve, 500);
+        });
+        if (!serverProcess.killed) {
+            serverProcess.kill('SIGKILL');
+        }
+    }
+});
+test('creates a session and receives prompt events', async () => {
+    if (!connection || !client) {
+        throw new Error('ACP connection not initialized');
+    }
+    const sessionResponse = await connection.newSession({
+        cwd: process.cwd(),
+        mcpServers: [],
+    });
+    sessionId = sessionResponse.sessionId;
+    const promptResponse = await connection.prompt({
+        sessionId,
+        prompt: [{ type: 'text', text: 'Hello from ACP test.' }],
+    });
+    const update = await client.waitForUpdate({
+        predicate: (notification) => {
+            return (notification.sessionId === sessionId &&
+                notification.update.sessionUpdate === 'agent_message_chunk');
+        },
+    });
+    expect(promptResponse.stopReason).toBeTruthy();
+    expect(update.update.sessionUpdate).toBe('agent_message_chunk');
+}, 30000);
+test('loads an existing session and streams history', async () => {
+    if (!connection || !client) {
+        throw new Error('ACP connection not initialized');
+    }
+    if (!initResult?.agentCapabilities?.loadSession) {
+        expect(true).toBe(true);
+        return;
+    }
+    if (!sessionId) {
+        throw new Error('Missing session ID from previous test');
+    }
+    client.resetUpdates();
+    const loadPromise = connection.loadSession({
+        sessionId,
+        cwd: process.cwd(),
+        mcpServers: [],
+    });
+    const update = await client.waitForUpdate({
+        predicate: (notification) => {
+            return (notification.sessionId === sessionId &&
+                notification.update.sessionUpdate === 'user_message_chunk');
+        },
+    });
+    await loadPromise;
+    expect(update.update.sessionUpdate).toBe('user_message_chunk');
+}, 30000);

package/dist/ai-tool-to-genai.js

@@ -1,3 +1,6 @@
+// AI SDK to Google GenAI tool converter.
+// Transforms Vercel AI SDK tool definitions into Google GenAI CallableTool format
+// for use with Gemini's function calling in the voice assistant.
 import { Type } from '@google/genai';
 import { z, toJSONSchema } from 'zod';
 /**

package/dist/channel-management.js

@@ -1,45 +1,50 @@
+// Discord channel and category management.
+// Creates and manages Kimaki project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
 import { ChannelType, } from 'discord.js';
 import path from 'node:path';
 import { getDatabase } from './database.js';
 import { extractTagsArrays } from './xml.js';
-export async function ensureKimakiCategory(guild) {
+export async function ensureKimakiCategory(guild, botName) {
+    const categoryName = botName ? `Kimaki ${botName}` : 'Kimaki';
     const existingCategory = guild.channels.cache.find((channel) => {
         if (channel.type !== ChannelType.GuildCategory) {
             return false;
         }
-        return channel.name.toLowerCase() === 'kimaki';
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
     });
     if (existingCategory) {
         return existingCategory;
     }
     return guild.channels.create({
-        name: 'Kimaki',
+        name: categoryName,
         type: ChannelType.GuildCategory,
     });
 }
-export async function ensureKimakiAudioCategory(guild) {
+export async function ensureKimakiAudioCategory(guild, botName) {
+    const categoryName = botName ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
     const existingCategory = guild.channels.cache.find((channel) => {
         if (channel.type !== ChannelType.GuildCategory) {
             return false;
         }
-        return channel.name.toLowerCase() === 'kimaki audio';
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
     });
     if (existingCategory) {
         return existingCategory;
     }
     return guild.channels.create({
-        name: 'Kimaki Audio',
+        name: categoryName,
         type: ChannelType.GuildCategory,
     });
 }
-export async function createProjectChannels({ guild, projectDirectory, appId, }) {
+export async function createProjectChannels({ guild, projectDirectory, appId, botName, }) {
     const baseName = path.basename(projectDirectory);
     const channelName = `${baseName}`
         .toLowerCase()
         .replace(/[^a-z0-9-]/g, '-')
         .slice(0, 100);
-    const kimakiCategory = await ensureKimakiCategory(guild);
-    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild);
+    const kimakiCategory = await ensureKimakiCategory(guild, botName);
+    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
     const textChannel = await guild.channels.create({
         name: channelName,
         type: ChannelType.GuildText,

package/dist/cli.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+// Main CLI entrypoint for the Kimaki Discord bot.
+// Handles interactive setup, Discord OAuth, slash command registration,
+// project channel creation, and launching the bot with opencode integration.
 import { cac } from 'cac';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl } from './utils.js';
@@ -13,35 +16,91 @@ const cliLogger = createLogger('CLI');
 const cli = cac('kimaki');
 process.title = 'kimaki';
 const LOCK_PORT = 29988;
+async function killProcessOnPort(port) {
+    const isWindows = process.platform === 'win32';
+    const myPid = process.pid;
+    try {
+        if (isWindows) {
+            // Windows: find PID using netstat, then kill
+            const result = spawnSync('cmd', ['/c', `for /f "tokens=5" %a in ('netstat -ano ^| findstr :${port} ^| findstr LISTENING') do @echo %a`], {
+                shell: false,
+                encoding: 'utf-8',
+            });
+            const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p));
+            // Filter out our own PID and take the first (oldest)
+            const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid);
+            if (targetPid) {
+                cliLogger.log(`Killing existing kimaki process (PID: ${targetPid})`);
+                spawnSync('taskkill', ['/F', '/PID', targetPid], { shell: false });
+                return true;
+            }
+        }
+        else {
+            // Unix: use lsof with -sTCP:LISTEN to only find the listening process
+            const result = spawnSync('lsof', ['-i', `:${port}`, '-sTCP:LISTEN', '-t'], {
+                shell: false,
+                encoding: 'utf-8',
+            });
+            const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p));
+            // Filter out our own PID and take the first (oldest)
+            const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid);
+            if (targetPid) {
+                const pid = parseInt(targetPid, 10);
+                cliLogger.log(`Stopping existing kimaki process (PID: ${pid})`);
+                process.kill(pid, 'SIGKILL');
+                return true;
+            }
+        }
+    }
+    catch (e) {
+        cliLogger.debug(`Failed to kill process on port ${port}:`, e);
+    }
+    return false;
+}
 async function checkSingleInstance() {
     try {
         const response = await fetch(`http://127.0.0.1:${LOCK_PORT}`, {
             signal: AbortSignal.timeout(1000),
         });
         if (response.ok) {
-            cliLogger.error('Another kimaki instance is already running');
-            process.exit(1);
+            cliLogger.log('Another kimaki instance detected');
+            await killProcessOnPort(LOCK_PORT);
+            // Wait a moment for port to be released
+            await new Promise((resolve) => { setTimeout(resolve, 500); });
         }
     }
     catch {
-        // Connection refused means no instance running, continue
+        cliLogger.debug('No other kimaki instance detected on lock port');
     }
 }
-function startLockServer() {
-    const server = http.createServer((req, res) => {
-        res.writeHead(200);
-        res.end('kimaki');
-    });
-    server.listen(LOCK_PORT, '127.0.0.1');
-    server.on('error', (err) => {
-        if (err.code === 'EADDRINUSE') {
-            cliLogger.error('Another kimaki instance is already running');
-            process.exit(1);
-        }
+async function startLockServer() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            res.writeHead(200);
+            res.end('kimaki');
+        });
+        server.listen(LOCK_PORT, '127.0.0.1');
+        server.once('listening', () => {
+            resolve();
+        });
+        server.on('error', async (err) => {
+            if (err.code === 'EADDRINUSE') {
+                cliLogger.log('Port still in use, retrying...');
+                await killProcessOnPort(LOCK_PORT);
+                await new Promise((r) => { setTimeout(r, 500); });
+                // Retry once
+                server.listen(LOCK_PORT, '127.0.0.1');
+            }
+            else {
+                reject(err);
+            }
+        });
     });
 }
 const EXIT_NO_RESTART = 64;
-async function registerCommands(token, appId) {
+// Commands to skip when registering user commands (reserved names)
+const SKIP_USER_COMMANDS = ['init'];
+async function registerCommands(token, appId, userCommands = []) {
     const commands = [
         new SlashCommandBuilder()
             .setName('resume')
@@ -113,6 +172,10 @@ async function registerCommands(token, appId) {
             .setName('abort')
             .setDescription('Abort the current OpenCode request in this thread')
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('stop')
+            .setDescription('Abort the current OpenCode request in this thread')
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('share')
             .setDescription('Share the current session as a public URL')
@@ -125,7 +188,53 @@ async function registerCommands(token, appId) {
             .setName('model')
             .setDescription('Set the preferred model for this channel or session')
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('agent')
+            .setDescription('Set the preferred agent for this channel or session')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('queue')
+            .setDescription('Queue a message to be sent after the current response finishes')
+            .addStringOption((option) => {
+            option
+                .setName('message')
+                .setDescription('The message to queue')
+                .setRequired(true);
+            return option;
+        })
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('clear-queue')
+            .setDescription('Clear all queued messages in this thread')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('undo')
+            .setDescription('Undo the last assistant message (revert file changes)')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('redo')
+            .setDescription('Redo previously undone changes')
+            .toJSON(),
     ];
+    // Add user-defined commands with -cmd suffix
+    for (const cmd of userCommands) {
+        if (SKIP_USER_COMMANDS.includes(cmd.name)) {
+            continue;
+        }
+        const commandName = `${cmd.name}-cmd`;
+        const description = cmd.description || `Run /${cmd.name} command`;
+        commands.push(new SlashCommandBuilder()
+            .setName(commandName)
+            .setDescription(description.slice(0, 100)) // Discord limits to 100 chars
+            .addStringOption((option) => {
+            option
+                .setName('arguments')
+                .setDescription('Arguments to pass to the command')
+                .setRequired(false);
+            return option;
+        })
+            .toJSON());
+    }
     const rest = new REST().setToken(token);
     try {
         const data = (await rest.put(Routes.applicationCommands(appId), {
@@ -414,6 +523,7 @@ async function run({ restart, addChannels }) {
                         guild: targetGuild,
                         projectDirectory: project.worktree,
                         appId,
+                        botName: discordClient.user?.username,
                     });
                     createdChannels.push({
                         name: channelName,
@@ -431,8 +541,29 @@ async function run({ restart, addChannels }) {
             }
         }
     }
+    // Fetch user-defined commands using the already-running server
+    const allUserCommands = [];
+    try {
+        const commandsResponse = await getClient().command.list({
+            query: { directory: currentDir },
+        });
+        if (commandsResponse.data) {
+            allUserCommands.push(...commandsResponse.data);
+        }
+    }
+    catch {
+        // Ignore errors fetching commands
+    }
+    // Log available user commands
+    const registrableCommands = allUserCommands.filter((cmd) => !SKIP_USER_COMMANDS.includes(cmd.name));
+    if (registrableCommands.length > 0) {
+        const commandList = registrableCommands
+            .map((cmd) => `  /${cmd.name}-cmd - ${cmd.description || 'No description'}`)
+            .join('\n');
+        note(`Found ${registrableCommands.length} user-defined command(s):\n${commandList}`, 'OpenCode Commands');
+    }
     cliLogger.log('Registering slash commands asynchronously...');
-    void registerCommands(token, appId)
+    void registerCommands(token, appId, allUserCommands)
         .then(() => {
         cliLogger.log('Slash commands registered!');
     })
@@ -469,7 +600,7 @@ cli
     .action(async (options) => {
     try {
         await checkSingleInstance();
-        startLockServer();
+        await startLockServer();
         await run({
             restart: options.restart,
             addChannels: options.addChannels,

package/dist/commands/abort.js

@@ -0,0 +1,78 @@
+// /abort command - Abort the current OpenCode request in this thread.
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { abortControllers } from '../session-handler.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('ABORT');
+export async function handleAbortCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = row.session_id;
+    try {
+        const existingController = abortControllers.get(sessionId);
+        if (existingController) {
+            existingController.abort(new Error('User requested abort'));
+            abortControllers.delete(sessionId);
+        }
+        const getClient = await initializeOpencodeForDirectory(directory);
+        await getClient().session.abort({
+            path: { id: sessionId },
+        });
+        await command.reply({
+            content: `🛑 Request **aborted**`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`Session ${sessionId} aborted by user`);
+    }
+    catch (error) {
+        logger.error('[ABORT] Error:', error);
+        await command.reply({
+            content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/add-project.js

@@ -0,0 +1,98 @@
+// /add-project command - Create Discord channels for an existing OpenCode project.
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { createProjectChannels } from '../channel-management.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('ADD-PROJECT');
+export async function handleAddProjectCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const projectId = command.options.getString('project', true);
+    const guild = command.guild;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    try {
+        const currentDir = process.cwd();
+        const getClient = await initializeOpencodeForDirectory(currentDir);
+        const projectsResponse = await getClient().project.list({});
+        if (!projectsResponse.data) {
+            await command.editReply('Failed to fetch projects');
+            return;
+        }
+        const project = projectsResponse.data.find((p) => p.id === projectId);
+        if (!project) {
+            await command.editReply('Project not found');
+            return;
+        }
+        const directory = project.worktree;
+        if (!fs.existsSync(directory)) {
+            await command.editReply(`Directory does not exist: ${directory}`);
+            return;
+        }
+        const db = getDatabase();
+        const existingChannel = db
+            .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+            .get(directory, 'text');
+        if (existingChannel) {
+            await command.editReply(`A channel already exists for this directory: <#${existingChannel.channel_id}>`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+            guild,
+            projectDirectory: directory,
+            appId,
+            botName: command.client.user?.username,
+        });
+        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``);
+        logger.log(`Created channels for project ${channelName} at ${directory}`);
+    }
+    catch (error) {
+        logger.error('[ADD-PROJECT] Error:', error);
+        await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleAddProjectAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    try {
+        const currentDir = process.cwd();
+        const getClient = await initializeOpencodeForDirectory(currentDir);
+        const projectsResponse = await getClient().project.list({});
+        if (!projectsResponse.data) {
+            await interaction.respond([]);
+            return;
+        }
+        const db = getDatabase();
+        const existingDirs = db
+            .prepare('SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?')
+            .all('text');
+        const existingDirSet = new Set(existingDirs.map((row) => row.directory));
+        const availableProjects = projectsResponse.data.filter((project) => !existingDirSet.has(project.worktree));
+        const projects = availableProjects
+            .filter((project) => {
+            const baseName = path.basename(project.worktree);
+            const searchText = `${baseName} ${project.worktree}`.toLowerCase();
+            return searchText.includes(focusedValue.toLowerCase());
+        })
+            .sort((a, b) => {
+            const aTime = a.time.initialized || a.time.created;
+            const bTime = b.time.initialized || b.time.created;
+            return bTime - aTime;
+        })
+            .slice(0, 25)
+            .map((project) => {
+            const name = `${path.basename(project.worktree)} (${project.worktree})`;
+            return {
+                name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+                value: project.id,
+            };
+        });
+        await interaction.respond(projects);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+        await interaction.respond([]);
+    }
+}