@brianli/kimaki 0.4.72-brianli.1

package/dist/opencode.js

@@ -0,0 +1,409 @@
+// OpenCode server process manager.
+// Spawns and maintains OpenCode API servers per project directory,
+// handles automatic restarts on failure, and provides typed SDK clients.
+// Uses errore for type-safe error handling.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import { createOpencodeClient, } from '@opencode-ai/sdk/v2';
+import { getBotToken } from './bot-token.js';
+import { getDataDir, getLockPort, getVerboseOpencodeServer, } from './config.js';
+import { getHranaUrl } from './hrana-server.js';
+import * as errore from 'errore';
+import { createLogger, LogPrefix } from './logger.js';
+import { notifyError } from './sentry.js';
+import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
+const opencodeLogger = createLogger(LogPrefix.OPENCODE);
+const STARTUP_STDERR_TAIL_LIMIT = 30;
+const STARTUP_STDERR_LINE_MAX_LENGTH = 120;
+const STARTUP_ERROR_REASON_MAX_LENGTH = 1500;
+const ANSI_ESCAPE_REGEX = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+function truncateWithEllipsis({ value, maxLength, }) {
+    if (maxLength <= 3) {
+        return value.slice(0, maxLength);
+    }
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength - 3)}...`;
+}
+function stripAnsiCodes(value) {
+    return value.replaceAll(ANSI_ESCAPE_REGEX, '');
+}
+function splitOutputChunkLines(chunk) {
+    return chunk
+        .split(/\r?\n/g)
+        .map((line) => stripAnsiCodes(line).trim())
+        .filter((line) => line.length > 0);
+}
+function sanitizeForCodeFence(line) {
+    return line.replaceAll('```', '`\u200b``');
+}
+function pushStartupStderrTail({ stderrTail, chunk, }) {
+    const incomingLines = splitOutputChunkLines(chunk);
+    const truncatedLines = incomingLines.map((line) => {
+        const sanitizedLine = sanitizeForCodeFence(line);
+        return truncateWithEllipsis({
+            value: sanitizedLine,
+            maxLength: STARTUP_STDERR_LINE_MAX_LENGTH,
+        });
+    });
+    stderrTail.push(...truncatedLines);
+    if (stderrTail.length > STARTUP_STDERR_TAIL_LIMIT) {
+        stderrTail.splice(0, stderrTail.length - STARTUP_STDERR_TAIL_LIMIT);
+    }
+}
+function buildStartupTimeoutReason({ maxAttempts, stderrTail, }) {
+    const baseReason = `Server did not start after ${maxAttempts} seconds`;
+    if (stderrTail.length === 0) {
+        return baseReason;
+    }
+    const formatReason = ({ lines, omitted, }) => {
+        const omittedLine = omitted > 0
+            ? `[... ${omitted} older stderr lines omitted to fit Discord ...]\n`
+            : '';
+        const stderrCodeBlock = `${omittedLine}${lines.join('\n')}`;
+        return `${baseReason}\nLast opencode stderr lines:\n\`\`\`text\n${stderrCodeBlock}\n\`\`\``;
+    };
+    let lines = [...stderrTail];
+    let omitted = 0;
+    let formattedReason = formatReason({ lines, omitted });
+    while (formattedReason.length > STARTUP_ERROR_REASON_MAX_LENGTH &&
+        lines.length > 0) {
+        lines = lines.slice(1);
+        omitted += 1;
+        formattedReason = formatReason({ lines, omitted });
+    }
+    return truncateWithEllipsis({
+        value: formattedReason,
+        maxLength: STARTUP_ERROR_REASON_MAX_LENGTH,
+    });
+}
+const opencodeServers = new Map();
+const serverRetryCount = new Map();
+async function getOpenPort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, () => {
+            const address = server.address();
+            if (address && typeof address === 'object') {
+                const port = address.port;
+                server.close(() => {
+                    resolve(port);
+                });
+            }
+            else {
+                reject(new Error('Failed to get port'));
+            }
+        });
+        server.on('error', reject);
+    });
+}
+async function waitForServer({ port, maxAttempts = 30, startupStderrTail, }) {
+    const endpoint = `http://127.0.0.1:${port}/api/health`;
+    for (let i = 0; i < maxAttempts; i++) {
+        const response = await errore.tryAsync({
+            try: () => fetch(endpoint),
+            catch: (e) => new FetchError({ url: endpoint, cause: e }),
+        });
+        if (response instanceof Error) {
+            // Connection refused or other transient errors - continue polling
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            continue;
+        }
+        if (response.status < 500) {
+            return true;
+        }
+        const body = await response.text();
+        // Fatal errors that won't resolve with retrying
+        if (body.includes('BunInstallFailedError')) {
+            return new ServerStartError({ port, reason: body.slice(0, 200) });
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    return new ServerStartError({
+        port,
+        reason: buildStartupTimeoutReason({
+            maxAttempts,
+            stderrTail: startupStderrTail,
+        }),
+    });
+}
+/**
+ * Initialize OpenCode server for a directory.
+ * @param directory - The directory to run the server in (cwd)
+ * @param options.originalRepoDirectory - For worktrees: the original repo directory to allow access to
+ */
+export async function initializeOpencodeForDirectory(directory, options) {
+    const existing = opencodeServers.get(directory);
+    if (existing && !existing.process.killed) {
+        opencodeLogger.log(`Reusing existing server on port ${existing.port} for directory: ${directory}`);
+        return () => {
+            const entry = opencodeServers.get(directory);
+            if (!entry?.client) {
+                throw new ServerNotReadyError({ directory });
+            }
+            return entry.client;
+        };
+    }
+    // Verify directory exists and is accessible before spawning
+    const accessCheck = errore.tryFn({
+        try: () => {
+            fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK);
+        },
+        catch: () => new DirectoryNotAccessibleError({ directory }),
+    });
+    if (accessCheck instanceof Error) {
+        return accessCheck;
+    }
+    const port = await getOpenPort();
+    const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
+    // Normalize path separators for cross-platform compatibility (Windows uses backslashes)
+    const tmpdir = os.tmpdir().replaceAll('\\', '/');
+    const originalRepo = options?.originalRepoDirectory?.replaceAll('\\', '/');
+    const normalizedDirectory = directory.replaceAll('\\', '/');
+    // Build external_directory permissions, optionally including original repo for worktrees.
+    const externalDirectoryPermissions = {
+        '*': 'ask',
+        '/tmp': 'allow',
+        '/tmp/*': 'allow',
+        '/private/tmp': 'allow',
+        '/private/tmp/*': 'allow',
+        [tmpdir]: 'allow',
+        [`${tmpdir}/*`]: 'allow',
+        [normalizedDirectory]: 'allow',
+        [`${normalizedDirectory}/*`]: 'allow',
+    };
+    // Allow ~/.config/opencode so the agent doesn't get permission prompts when
+    // it tries to read the global AGENTS.md or opencode config (the path is
+    // visible in the system prompt, so models sometimes try to read it).
+    const opencodeConfigDir = path
+        .join(os.homedir(), '.config', 'opencode')
+        .replaceAll('\\', '/');
+    externalDirectoryPermissions[opencodeConfigDir] = 'allow';
+    externalDirectoryPermissions[`${opencodeConfigDir}/*`] = 'allow';
+    if (originalRepo) {
+        externalDirectoryPermissions[originalRepo] = 'allow';
+        externalDirectoryPermissions[`${originalRepo}/*`] = 'allow';
+    }
+    // Get bot token for plugin to use Discord API (env first, DB fallback)
+    const kimakiBotToken = getBotToken()?.token;
+    const serveArgs = ['serve', '--port', port.toString()];
+    if (getVerboseOpencodeServer()) {
+        serveArgs.push('--print-logs', '--log-level', 'DEBUG');
+    }
+    const serverProcess = spawn(opencodeCommand, serveArgs, {
+        stdio: 'pipe',
+        detached: false,
+        cwd: directory,
+        shell: true, // Required for .cmd files on Windows
+        env: {
+            ...process.env,
+            OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                $schema: 'https://opencode.ai/config.json',
+                lsp: false,
+                formatter: false,
+                plugin: [new URL('../src/opencode-plugin.ts', import.meta.url).href],
+                permission: {
+                    edit: 'allow',
+                    bash: 'allow',
+                    external_directory: externalDirectoryPermissions,
+                    webfetch: 'allow',
+                },
+                agent: {
+                    explore: {
+                        permission: {
+                            '*': 'deny',
+                            grep: 'allow',
+                            glob: 'allow',
+                            list: 'allow',
+                            read: {
+                                '*': 'allow',
+                                '*.env': 'deny',
+                                '*.env.*': 'deny',
+                                '*.env.example': 'allow',
+                            },
+                            webfetch: 'allow',
+                            websearch: 'allow',
+                            codesearch: 'allow',
+                            external_directory: externalDirectoryPermissions,
+                        },
+                    },
+                },
+                skills: {
+                    paths: [path.resolve(__dirname, '..', 'skills')],
+                },
+            }),
+            OPENCODE_PORT: port.toString(),
+            KIMAKI_DATA_DIR: getDataDir(),
+            KIMAKI_LOCK_PORT: getLockPort().toString(),
+            ...(kimakiBotToken && { KIMAKI_BOT_TOKEN: kimakiBotToken }),
+            ...(getHranaUrl() && { KIMAKI_DB_URL: getHranaUrl() }),
+            ...(process.env.KIMAKI_SENTRY_DSN && {
+                KIMAKI_SENTRY_DSN: process.env.KIMAKI_SENTRY_DSN,
+            }),
+        },
+    });
+    // Buffer logs until we know if server started successfully.
+    // Once ready, switch to forwarding if --verbose-opencode-server is set.
+    const logBuffer = [];
+    const startupStderrTail = [];
+    let serverReady = false;
+    const shortDir = path.basename(directory);
+    logBuffer.push(`Spawned opencode serve --port ${port} in ${directory} (pid: ${serverProcess.pid})`);
+    serverProcess.stdout?.on('data', (data) => {
+        try {
+            const chunk = data.toString();
+            const lines = splitOutputChunkLines(chunk);
+            if (!serverReady) {
+                logBuffer.push(...lines.map((line) => `[stdout] ${line}`));
+                return;
+            }
+            if (getVerboseOpencodeServer()) {
+                for (const line of lines) {
+                    opencodeLogger.log(`[${shortDir}:${port}] ${line}`);
+                }
+            }
+        }
+        catch (error) {
+            logBuffer.push(`Failed to process stdout startup logs: ${error}`);
+        }
+    });
+    serverProcess.stderr?.on('data', (data) => {
+        try {
+            const chunk = data.toString();
+            const lines = splitOutputChunkLines(chunk);
+            if (!serverReady) {
+                logBuffer.push(...lines.map((line) => `[stderr] ${line}`));
+                pushStartupStderrTail({ stderrTail: startupStderrTail, chunk });
+                return;
+            }
+            if (getVerboseOpencodeServer()) {
+                for (const line of lines) {
+                    opencodeLogger.error(`[${shortDir}:${port}] ${line}`);
+                }
+            }
+        }
+        catch (error) {
+            logBuffer.push(`Failed to process stderr startup logs: ${error}`);
+        }
+    });
+    serverProcess.on('error', (error) => {
+        logBuffer.push(`Failed to start server on port ${port}: ${error}`);
+    });
+    serverProcess.on('exit', (code) => {
+        opencodeLogger.log(`Opencode server on ${directory} exited with code:`, code);
+        // Capture init options before deleting the entry so auto-restart preserves
+        // worktree repo access.
+        const storedInitOptions = opencodeServers.get(directory)?.initOptions;
+        opencodeServers.delete(directory);
+        if (code !== 0) {
+            const retryCount = serverRetryCount.get(directory) || 0;
+            if (retryCount < 5) {
+                serverRetryCount.set(directory, retryCount + 1);
+                opencodeLogger.log(`Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`);
+                initializeOpencodeForDirectory(directory, storedInitOptions).then((result) => {
+                    if (result instanceof Error) {
+                        opencodeLogger.error(`Failed to restart opencode server:`, result);
+                        void notifyError(result, `OpenCode server restart failed for ${directory}`);
+                    }
+                });
+            }
+            else {
+                const crashError = new Error(`Server for ${directory} crashed too many times (5), not restarting`);
+                opencodeLogger.error(crashError.message);
+                void notifyError(crashError, `OpenCode server crash loop exhausted`);
+            }
+        }
+        else {
+            serverRetryCount.delete(directory);
+        }
+    });
+    const waitResult = await waitForServer({
+        port,
+        startupStderrTail,
+    });
+    if (waitResult instanceof Error) {
+        // Dump buffered logs on failure
+        opencodeLogger.error(`Server failed to start for ${directory}:`);
+        for (const line of logBuffer) {
+            opencodeLogger.error(`  ${line}`);
+        }
+        return waitResult;
+    }
+    serverReady = true;
+    opencodeLogger.log(`Server ready on port ${port}`);
+    // When verbose mode is enabled, also dump startup logs so plugin loading
+    // errors and other startup output are visible in kimaki.log.
+    if (getVerboseOpencodeServer()) {
+        for (const line of logBuffer) {
+            opencodeLogger.log(`[${shortDir}:${port}:startup] ${line}`);
+        }
+    }
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const fetchWithTimeout = (request) => fetch(request, {
+        // @ts-ignore
+        timeout: false,
+    });
+    const client = createOpencodeClient({
+        baseUrl,
+        fetch: fetchWithTimeout,
+    });
+    opencodeServers.set(directory, {
+        process: serverProcess,
+        client,
+        port,
+        initOptions: options,
+    });
+    return () => {
+        const entry = opencodeServers.get(directory);
+        if (!entry?.client) {
+            throw new ServerNotReadyError({ directory });
+        }
+        return entry.client;
+    };
+}
+export function getOpencodeServers() {
+    return opencodeServers;
+}
+export function getOpencodeServerPort(directory) {
+    const entry = opencodeServers.get(directory);
+    return entry?.port ?? null;
+}
+export function getOpencodeClient(directory) {
+    const entry = opencodeServers.get(directory);
+    return entry?.client ?? null;
+}
+/**
+ * Restart the opencode server for a directory.
+ * Kills the existing process and reinitializes a new one.
+ * Used for resolving opencode state issues, refreshing auth, plugins, etc.
+ */
+export async function restartOpencodeServer(directory) {
+    const existing = opencodeServers.get(directory);
+    // Preserve init options (originalRepoDirectory) so the restarted
+    // server retains worktree access.
+    const storedInitOptions = existing?.initOptions;
+    if (existing) {
+        opencodeLogger.log(`Killing existing server for directory: ${directory} (pid: ${existing.process.pid})`);
+        // Reset retry count so the exit handler doesn't auto-restart
+        serverRetryCount.set(directory, 999);
+        existing.process.kill('SIGTERM');
+        opencodeServers.delete(directory);
+        // Give the process time to fully terminate
+        await new Promise((resolve) => {
+            setTimeout(resolve, 1000);
+        });
+    }
+    // Reset retry count for the fresh start
+    serverRetryCount.delete(directory);
+    const result = await initializeOpencodeForDirectory(directory, storedInitOptions);
+    if (result instanceof Error) {
+        return result;
+    }
+    return true;
+}

