kimaki 0.0.3 → 0.1.0

package/dist/cli.js

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+import { cac } from 'cac';
+import { intro, outro, text, password, note, cancel, isCancel, log, multiselect, spinner, } from '@clack/prompts';
+import { generateBotInstallUrl } from './utils.js';
+import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDiscordBot, initializeOpencodeForDirectory, } from './discordBot.js';
+import { Events, ChannelType, REST, Routes, SlashCommandBuilder, } from 'discord.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import { createLogger } from './logger.js';
+const cliLogger = createLogger('CLI');
+const cli = cac('kimaki');
+process.title = 'kimaki';
+const EXIT_NO_RESTART = 64;
+async function registerCommands(token, appId) {
+    const commands = [
+        new SlashCommandBuilder()
+            .setName('resume')
+            .setDescription('Resume an existing OpenCode session')
+            .addStringOption((option) => {
+            option
+                .setName('session')
+                .setDescription('The session to resume')
+                .setRequired(true)
+                .setAutocomplete(true);
+            return option;
+        })
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('session')
+            .setDescription('Start a new OpenCode session')
+            .addStringOption((option) => {
+            option
+                .setName('prompt')
+                .setDescription('Prompt content for the session')
+                .setRequired(true);
+            return option;
+        })
+            .addStringOption((option) => {
+            option
+                .setName('files')
+                .setDescription('Files to mention (comma or space separated; autocomplete)')
+                .setAutocomplete(true)
+                .setMaxLength(6000);
+            return option;
+        })
+            .toJSON(),
+    ];
+    const rest = new REST().setToken(token);
+    try {
+        const data = (await rest.put(Routes.applicationCommands(appId), {
+            body: commands,
+        }));
+        cliLogger.info(`COMMANDS: Successfully registered ${data.length} slash commands`);
+    }
+    catch (error) {
+        cliLogger.error('COMMANDS: Failed to register slash commands: ' + String(error));
+        throw error;
+    }
+}
+async function ensureKimakiCategory(guild) {
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === 'kimaki';
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: 'Kimaki',
+        type: ChannelType.GuildCategory,
+    });
+}
+async function run({ restart, addChannels }) {
+    const forceSetup = Boolean(restart);
+    const shouldAddChannels = Boolean(addChannels);
+    intro('🤖 Discord Bot Setup');
+    const db = getDatabase();
+    let appId;
+    let token;
+    const existingBot = db
+        .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+        .get();
+    if (existingBot && !forceSetup) {
+        appId = existingBot.app_id;
+        token = existingBot.token;
+        note(`Using saved bot credentials:\nApp ID: ${appId}\n\nTo use different credentials, run with --restart`, 'Existing Bot Found');
+        note(`Bot install URL (in case you need to add it to another server):\n${generateBotInstallUrl({ clientId: appId })}`, 'Install URL');
+    }
+    else {
+        if (forceSetup && existingBot) {
+            note('Ignoring saved credentials due to --restart flag', 'Restart Setup');
+        }
+        note('1. Go to https://discord.com/developers/applications\n' +
+            '2. Click "New Application"\n' +
+            '3. Give your application a name\n' +
+            '4. Copy the Application ID from the "General Information" section', 'Step 1: Create Discord Application');
+        const appIdInput = await text({
+            message: 'Enter your Discord Application ID:',
+            placeholder: 'e.g., 1234567890123456789',
+            validate(value) {
+                if (!value)
+                    return 'Application ID is required';
+                if (!/^\d{17,20}$/.test(value))
+                    return 'Invalid Application ID format (should be 17-20 digits)';
+            },
+        });
+        if (isCancel(appIdInput)) {
+            cancel('Setup cancelled');
+            process.exit(0);
+        }
+        appId = appIdInput;
+        note('1. Go to the "Bot" section in the left sidebar\n' +
+            '2. Click "Reset Token" to generate a new bot token\n' +
+            "3. Copy the token (you won't be able to see it again!)", 'Step 2: Get Bot Token');
+        const tokenInput = await password({
+            message: 'Enter your Discord Bot Token (will be hidden):',
+            validate(value) {
+                if (!value)
+                    return 'Bot token is required';
+                if (value.length < 50)
+                    return 'Invalid token format (too short)';
+            },
+        });
+        if (isCancel(tokenInput)) {
+            cancel('Setup cancelled');
+            process.exit(0);
+        }
+        token = tokenInput;
+        db.prepare('INSERT OR REPLACE INTO bot_tokens (app_id, token) VALUES (?, ?)').run(appId, token);
+        note('Token saved to database', 'Credentials Stored');
+        note(`Bot install URL:\n${generateBotInstallUrl({ clientId: appId })}\n\nYou MUST install the bot in your Discord server before continuing.`, 'Step 3: Install Bot to Server');
+        const installed = await text({
+            message: 'Press Enter AFTER you have installed the bot in your server:',
+            placeholder: 'Press Enter to continue',
+            validate() {
+                return undefined;
+            },
+        });
+        if (isCancel(installed)) {
+            cancel('Setup cancelled');
+            process.exit(0);
+        }
+    }
+    const s = spinner();
+    s.start('Creating Discord client and connecting...');
+    const discordClient = await createDiscordClient();
+    const guilds = [];
+    const kimakiChannels = [];
+    const createdChannels = [];
+    try {
+        await new Promise((resolve, reject) => {
+            discordClient.once(Events.ClientReady, async (c) => {
+                guilds.push(...Array.from(c.guilds.cache.values()));
+                for (const guild of guilds) {
+                    const channels = await getChannelsWithDescriptions(guild);
+                    const kimakiChans = channels.filter((ch) => ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId));
+                    if (kimakiChans.length > 0) {
+                        kimakiChannels.push({ guild, channels: kimakiChans });
+                    }
+                }
+                resolve(null);
+            });
+            discordClient.once(Events.Error, reject);
+            discordClient.login(token).catch(reject);
+        });
+        s.stop('Connected to Discord!');
+    }
+    catch (error) {
+        s.stop('Failed to connect to Discord');
+        cliLogger.error('Error: ' + (error instanceof Error ? error.message : String(error)));
+        process.exit(EXIT_NO_RESTART);
+    }
+    for (const { guild, channels } of kimakiChannels) {
+        for (const channel of channels) {
+            if (channel.kimakiDirectory) {
+                db.prepare('INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)').run(channel.id, channel.kimakiDirectory, 'text');
+                const voiceChannel = guild.channels.cache.find((ch) => ch.type === ChannelType.GuildVoice && ch.name === channel.name);
+                if (voiceChannel) {
+                    db.prepare('INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)').run(voiceChannel.id, channel.kimakiDirectory, 'voice');
+                }
+            }
+        }
+    }
+    if (kimakiChannels.length > 0) {
+        const channelList = kimakiChannels
+            .flatMap(({ guild, channels }) => channels.map((ch) => {
+            const appInfo = ch.kimakiApp === appId
+                ? ' (this bot)'
+                : ch.kimakiApp
+                    ? ` (app: ${ch.kimakiApp})`
+                    : '';
+            return `#${ch.name} in ${guild.name}: ${ch.kimakiDirectory}${appInfo}`;
+        }))
+            .join('\n');
+        note(channelList, 'Existing Kimaki Channels');
+    }
+    s.start('Starting OpenCode server...');
+    let client;
+    try {
+        const currentDir = process.cwd();
+        client = await initializeOpencodeForDirectory(currentDir);
+        s.stop('OpenCode server started!');
+    }
+    catch (error) {
+        s.stop('Failed to start OpenCode');
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        discordClient.destroy();
+        process.exit(EXIT_NO_RESTART);
+    }
+    s.start('Fetching OpenCode projects...');
+    let projects = [];
+    try {
+        const projectsResponse = await client.project.list();
+        if (!projectsResponse.data) {
+            throw new Error('Failed to fetch projects');
+        }
+        projects = projectsResponse.data;
+        s.stop(`Found ${projects.length} OpenCode project(s)`);
+    }
+    catch (error) {
+        s.stop('Failed to fetch projects');
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        discordClient.destroy();
+        process.exit(EXIT_NO_RESTART);
+    }
+    const existingDirs = kimakiChannels.flatMap(({ channels }) => channels.map((ch) => ch.kimakiDirectory).filter(Boolean));
+    const availableProjects = projects.filter((project) => !existingDirs.includes(project.worktree));
+    if (availableProjects.length === 0) {
+        note('All OpenCode projects already have Discord channels', 'No New Projects');
+    }
+    if (shouldAddChannels && availableProjects.length > 0) {
+        const selectedProjects = await multiselect({
+            message: 'Select projects to create Discord channels for:',
+            options: availableProjects.map((project) => ({
+                value: project.id,
+                label: `${path.basename(project.worktree)} (${project.worktree})`,
+            })),
+            required: false,
+        });
+        if (!isCancel(selectedProjects) && selectedProjects.length > 0) {
+            let targetGuild;
+            if (guilds.length === 0) {
+                cliLogger.error('No Discord servers found! The bot must be installed in at least one server.');
+                process.exit(EXIT_NO_RESTART);
+            }
+            if (guilds.length === 1) {
+                targetGuild = guilds[0];
+            }
+            else {
+                const guildId = await text({
+                    message: 'Enter the Discord server ID to create channels in:',
+                    placeholder: guilds[0]?.id,
+                    validate(value) {
+                        if (!value)
+                            return 'Server ID is required';
+                        if (!guilds.find((g) => g.id === value))
+                            return 'Invalid server ID';
+                    },
+                });
+                if (isCancel(guildId)) {
+                    cancel('Setup cancelled');
+                    process.exit(0);
+                }
+                targetGuild = guilds.find((g) => g.id === guildId);
+            }
+            s.start('Creating Discord channels...');
+            for (const projectId of selectedProjects) {
+                const project = projects.find((p) => p.id === projectId);
+                if (!project)
+                    continue;
+                const baseName = path.basename(project.worktree);
+                const channelName = `kimaki-${baseName}`
+                    .toLowerCase()
+                    .replace(/[^a-z0-9-]/g, '-')
+                    .slice(0, 100);
+                try {
+                    const kimakiCategory = await ensureKimakiCategory(targetGuild);
+                    const textChannel = await targetGuild.channels.create({
+                        name: channelName,
+                        type: ChannelType.GuildText,
+                        parent: kimakiCategory,
+                        topic: `<kimaki><directory>${project.worktree}</directory><app>${appId}</app></kimaki>`,
+                    });
+                    const voiceChannel = await targetGuild.channels.create({
+                        name: channelName,
+                        type: ChannelType.GuildVoice,
+                        parent: kimakiCategory,
+                    });
+                    db.prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)').run(textChannel.id, project.worktree, 'text');
+                    db.prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)').run(voiceChannel.id, project.worktree, 'voice');
+                    createdChannels.push({
+                        name: textChannel.name,
+                        id: textChannel.id,
+                        guildId: targetGuild.id,
+                    });
+                }
+                catch (error) {
+                    cliLogger.error(`Failed to create channels for ${baseName}:`, error);
+                }
+            }
+            s.stop(`Created ${createdChannels.length} channel(s)`);
+            if (createdChannels.length > 0) {
+                note(createdChannels.map((ch) => `#${ch.name}`).join('\n'), 'Created Channels');
+            }
+        }
+    }
+    cliLogger.log('Registering slash commands asynchronously...');
+    void registerCommands(token, appId)
+        .then(() => {
+        cliLogger.log('Slash commands registered!');
+    })
+        .catch((error) => {
+        cliLogger.error('Failed to register slash commands:', error instanceof Error ? error.message : String(error));
+    });
+    s.start('Starting Discord bot...');
+    await startDiscordBot({ token, appId, discordClient });
+    s.stop('Discord bot is running!');
+    const allChannels = [];
+    allChannels.push(...createdChannels);
+    kimakiChannels.forEach(({ guild, channels }) => {
+        channels.forEach((ch) => {
+            allChannels.push({
+                name: ch.name,
+                id: ch.id,
+                guildId: guild.id,
+                directory: ch.kimakiDirectory,
+            });
+        });
+    });
+    if (allChannels.length > 0) {
+        const channelLinks = allChannels
+            .map((ch) => `• #${ch.name}: https://discord.com/channels/${ch.guildId}/${ch.id}`)
+            .join('\n');
+        note(`Your kimaki channels are ready! Click any link below to open in Discord:\n\n${channelLinks}\n\nSend a message in any channel to start using OpenCode!`, '🚀 Ready to Use');
+    }
+    outro('✨ Setup complete!');
+}
+cli
+    .command('', 'Set up and run the Kimaki Discord bot')
+    .option('--restart', 'Prompt for new credentials even if saved')
+    .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
+    .action(async (options) => {
+    try {
+        await run({
+            restart: options.restart,
+            addChannels: options.addChannels,
+        });
+    }
+    catch (error) {
+        cliLogger.error('Unhandled error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli.help();
+cli.parse();

package/dist/directVoiceStreaming.js

@@ -0,0 +1,102 @@
+import { Buffer } from 'node:buffer';
+import { PassThrough } from 'node:stream';
+import { VoiceConnectionStatus } from '@discordjs/voice';
+import * as prism from 'prism-media';
+import { Resampler } from '@purinton/resampler';
+// Discord expects Opus packets every 20ms
+const FRAME_LENGTH = 20;
+export function createDirectVoiceStreamer({ connection, inputSampleRate, inputChannels, onStop, }) {
+    let active = true;
+    const opusChannels = 2;
+    // Create resampler to convert input to 48kHz stereo (Discord's format)
+    const resampler = new Resampler({
+        inRate: inputSampleRate,
+        outRate: 48000,
+        inChannels: inputChannels,
+        volume: 1,
+        filterWindow: 8,
+        outChannels: opusChannels,
+    });
+    resampler.on('error', (error) => {
+        console.error('[DIRECT VOICE] Resampler error:', error);
+    });
+    resampler.on('end', () => {
+        console.error('[DIRECT VOICE] Resampler end');
+    });
+    const frameSize = 48000 * 20 / 1000; // 20ms at 48kHz = 960 samples per frame
+    // Create Opus encoder for Discord (48kHz stereo)
+    const encoder = new prism.opus.Encoder({
+        rate: 48000,
+        channels: opusChannels,
+        frameSize,
+    });
+    // Pipe resampler to encoder
+    resampler.pipe(encoder);
+    let packetInterval = null;
+    const opusPacketQueue = [];
+    encoder.on('data', (packet) => {
+        // Opus encoder outputs complete packets, don't buffer them
+        opusPacketQueue.push(packet);
+    });
+    // Send packets at 20ms intervals as Discord expects
+    packetInterval = setInterval(() => {
+        if (!active) {
+            if (packetInterval) {
+                clearInterval(packetInterval);
+                packetInterval = null;
+            }
+            return;
+        }
+        const packet = opusPacketQueue.shift();
+        if (!packet)
+            return;
+        if (connection.state.status !== VoiceConnectionStatus.Ready) {
+            console.log('[DIRECT VOICE] Skipping packet: connection not ready');
+            return;
+        }
+        try {
+            connection.setSpeaking(true);
+            connection.playOpusPacket(packet);
+            console.log('[DIRECT VOICE] Sent Opus packet of size', packet.length);
+        }
+        catch (error) {
+            console.error('[DIRECT VOICE] Error sending packet:', error);
+        }
+    }, 20); // 20ms interval
+    encoder.on('error', (error) => {
+        console.error('[DIRECT VOICE] Encoder error:', error);
+    });
+    return {
+        write(pcmData) {
+            if (!active) {
+                throw new Error('Voice streamer has been stopped');
+            }
+            resampler.write(pcmData);
+        },
+        interrupt() {
+            // Clear the Opus packet queue
+            opusPacketQueue.length = 0;
+            // Stop speaking immediately
+            connection.setSpeaking(false);
+            console.log('[DIRECT VOICE] Interrupted - cleared queue');
+        },
+        stop() {
+            if (!active)
+                return;
+            active = false;
+            // Stop speaking
+            connection.setSpeaking(false);
+            // Clear the packet interval
+            if (packetInterval) {
+                clearInterval(packetInterval);
+                packetInterval = null;
+            }
+            // Close the resampler input
+            resampler.end();
+            onStop?.();
+        },
+        get isActive() {
+            return active;
+        },
+    };
+}