kimaki 0.10.1 → 0.11.0

package/dist/cli-commands/misc.js

@@ -1,4 +1,4 @@
-// File upload terminal command for sharing local files into Discord threads.
+// File upload and TTS terminal commands for sharing local files into Discord threads.
 import { goke } from 'goke';
 import { z } from 'zod';
 import { note } from '@clack/prompts';
@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getAnyAudioApiKey } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -73,4 +73,78 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('tts [text]', 'Generate speech audio from text. Reads from stdin if no text given.')
+    .option('-o, --output [path]', 'Output file path (default: speech.mp3)')
+    .option('-v, --voice [voice]', 'Voice ID, defaults to alloy (OpenAI) or Kore (Gemini)')
+    .option('-i, --instructions [text]', 'Style instructions, e.g. "Speak calmly" (OpenAI only)')
+    .option('--speed [speed]', 'Speed multiplier 0.25-4.0 (OpenAI only)')
+    .option('-p, --provider [provider]', 'openai or gemini (auto-detected from key)')
+    .option('-k, --api-key [key]', 'API key (falls back to stored key or env var)')
+    .action(async (text, options) => {
+    const { generateSpeech } = await import('../voice.js');
+    // Read from stdin if no positional text argument
+    if (!text) {
+        if (process.stdin.isTTY) {
+            cliLogger.error('No text provided. Pass text as argument or pipe via stdin.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        text = Buffer.concat(chunks).toString('utf-8').trim();
+        if (!text) {
+            cliLogger.error('Empty input from stdin.');
+            process.exit(EXIT_NO_RESTART);
+        }
+    }
+    await initDatabase();
+    // Resolve API key: flag → DB → env
+    let apiKey = options.apiKey;
+    let provider = options.provider === 'openai' || options.provider === 'gemini'
+        ? options.provider
+        : undefined;
+    if (!apiKey) {
+        const stored = await getAnyAudioApiKey();
+        if (stored) {
+            apiKey = stored.apiKey;
+            provider = provider || stored.provider;
+        }
+    }
+    if (!apiKey) {
+        if (process.env.OPENAI_API_KEY) {
+            apiKey = process.env.OPENAI_API_KEY;
+            provider = provider || 'openai';
+        }
+        else if (process.env.GEMINI_API_KEY) {
+            apiKey = process.env.GEMINI_API_KEY;
+            provider = provider || 'gemini';
+        }
+    }
+    if (!apiKey) {
+        cliLogger.error('No API key found. Use --api-key, set OPENAI_API_KEY/GEMINI_API_KEY, or run /transcription-key in Discord.');
+        process.exit(EXIT_NO_RESTART);
+    }
+    const speed = options.speed ? Number(options.speed) : 1.25;
+    cliLogger.log(`Generating speech with ${provider || 'auto-detected provider'}...`);
+    const result = await generateSpeech({
+        text,
+        voice: options.voice || undefined,
+        apiKey,
+        provider,
+        instructions: options.instructions || undefined,
+        speed,
+    });
+    if (result instanceof Error) {
+        cliLogger.error(`Speech generation failed: ${result.message}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    const ext = result.mediaType === 'audio/mp3' ? 'mp3' : 'wav';
+    const outputPath = options.output || `speech.${ext}`;
+    const resolvedOutput = path.resolve(outputPath);
+    await fs.promises.writeFile(resolvedOutput, result.audio);
+    cliLogger.log(`Audio saved to ${resolvedOutput} (${(result.audio.length / 1024).toFixed(1)} KB)`);
+    process.exit(0);
+});
 export default cli;

package/dist/cli-runner.js

@@ -938,35 +938,16 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
     startCaffeinate();
     const forceRestartOnboarding = Boolean(restartOnboarding);
     const forceGateway = Boolean(gateway);
-    // Step 0: Ensure required CLI tools are installed (OpenCode + Bun).
-    // Run checks in parallel since they're independent `which` calls.
-    await Promise.all([
-        ensureCommandAvailable({
-            name: 'opencode',
-            envPathKey: 'OPENCODE_PATH',
-            installUnix: 'curl -fsSL https://opencode.ai/install | bash',
-            installWindows: 'irm https://opencode.ai/install.ps1 | iex',
-            possiblePathsUnix: [
-                '~/.local/bin/opencode',
-                '~/.opencode/bin/opencode',
-                '/usr/local/bin/opencode',
-                '/opt/opencode/bin/opencode',
-            ],
-            possiblePathsWindows: [
-                '~\\.local\\bin\\opencode.exe',
-                '~\\AppData\\Local\\opencode\\opencode.exe',
-                '~\\.opencode\\bin\\opencode.exe',
-            ],
-        }),
-        ensureCommandAvailable({
-            name: 'bun',
-            envPathKey: 'BUN_PATH',
-            installUnix: 'curl -fsSL https://bun.sh/install | bash',
-            installWindows: 'irm bun.sh/install.ps1 | iex',
-            possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
-            possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
-        }),
-    ]);
+    // Step 0: Ensure bun is installed. OpenCode is downloaded on first run
+    // to ~/.kimaki/bin/ (pinned version), so no install check is needed.
+    await ensureCommandAvailable({
+        name: 'bun',
+        envPathKey: 'BUN_PATH',
+        installUnix: 'curl -fsSL https://bun.sh/install | bash',
+        installWindows: 'irm bun.sh/install.ps1 | iex',
+        possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
+        possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
+    });
     void backgroundUpgradeKimaki();
     // Start in-process Hrana server before database init. Required for the bot
     // process because it serves as both the DB server and the single-instance

package/dist/cli.js

@@ -39,6 +39,7 @@ cli
     .option('--mention-mode', 'Bot only responds when @mentioned (default for all channels)')
     .option('--no-critique', 'Disable automatic diff upload to critique.work in system prompts')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
+    .option('--allow-all-users', 'Allow all Discord users to start sessions without needing Kimaki role or admin permissions (no-kimaki role still blocks)')
     .option('--no-sentry', 'Disable Sentry error reporting')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
     .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
@@ -134,6 +135,7 @@ cli
             }),
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
+            ...(options.allowAllUsers && { allowAllUsers: true }),
             ...(enabledSkills.length > 0 && { enabledSkills }),
             ...(disabledSkills.length > 0 && { disabledSkills }),
         });
@@ -143,6 +145,9 @@ cli
         if (disabledSkills.length > 0) {
             cliLogger.log(`Skill blacklist enabled: [${disabledSkills.join(', ')}] will be hidden`);
         }
+        if (options.allowAllUsers) {
+            cliLogger.log('Allow all users: any Discord member can start sessions (no-kimaki role still blocks)');
+        }
         if (options.verbosity) {
             cliLogger.log(`Default verbosity: ${options.verbosity}`);
         }

package/dist/commands/agent.js

@@ -1,10 +1,13 @@
 // /agent command - Set the preferred agent for this channel or session.
 // Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
-import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
+// When a prompt is provided to a quick agent command (e.g. /plan-agent "fix the bug"),
+// the prompt is sent as a one-shot with that agent without switching the persistent preference.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
 import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { resolveTextChannel, resolveWorkingDirectory, getKimakiMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getCurrentModelInfo } from './model.js';
 const agentLogger = createLogger(LogPrefix.AGENT);
@@ -286,6 +289,13 @@ export async function handleAgentSelectMenu(interaction) {
  */
 export async function handleQuickAgentCommand({ command, appId, }) {
     const fallbackAgentName = command.commandName.replace(/-agent$/, '');
+    const prompt = command.options.getString('prompt') || undefined;
+    // One-shot prompt mode: send the prompt with a temporary agent override
+    // without changing the persistent agent preference.
+    if (prompt) {
+        return handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, prompt });
+    }
+    // No prompt: switch the persistent agent preference (original behavior).
     await command.deferReply({ flags: MessageFlags.Ephemeral });
     const context = await resolveAgentCommandContext({
         interaction: command,
@@ -352,3 +362,107 @@ export async function handleQuickAgentCommand({ command, appId, }) {
         });
     }
 }
+/**
+ * Handle one-shot prompt mode: send a prompt with a temporary agent override.
+ * In a thread: enqueue the prompt with the agent override on the existing session.
+ * In a channel: create a new thread and enqueue the prompt with the agent override.
+ * Neither case changes the persistent agent preference.
+ */
+async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, prompt, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const resolvedAgentName = (await resolveQuickAgentNameFromInteraction({ command })) ||
+        fallbackAgentName;
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const displayText = `${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`;
+    if (isThread) {
+        // In a thread: enqueue the prompt on the existing session with agent override.
+        const thread = channel;
+        const resolved = await resolveWorkingDirectory({ channel: thread });
+        if (!resolved) {
+            await command.reply({
+                content: 'Could not determine project directory for this channel',
+                flags: MessageFlags.Ephemeral,
+            });
+            return;
+        }
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory: resolved.projectDirectory,
+            sdkDirectory: resolved.workingDirectory,
+            channelId: thread.parentId || thread.id,
+            appId,
+        });
+        // Visible reply showing the one-shot prompt (not ephemeral, so it appears in thread).
+        await command.reply({
+            content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        await runtime.enqueueIncoming({
+            prompt,
+            userId: command.user.id,
+            username: command.user.displayName,
+            agent: resolvedAgentName,
+            appId,
+            mode: 'opencode',
+        });
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        // In a channel: create a new thread and enqueue with the agent override.
+        const textChannel = channel;
+        const metadata = await getKimakiMetadata(textChannel);
+        const projectDirectory = metadata.projectDirectory;
+        if (!projectDirectory) {
+            await command.reply({
+                content: 'This channel is not configured with a project directory',
+                flags: MessageFlags.Ephemeral,
+            });
+            return;
+        }
+        await command.deferReply();
+        const starterMessage = await textChannel.send({
+            content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const thread = await starterMessage.startThread({
+            name: prompt.slice(0, 80),
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `One-shot ${resolvedAgentName} agent prompt`,
+        });
+        await thread.members.add(command.user.id);
+        await command.editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`);
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory,
+            sdkDirectory: projectDirectory,
+            channelId: textChannel.id,
+            appId,
+        });
+        await runtime.enqueueIncoming({
+            prompt,
+            userId: command.user.id,
+            username: command.user.displayName,
+            agent: resolvedAgentName,
+            appId,
+            mode: 'opencode',
+        });
+    }
+    else {
+        await command.reply({
+            content: 'This command can only be used in text channels or threads',
+            flags: MessageFlags.Ephemeral,
+        });
+    }
+}

package/dist/commands/gemini-apikey.js

@@ -1,11 +1,13 @@
-// Transcription API key button, slash command, and modal handlers.
+// Audio API key button, slash command, and modal handlers.
+// Used for both transcription and speech generation — same OpenAI/Gemini keys.
 // Auto-detects provider from key prefix: sk-* = OpenAI, otherwise Gemini.
-import { ActionRowBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, MessageFlags, } from 'discord.js';
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ModalBuilder, TextInputBuilder, TextInputStyle, MessageFlags, } from 'discord.js';
 import { setGeminiApiKey, setOpenAIApiKey } from '../database.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 function buildTranscriptionApiKeyModal(appId) {
     const modal = new ModalBuilder()
         .setCustomId(`transcription_apikey_modal:${appId}`)
-        .setTitle('Transcription API Key');
+        .setTitle('Audio API Key');
     const apiKeyInput = new TextInputBuilder()
         .setCustomId('apikey')
         .setLabel('OpenAI or Gemini API Key')
@@ -16,6 +18,23 @@ function buildTranscriptionApiKeyModal(appId) {
     modal.addComponents(actionRow);
     return modal;
 }
+/**
+ * Show a "Set API Key" button in a Discord thread.
+ * Reusable for both transcription and TTS — both use the same stored keys.
+ * The button opens a modal where the user can enter an OpenAI or Gemini key.
+ */
+export async function showApiKeyRequiredButton({ thread, appId, message, }) {
+    const button = new ButtonBuilder()
+        .setCustomId(`transcription_apikey:${appId}`)
+        .setLabel('Set API Key')
+        .setStyle(ButtonStyle.Primary);
+    const row = new ActionRowBuilder().addComponents(button);
+    await thread.send({
+        content: message || 'An API key (OpenAI or Gemini) is required. Set one to continue.',
+        components: [row],
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+}
 export async function handleTranscriptionApiKeyButton(interaction) {
     if (!interaction.customId.startsWith('transcription_apikey:'))
         return;
@@ -58,13 +77,13 @@ export async function handleTranscriptionApiKeyModalSubmit(interaction) {
     if (apiKey.startsWith('sk-')) {
         await setOpenAIApiKey(appId, apiKey);
         await interaction.editReply({
-            content: 'OpenAI API key saved. Voice messages will be transcribed with OpenAI.',
+            content: 'OpenAI API key saved. Voice transcription and speech generation are now enabled.',
         });
     }
     else {
         await setGeminiApiKey(appId, apiKey);
         await interaction.editReply({
-            content: 'Gemini API key saved. Voice messages will be transcribed with Gemini.',
+            content: 'Gemini API key saved. Voice transcription and speech generation are now enabled.',
         });
     }
 }

package/dist/database.js

@@ -500,6 +500,22 @@ export async function getTranscriptionApiKey(appId) {
         return { provider: 'gemini', apiKey: row.gemini_api_key };
     return null;
 }
+/**
+ * Get any stored audio API key (OpenAI or Gemini) without requiring a specific appId.
+ * Used by the plugin process which doesn't have direct access to the bot's appId.
+ * Returns the first available key found, preferring OpenAI.
+ */
+export async function getAnyAudioApiKey() {
+    const db = await getDb();
+    const row = await db.query.bot_api_keys.findFirst();
+    if (!row)
+        return null;
+    if (row.openai_api_key)
+        return { provider: 'openai', apiKey: row.openai_api_key, appId: row.app_id };
+    if (row.gemini_api_key)
+        return { provider: 'gemini', apiKey: row.gemini_api_key, appId: row.app_id };
+    return null;
+}
 export async function setChannelDirectory({ channelId, directory, channelType, skipIfExists = false }) {
     const db = await getDb();
     if (skipIfExists) {

package/dist/discord-command-registration.js

@@ -19,46 +19,13 @@ function getDiscordCommandSuffix(command) {
     }
     return '-cmd';
 }
-function isDiscordCommandSummary(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    const id = Reflect.get(value, 'id');
-    const name = Reflect.get(value, 'name');
-    return typeof id === 'string' && typeof name === 'string';
-}
-async function deleteLegacyGlobalCommands({ rest, appId, commandNames, }) {
+async function clearGlobalCommands({ rest, appId, }) {
     try {
-        const response = await rest.get(Routes.applicationCommands(appId));
-        if (!Array.isArray(response)) {
-            cliLogger.warn('COMMANDS: Unexpected global command payload while cleaning legacy global commands');
-            return;
-        }
-        const legacyGlobalCommands = response
-            .filter(isDiscordCommandSummary)
-            .filter((command) => {
-            return commandNames.has(command.name);
-        });
-        if (legacyGlobalCommands.length === 0) {
-            return;
-        }
-        const deletionResults = await Promise.allSettled(legacyGlobalCommands.map(async (command) => {
-            await rest.delete(Routes.applicationCommand(appId, command.id));
-            return command;
-        }));
-        const failedDeletions = deletionResults.filter((result) => {
-            return result.status === 'rejected';
-        });
-        if (failedDeletions.length > 0) {
-            cliLogger.warn(`COMMANDS: Failed to delete ${failedDeletions.length} legacy global command(s)`);
-        }
-        const deletedCount = deletionResults.length - failedDeletions.length;
-        if (deletedCount > 0) {
-            cliLogger.info(`COMMANDS: Deleted ${deletedCount} legacy global command(s) to avoid guild/global duplicates`);
-        }
+        await rest.put(Routes.applicationCommands(appId), { body: [] });
+        cliLogger.info('COMMANDS: Cleared global slash commands');
     }
     catch (error) {
-        cliLogger.warn(`COMMANDS: Could not clean legacy global commands: ${error instanceof Error ? error.stack : String(error)}`);
+        cliLogger.warn(`COMMANDS: Could not clear global slash commands: ${error instanceof Error ? error.stack : String(error)}`);
     }
 }
 // Discord slash command descriptions must be 1-100 chars.
@@ -426,6 +393,10 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setName(commandName)
             .setDescription(truncateCommandDescription(description))
             .setDMPermission(false)
+            .addStringOption((opt) => opt
+            .setName('prompt')
+            .setDescription('Send a one-shot prompt with this agent without switching')
+            .setRequired(false))
             .toJSON());
     }
     // 2. User-defined commands, skills, and MCP prompts (ordered by priority)
@@ -488,13 +459,6 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
     }
     const rest = createDiscordRest(token);
     const uniqueGuildIds = Array.from(new Set(guildIds.filter((guildId) => guildId)));
-    const guildCommandNames = new Set(commands
-        .map((command) => {
-        return command.name;
-    })
-        .filter((name) => {
-        return typeof name === 'string';
-    }));
     if (uniqueGuildIds.length === 0) {
         cliLogger.warn('COMMANDS: No guilds available, skipping slash command registration');
         return;
@@ -543,10 +507,9 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
         // exist for self-hosted bots that previously registered commands globally.
         const isGateway = store.getState().discordBaseUrl !== 'https://discord.com';
         if (!isGateway) {
-            await deleteLegacyGlobalCommands({
+            await clearGlobalCommands({
                 rest,
                 appId,
-                commandNames: guildCommandNames,
             });
         }
         cliLogger.info(`COMMANDS: Successfully registered ${registeredCommandCount} slash commands for ${successfulGuilds} guild(s)`);

package/dist/discord-utils.js

@@ -14,6 +14,7 @@ import { limitHeadingDepth } from './limit-heading-depth.js';
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
 import { createLogger, LogPrefix } from './logger.js';
 import * as errore from 'errore';
+import { store } from './store.js';
 import mime from 'mime';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -32,6 +33,34 @@ export function hasKimakiBotPermission(member, guild) {
     if (hasNoKimakiRole) {
         return false;
     }
+    if (store.getState().allowAllUsers) {
+        return true;
+    }
+    const memberPermissions = member instanceof GuildMember
+        ? member.permissions
+        : new PermissionsBitField(BigInt(member.permissions));
+    const ownerId = member instanceof GuildMember ? member.guild.ownerId : guild?.ownerId;
+    const memberId = member instanceof GuildMember ? member.id : member.user.id;
+    const isOwner = ownerId ? memberId === ownerId : false;
+    const isAdmin = memberPermissions.has(PermissionsBitField.Flags.Administrator);
+    const canManageServer = memberPermissions.has(PermissionsBitField.Flags.ManageGuild);
+    const hasKimakiRole = hasRoleByName(member, 'kimaki', guild);
+    return isOwner || isAdmin || canManageServer || hasKimakiRole;
+}
+/**
+ * Stricter permission check that ignores allowAllUsers.
+ * Use for admin-only commands like /login and /transcription-key that
+ * configure shared credentials. Always requires owner, admin, manage
+ * server, or Kimaki role regardless of --allow-all-users flag.
+ */
+export function hasKimakiAdminPermission(member, guild) {
+    if (!member) {
+        return false;
+    }
+    const hasNoKimaki = hasRoleByName(member, 'no-kimaki', guild);
+    if (hasNoKimaki) {
+        return false;
+    }
     const memberPermissions = member instanceof GuildMember
         ? member.permissions
         : new PermissionsBitField(BigInt(member.permissions));

package/dist/discord-utils.test.js

@@ -1,6 +1,7 @@
 import { PermissionsBitField } from 'discord.js';
-import { describe, expect, test } from 'vitest';
-import { hasKimakiBotPermission, splitMarkdownForDiscord } from './discord-utils.js';
+import { afterEach, describe, expect, test } from 'vitest';
+import { hasKimakiAdminPermission, hasKimakiBotPermission, splitMarkdownForDiscord } from './discord-utils.js';
+import { store } from './store.js';
 describe('splitMarkdownForDiscord', () => {
     test('never returns chunks over the max length with code fences', () => {
         const maxLength = 2000;
@@ -90,6 +91,40 @@ describe('splitMarkdownForDiscord', () => {
     });
 });
 describe('hasKimakiBotPermission', () => {
+    afterEach(() => {
+        store.setState({ allowAllUsers: false });
+    });
+    test('allows any member when allowAllUsers is enabled', () => {
+        store.setState({ allowAllUsers: true });
+        const guild = {
+            ownerId: 'owner-id',
+            roles: { cache: new Map() },
+        };
+        const member = {
+            user: { id: 'member-id' },
+            permissions: '0',
+            roles: [],
+        };
+        expect(hasKimakiBotPermission(member, guild)).toBe(true);
+    });
+    test('still blocks no-kimaki role even when allowAllUsers is enabled', () => {
+        store.setState({ allowAllUsers: true });
+        const noKimakiRoleId = '222';
+        const guild = {
+            ownerId: 'owner-id',
+            roles: {
+                cache: new Map([
+                    [noKimakiRoleId, { id: noKimakiRoleId, name: 'no-kimaki' }],
+                ]),
+            },
+        };
+        const member = {
+            user: { id: 'member-id' },
+            permissions: '0',
+            roles: [noKimakiRoleId],
+        };
+        expect(hasKimakiBotPermission(member, guild)).toBe(false);
+    });
     test('allows API interaction member when kimaki role exists', () => {
         const kimakiRoleId = '111';
         const guild = {
@@ -132,3 +167,34 @@ describe('hasKimakiBotPermission', () => {
         expect(hasKimakiBotPermission(member, guild)).toBe(false);
     });
 });
+describe('hasKimakiAdminPermission', () => {
+    afterEach(() => {
+        store.setState({ allowAllUsers: false });
+    });
+    test('denies unprivileged member even when allowAllUsers is enabled', () => {
+        store.setState({ allowAllUsers: true });
+        const guild = {
+            ownerId: 'owner-id',
+            roles: { cache: new Map() },
+        };
+        const member = {
+            user: { id: 'member-id' },
+            permissions: '0',
+            roles: [],
+        };
+        expect(hasKimakiAdminPermission(member, guild)).toBe(false);
+    });
+    test('allows admin even when allowAllUsers is enabled', () => {
+        store.setState({ allowAllUsers: true });
+        const guild = {
+            ownerId: 'owner-id',
+            roles: { cache: new Map() },
+        };
+        const member = {
+            user: { id: 'member-id' },
+            permissions: PermissionsBitField.Flags.Administrator.toString(),
+            roles: [],
+        };
+        expect(hasKimakiAdminPermission(member, guild)).toBe(true);
+    });
+});

package/dist/errors.js

@@ -58,6 +58,11 @@ export class TranscriptionError extends createTaggedError({
     message: 'Transcription failed: $reason',
 }) {
 }
+export class SpeechGenerationError extends createTaggedError({
+    name: 'SpeechGenerationError',
+    message: 'Speech generation failed: $reason',
+}) {
+}
 export class GrepSearchError extends createTaggedError({
     name: 'GrepSearchError',
     message: 'Grep search failed for pattern: $pattern',