package/dist/privacy-sanitizer.js

@@ -0,0 +1,105 @@
+// Sensitive data redaction helpers for logs and telemetry payloads.
+// Redacts common secrets, identifiers, emails, and can optionally redact paths.
+const CORE_SENSITIVE_REPLACEMENTS = [
+    {
+        pattern: /\bBearer\s+[A-Za-z0-9._-]{10,}\b/gi,
+        replacement: 'Bearer [REDACTED]',
+    },
+    {
+        pattern: /\bsk-[A-Za-z0-9]{16,}\b/g,
+        replacement: '[REDACTED_OPENAI_KEY]',
+    },
+    {
+        pattern: /\bAIza[0-9A-Za-z_-]{20,}\b/g,
+        replacement: '[REDACTED_GOOGLE_KEY]',
+    },
+    {
+        pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+        replacement: '[REDACTED_GITHUB_TOKEN]',
+    },
+    {
+        pattern: /([?&](?:token|api[_-]?key|key|secret|password|authorization)=)[^&\s]+/gi,
+        replacement: '$1[REDACTED]',
+    },
+    {
+        pattern: /(\b(?:token|api[_-]?key|secret|password|authorization)\b\s*[:=]\s*")([^"]+)(")/gi,
+        replacement: '$1[REDACTED]$3',
+    },
+    {
+        pattern: /(\b(?:token|api[_-]?key|secret|password|authorization)\b\s*[:=]\s*)([^\s,;]+)/gi,
+        replacement: '$1[REDACTED]',
+    },
+];
+const PATH_REPLACEMENTS = [
+    {
+        pattern: /\/(?:Users|home)\/[^/\s]+\/[^\s'"`)]*/g,
+        replacement: '[REDACTED_PATH]',
+    },
+    {
+        pattern: /[A-Za-z]:\\[^\s'"`)]*/g,
+        replacement: '[REDACTED_PATH]',
+    },
+];
+export function sanitizeSensitiveText(value, { redactPaths = false } = {}) {
+    const replacements = redactPaths
+        ? [...CORE_SENSITIVE_REPLACEMENTS, ...PATH_REPLACEMENTS]
+        : CORE_SENSITIVE_REPLACEMENTS;
+    return replacements.reduce((current, entry) => {
+        return current.replace(entry.pattern, entry.replacement);
+    }, value);
+}
+export function sanitizeUnknownValue(value, { depth = 0, seen = new WeakSet(), redactPaths = false, } = {}) {
+    if (depth > 8) {
+        return '[REDACTED_DEPTH_LIMIT]';
+    }
+    if (typeof value === 'string') {
+        return sanitizeSensitiveText(value, { redactPaths });
+    }
+    if (typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value === null ||
+        value === undefined) {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (value instanceof Error) {
+        const sanitizedStack = value.stack
+            ? sanitizeSensitiveText(value.stack, { redactPaths })
+            : undefined;
+        return {
+            name: value.name,
+            message: sanitizeSensitiveText(value.message, { redactPaths }),
+            stack: sanitizedStack,
+            cause: sanitizeUnknownValue(value.cause, {
+                depth: depth + 1,
+                seen,
+                redactPaths,
+            }),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => {
+            return sanitizeUnknownValue(item, { depth: depth + 1, seen, redactPaths });
+        });
+    }
+    if (typeof value === 'object') {
+        if (seen.has(value)) {
+            return '[REDACTED_CIRCULAR]';
+        }
+        seen.add(value);
+        const sanitizedEntries = Object.entries(value).map(([key, entryValue]) => {
+            return [
+                key,
+                sanitizeUnknownValue(entryValue, {
+                    depth: depth + 1,
+                    seen,
+                    redactPaths,
+                }),
+            ];
+        });
+        return Object.fromEntries(sanitizedEntries);
+    }
+    return sanitizeSensitiveText(String(value), { redactPaths });
+}

package/dist/runtime-mode.js

@@ -0,0 +1,51 @@
+export var Mode;
+(function (Mode) {
+    Mode["Bot"] = "bot";
+    Mode["Auth"] = "auth";
+})(Mode || (Mode = {}));
+function trim(value) {
+    const cleaned = value?.trim();
+    return cleaned || undefined;
+}
+function resolveAuthMode(env) {
+    const privateKey = trim(env.KIMAKI_PRIVATE_KEY);
+    const guildId = trim(env.KIMAKI_GUILD_ID);
+    const appId = trim(env.KIMAKI_APP_ID);
+    if (!privateKey || !guildId || !appId) {
+        return null;
+    }
+    return {
+        kind: Mode.Auth,
+        privateKey,
+        guildId,
+        appId,
+    };
+}
+export function resolveRuntimeMode({ env, dbToken, dbAppId, }) {
+    const envToken = trim(env.KIMAKI_BOT_TOKEN);
+    if (envToken) {
+        return {
+            kind: Mode.Bot,
+            token: envToken,
+            source: 'env',
+            appId: undefined,
+        };
+    }
+    const authMode = resolveAuthMode(env);
+    if (authMode) {
+        return authMode;
+    }
+    const databaseToken = trim(dbToken);
+    if (databaseToken) {
+        return {
+            kind: Mode.Bot,
+            token: databaseToken,
+            source: 'database',
+            appId: trim(dbAppId),
+        };
+    }
+    return null;
+}
+export function shouldRegisterCommandsLocally(mode) {
+    return mode.kind === Mode.Bot;
+}

package/dist/runtime-mode.test.js

@@ -0,0 +1,115 @@
+import { describe, expect, test } from 'vitest';
+import { Mode, resolveRuntimeMode, shouldRegisterCommandsLocally, } from './runtime-mode.js';
+function authEnv(overrides = {}) {
+    return {
+        KIMAKI_PRIVATE_KEY: 'private-key',
+        KIMAKI_GUILD_ID: 'guild-1',
+        KIMAKI_APP_ID: 'app-1',
+        ...overrides,
+    };
+}
+describe('resolveRuntimeMode', () => {
+    test('prefers bot mode when env token is present', () => {
+        const mode = resolveRuntimeMode({
+            env: {
+                ...authEnv(),
+                KIMAKI_BOT_TOKEN: 'token-from-env',
+            },
+            dbToken: 'token-from-db',
+            dbAppId: 'db-app',
+        });
+        expect(mode).toEqual({
+            kind: Mode.Bot,
+            token: 'token-from-env',
+            source: 'env',
+            appId: undefined,
+        });
+    });
+    test('uses auth mode when auth env is complete and no env token', () => {
+        const mode = resolveRuntimeMode({
+            env: authEnv(),
+            dbToken: 'token-from-db',
+            dbAppId: 'db-app',
+        });
+        expect(mode).toEqual({
+            kind: Mode.Auth,
+            privateKey: 'private-key',
+            guildId: 'guild-1',
+            appId: 'app-1',
+        });
+    });
+    test('does not accept legacy app id aliases for auth mode', () => {
+        const mode = resolveRuntimeMode({
+            env: authEnv({
+                KIMAKI_APP_ID: undefined,
+                KIMAKI_APPLICATION_ID: 'app-from-kimaki-application-id',
+            }),
+        });
+        expect(mode).toBeNull();
+    });
+    test('does not accept legacy guild aliases for auth mode', () => {
+        const mode = resolveRuntimeMode({
+            env: authEnv({
+                KIMAKI_GUILD_ID: undefined,
+                KIMAKI_GUILD: 'guild-from-kimaki-guild',
+            }),
+        });
+        expect(mode).toBeNull();
+    });
+    test('falls back to db bot mode when auth env is incomplete', () => {
+        const mode = resolveRuntimeMode({
+            env: authEnv({ KIMAKI_APP_ID: undefined }),
+            dbToken: 'token-from-db',
+            dbAppId: 'db-app',
+        });
+        expect(mode).toEqual({
+            kind: Mode.Bot,
+            token: 'token-from-db',
+            source: 'database',
+            appId: 'db-app',
+        });
+    });
+    test('returns null when no valid mode can be resolved', () => {
+        const mode = resolveRuntimeMode({
+            env: {
+                KIMAKI_PRIVATE_KEY: 'only-private-key',
+            },
+        });
+        expect(mode).toBeNull();
+    });
+    test('trims whitespace for env values', () => {
+        const mode = resolveRuntimeMode({
+            env: {
+                KIMAKI_PRIVATE_KEY: '  private-key  ',
+                KIMAKI_GUILD_ID: '  guild-1  ',
+                KIMAKI_APP_ID: '  app-1  ',
+            },
+        });
+        expect(mode).toEqual({
+            kind: Mode.Auth,
+            privateKey: 'private-key',
+            guildId: 'guild-1',
+            appId: 'app-1',
+        });
+    });
+});
+describe('shouldRegisterCommandsLocally', () => {
+    test('returns true for bot mode', () => {
+        const mode = {
+            kind: Mode.Bot,
+            token: 'token',
+            source: 'env',
+            appId: undefined,
+        };
+        expect(shouldRegisterCommandsLocally(mode)).toBe(true);
+    });
+    test('returns false for auth mode', () => {
+        const mode = {
+            kind: Mode.Auth,
+            privateKey: 'private-key',
+            guildId: 'guild',
+            appId: 'app',
+        };
+        expect(shouldRegisterCommandsLocally(mode)).toBe(false);
+    });
+});