kimaki 0.31.0 → 1.0.0

package/dist/cache-rewrite.js

@@ -1,39 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { createTwoFilesPatch, diffLines } from 'diff';
-export const CACHE_REWRITES_DIR = 'cache-rewrites';
-export function countSystemPromptDiffLines({ beforeText, afterText, }) {
-    const changes = diffLines(beforeText, afterText);
-    let additions = 0;
-    let deletions = 0;
-    for (const change of changes) {
-        if (change.added)
-            additions += change.count ?? 0;
-        if (change.removed)
-            deletions += change.count ?? 0;
-    }
-    return { additions, deletions };
-}
-export function formatSystemPromptPatch({ beforeText, afterText, sessionId, model, agent, }) {
-    const { additions, deletions } = countSystemPromptDiffLines({ beforeText, afterText });
-    const patch = createTwoFilesPatch('system-before.txt', 'system-after.txt', beforeText, afterText, undefined, undefined, { context: 3 });
-    return [
-        `session: ${sessionId}`,
-        `model: ${model ?? 'unknown'}`,
-        `agent: ${agent ?? 'unknown'}`,
-        `system +${additions} -${deletions}`,
-        '',
-        patch,
-    ].join('\n');
-}
-export function cacheRewritePatchPath({ dataDir, sessionId, now = Date.now(), }) {
-    const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
-    return path.join(dataDir, CACHE_REWRITES_DIR, `${now}-${safeSessionId}.patch`);
-}
-export async function writeSystemPromptPatch({ dataDir, sessionId, beforeText, afterText, model, agent, now, }) {
-    const filePath = cacheRewritePatchPath({ dataDir, sessionId, now });
-    const dirPath = path.dirname(filePath);
-    await fs.promises.mkdir(dirPath, { recursive: true, mode: 0o700 });
-    await fs.promises.writeFile(filePath, formatSystemPromptPatch({ beforeText, afterText, sessionId, model, agent }), { encoding: 'utf8', mode: 0o600 });
-    return filePath;
-}

package/dist/cache-rewrite.test.js

@@ -1,41 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, expect, test } from 'vitest';
-import { countSystemPromptDiffLines, formatSystemPromptPatch, writeSystemPromptPatch, } from './cache-rewrite.js';
-const tempDirs = [];
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-test('counts added and removed system prompt lines', () => {
-    expect(countSystemPromptDiffLines({
-        beforeText: 'keep\nold line\n',
-        afterText: 'keep\nnew line\nextra\n',
-    })).toEqual({ additions: 2, deletions: 1 });
-});
-test('writes a unified patch only for the caller', async () => {
-    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-cache-rewrite-'));
-    tempDirs.push(dataDir);
-    const filePath = await writeSystemPromptPatch({
-        dataDir,
-        sessionId: 'ses_test',
-        beforeText: 'alpha\n',
-        afterText: 'beta\n',
-        model: 'openai/gpt-5',
-        agent: 'build',
-        now: 1_700_000_000_000,
-    });
-    expect(path.basename(filePath)).toBe('1700000000000-ses_test.patch');
-    const text = fs.readFileSync(filePath, 'utf8');
-    expect(text).toContain('session: ses_test');
-    expect(text).toContain('system +1 -1');
-    expect(text).toContain('-alpha');
-    expect(text).toContain('+beta');
-    expect(formatSystemPromptPatch({
-        beforeText: 'alpha\n',
-        afterText: 'beta\n',
-        sessionId: 'ses_test',
-    })).toContain('--- system-before.txt');
-});

package/dist/channel-management.js

@@ -1,347 +0,0 @@
-// 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 fs from 'node:fs';
-import path from 'node:path';
-import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, listTrackedTextChannels, getGuildCategories, setGuildCategoryId, } from './database.js';
-import { getProjectsDir } from './config.js';
-import { execAsync } from './worktrees.js';
-import { createLogger, LogPrefix } from './logger.js';
-import { trackEvent, } from './analytics.js';
-/**
- * Distinct non-default project directories mapped as text channels.
- * Returns null on query failure so callers omit the field instead of
- * emitting a fabricated zero.
- */
-export async function getUserProjectCount() {
-    try {
-        const channels = await listTrackedTextChannels();
-        const defaultDir = path.resolve(getDefaultKimakiDirectory());
-        const dirs = new Set(channels
-            .map((row) => path.resolve(row.directory))
-            .filter((directory) => directory !== defaultDir));
-        return dirs.size;
-    }
-    catch {
-        return null;
-    }
-}
-async function trackProjectRegistered({ projectKind, source, }) {
-    const userProjectCount = await getUserProjectCount();
-    const props = {
-        project_kind: projectKind,
-        source,
-    };
-    if (userProjectCount !== null) {
-        props.user_project_count = userProjectCount;
-    }
-    trackEvent('project_registered', props);
-}
-const logger = createLogger(LogPrefix.CHANNEL);
-function defaultCategoryName(kind, botName) {
-    const isKimakiBot = botName?.toLowerCase() === 'kimaki';
-    if (kind === 'audio') {
-        return botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
-    }
-    return botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki';
-}
-function defaultKimakiChannelName({ botName, isGatewayMode, }) {
-    if (isGatewayMode || !botName)
-        return 'kimaki';
-    const sanitized = botName
-        .toLowerCase()
-        .replace(/[^a-z0-9-]/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '');
-    if (!sanitized || sanitized === 'kimaki')
-        return 'kimaki';
-    return `kimaki-${sanitized}`.slice(0, 100);
-}
-const categoryEnsures = new Map();
-function ensureCategorySerialized({ key, run, }) {
-    const existing = categoryEnsures.get(key);
-    if (existing)
-        return existing;
-    const promise = run().finally(() => {
-        if (categoryEnsures.get(key) === promise) {
-            categoryEnsures.delete(key);
-        }
-    });
-    categoryEnsures.set(key, promise);
-    return promise;
-}
-function isUnknownDiscordChannel(error) {
-    const code = error instanceof Error ? Reflect.get(error, 'code') : undefined;
-    const status = error instanceof Error ? Reflect.get(error, 'status') : undefined;
-    return code === 10003 || status === 404;
-}
-function isCategoryChannel(channel) {
-    return channel?.type === ChannelType.GuildCategory;
-}
-async function fetchCategoryById(guild, categoryId) {
-    const cached = guild.channels.cache.get(categoryId);
-    if (isCategoryChannel(cached))
-        return cached;
-    try {
-        const fetched = await guild.channels.fetch(categoryId);
-        return isCategoryChannel(fetched) ? fetched : null;
-    }
-    catch (error) {
-        if (isUnknownDiscordChannel(error))
-            return null;
-        throw error;
-    }
-}
-async function adoptParentFromTrackedChannels({ guild, channelType, }) {
-    const mappings = await findChannelsByDirectory({ channelType });
-    const channels = await guild.channels.fetch();
-    for (const row of mappings) {
-        if (row.guild_id && row.guild_id !== guild.id)
-            continue;
-        const channel = channels.get(row.channel_id);
-        if (!channel?.parentId)
-            continue;
-        const parent = await fetchCategoryById(guild, channel.parentId);
-        if (parent)
-            return parent;
-    }
-    return null;
-}
-async function resolveKimakiCategory({ guild, kind, botName, }) {
-    const stored = await getGuildCategories(guild.id);
-    const storedId = kind === 'audio' ? stored?.audio_category_id : stored?.category_id;
-    if (storedId) {
-        const existing = await fetchCategoryById(guild, storedId);
-        if (existing)
-            return existing;
-    }
-    const adopted = await adoptParentFromTrackedChannels({
-        guild,
-        channelType: kind === 'audio' ? 'voice' : 'text',
-    });
-    if (adopted) {
-        await setGuildCategoryId({
-            guildId: guild.id,
-            kind,
-            categoryId: adopted.id,
-        });
-        return adopted;
-    }
-    const created = await guild.channels.create({
-        name: defaultCategoryName(kind, botName),
-        type: ChannelType.GuildCategory,
-    });
-    await setGuildCategoryId({
-        guildId: guild.id,
-        kind,
-        categoryId: created.id,
-    });
-    return created;
-}
-export function ensureKimakiCategory(guild, botName) {
-    return ensureCategorySerialized({
-        key: `${guild.id}:text`,
-        run: () => resolveKimakiCategory({ guild, kind: 'text', botName }),
-    });
-}
-export function ensureKimakiAudioCategory(guild, botName) {
-    return ensureCategorySerialized({
-        key: `${guild.id}:audio`,
-        run: () => resolveKimakiCategory({ guild, kind: 'audio', botName }),
-    });
-}
-export async function createProjectChannels({ guild, projectDirectory, botName, enableVoiceChannels = false, analyticsSource = 'cli', }) {
-    const baseName = path.basename(projectDirectory);
-    const channelName = `${baseName}`
-        .toLowerCase()
-        .replace(/[^a-z0-9-]/g, '-')
-        .slice(0, 100);
-    const kimakiCategory = await ensureKimakiCategory(guild, botName);
-    const textChannel = await guild.channels.create({
-        name: channelName,
-        type: ChannelType.GuildText,
-        parent: kimakiCategory,
-        // Channel configuration is stored in SQLite, not in the topic
-    });
-    await setChannelDirectory({
-        channelId: textChannel.id,
-        directory: projectDirectory,
-        channelType: 'text',
-        guildId: guild.id,
-    });
-    await trackProjectRegistered({
-        projectKind: 'user',
-        source: analyticsSource,
-    });
-    let voiceChannelId = null;
-    if (enableVoiceChannels) {
-        const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
-        const voiceChannel = await guild.channels.create({
-            name: channelName,
-            type: ChannelType.GuildVoice,
-            parent: kimakiAudioCategory,
-        });
-        await setChannelDirectory({
-            channelId: voiceChannel.id,
-            directory: projectDirectory,
-            channelType: 'voice',
-            guildId: guild.id,
-        });
-        voiceChannelId = voiceChannel.id;
-    }
-    return {
-        textChannelId: textChannel.id,
-        voiceChannelId,
-        channelName,
-    };
-}
-export async function getChannelsWithDescriptions(guild) {
-    const channels = [];
-    const textChannels = guild.channels.cache.filter((channel) => channel.type === ChannelType.GuildText);
-    for (const channel of textChannels.values()) {
-        const description = channel.topic || null;
-        // Get channel config from database instead of parsing XML from topic
-        const channelConfig = await getChannelDirectory(channel.id);
-        channels.push({
-            id: channel.id,
-            name: channel.name,
-            description,
-            kimakiDirectory: channelConfig?.directory,
-        });
-    }
-    return channels;
-}
-const DEFAULT_GITIGNORE = `node_modules/
-dist/
-.env
-.env.*
-!.env.example
-.DS_Store
-tmp/
-*.log
-__pycache__/
-*.pyc
-.venv/
-*.egg-info/
-`;
-/** Returns the absolute path to the default kimaki project directory. */
-export function getDefaultKimakiDirectory() {
-    return path.join(getProjectsDir(), 'kimaki');
-}
-const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Kimaki. Not connected to a specific OpenCode project or repository.';
-/**
- * Create (or find) the default "kimaki" channel for general-purpose tasks.
- * Channel name is "kimaki-{botName}" for self-hosted bots, "kimaki" for gateway.
- * Directory is ~/.kimaki/projects/kimaki, git-initialized with a .gitignore.
- *
- * Idempotency: checks the database for an existing channel mapped to the
- * kimaki projects directory. Also scans this machine's category for the
- * exact default channel name as a fallback for channels created before
- * DB mapping existed.
- */
-export async function createDefaultKimakiChannel({ guild, botName, appId, isGatewayMode, }) {
-    const projectDirectory = getDefaultKimakiDirectory();
-    // Ensure the default kimaki project directory exists before any DB mapping
-    // restoration or git setup. Custom data dirs may not have <dataDir>/projects
-    // created yet, and later writes assume the full path is present.
-    if (!fs.existsSync(projectDirectory)) {
-        fs.mkdirSync(projectDirectory, { recursive: true });
-        logger.log(`Created default kimaki directory: ${projectDirectory}`);
-    }
-    // Hydrate guild channels from API so the cache scan is complete
-    try {
-        await guild.channels.fetch();
-    }
-    catch (error) {
-        logger.warn(`Could not fetch guild channels for ${guild.name}: ${error instanceof Error ? error.stack : String(error)}`);
-    }
-    // 1. Check database for existing channel mapped to this directory.
-    // Check ALL mappings (not just the first) since the same directory could
-    // have stale rows from deleted channels or other guilds.
-    const existingMappings = await findChannelsByDirectory({
-        directory: projectDirectory,
-        channelType: 'text',
-    });
-    const mappedRow = existingMappings.find((row) => {
-        const ch = guild.channels.cache.get(row.channel_id);
-        return ch?.type === ChannelType.GuildText;
-    });
-    if (mappedRow) {
-        // Backfill guild_id for rows created before this column existed,
-        // so the tombstone check works if the channel is deleted later.
-        if (mappedRow.guild_id !== guild.id) {
-            await setChannelDirectory({
-                channelId: mappedRow.channel_id,
-                directory: projectDirectory,
-                channelType: 'text',
-                guildId: guild.id,
-            });
-        }
-        logger.log(`Default kimaki channel already exists: ${mappedRow.channel_id}`);
-        return null;
-    }
-    // 1b. If a mapping exists for this guild but the channel is gone from Discord,
-    // it was previously created and then deleted. Don't recreate it.
-    const staleForThisGuild = existingMappings.find((row) => row.guild_id === guild.id);
-    if (staleForThisGuild) {
-        logger.log(`Default kimaki channel was previously provisioned for guild ${guild.name} (${guild.id}) as ${staleForThisGuild.channel_id}, but no longer exists. Skipping recreation.`);
-        return null;
-    }
-    // 2. Fallback: detect an existing default channel in THIS machine's group.
-    // A #kimaki channel in another machine's group is ignored.
-    const channelName = defaultKimakiChannelName({ botName, isGatewayMode });
-    const kimakiCategory = await ensureKimakiCategory(guild, botName);
-    const existingByName = guild.channels.cache.find((ch) => {
-        if (ch.type !== ChannelType.GuildText) {
-            return false;
-        }
-        if (ch.parentId !== kimakiCategory.id) {
-            return false;
-        }
-        return ch.name === channelName;
-    });
-    if (existingByName) {
-        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}. Skipping recreation.`);
-        return null;
-    }
-    // Git init — gracefully skip if git is not installed
-    const gitDir = path.join(projectDirectory, '.git');
-    if (!fs.existsSync(gitDir)) {
-        try {
-            await execAsync('git init', { cwd: projectDirectory, timeout: 10_000 });
-            logger.log(`Initialized git in: ${projectDirectory}`);
-        }
-        catch (error) {
-            logger.warn(`Could not initialize git in ${projectDirectory}: ${error instanceof Error ? error.stack : String(error)}`);
-        }
-    }
-    // Write .gitignore if it doesn't exist
-    const gitignorePath = path.join(projectDirectory, '.gitignore');
-    if (!fs.existsSync(gitignorePath)) {
-        fs.writeFileSync(gitignorePath, DEFAULT_GITIGNORE);
-    }
-    const textChannel = await guild.channels.create({
-        name: channelName,
-        type: ChannelType.GuildText,
-        parent: kimakiCategory,
-        topic: DEFAULT_CHANNEL_TOPIC,
-    });
-    await setChannelDirectory({
-        channelId: textChannel.id,
-        directory: projectDirectory,
-        channelType: 'text',
-        guildId: guild.id,
-    });
-    await trackProjectRegistered({
-        projectKind: 'default',
-        source: 'onboarding',
-    });
-    logger.log(`Created default kimaki channel: #${channelName} (${textChannel.id})`);
-    return {
-        textChannel,
-        textChannelId: textChannel.id,
-        channelName,
-        projectDirectory,
-    };
-}

package/dist/cli-commands/bot.js

@@ -1,254 +0,0 @@
-// Bot configuration terminal commands for install URLs and Discord presence.
-import { goke } from 'goke';
-import { z } from 'zod';
-import { note } from '@clack/prompts';
-import YAML from 'yaml';
-import * as errore from 'errore';
-import { Events, ActivityType, Routes } from 'discord.js';
-import path from 'node:path';
-import fs from 'node:fs';
-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 { ShareMarkdown } from '../markdown.js';
-import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
-import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
-import { WORKTREE_PREFIX } from '../commands/merge-worktree.js';
-import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-event-log.js';
-import { createDiscordRest } from '../discord-urls.js';
-import { archiveThread, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
-import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js';
-import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
-import { upgrade, getCurrentVersion } from '../upgrade.js';
-import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
-import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
-const cliLogger = createLogger(LogPrefix.CLI);
-const cli = goke();
-cli
-    .command('discord-install-url', 'Print the bot install URL and exit')
-    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
-    .option('--gateway', 'Print the gateway install URL and create local gateway credentials if missing')
-    .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
-    .action(async (options) => {
-    try {
-        if (options.dataDir) {
-            setDataDir(options.dataDir);
-            cliLogger.log(`Using data directory: ${getDataDir()}`);
-        }
-        initLogFile(getDataDir());
-        await printDiscordInstallUrlAndExit({
-            gateway: options.gateway,
-            gatewayCallbackUrl: options.gatewayCallbackUrl,
-        });
-    }
-    catch (error) {
-        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
-        process.exit(EXIT_NO_RESTART);
-    }
-});
-// ── bot command group ────────────────────────────────────────────────────
-const ACTIVITY_TYPE_MAP = {
-    playing: ActivityType.Playing,
-    watching: ActivityType.Watching,
-    listening: ActivityType.Listening,
-    competing: ActivityType.Competing,
-    custom: ActivityType.Custom,
-};
-const STATUS_MAP = {
-    online: 'online',
-    idle: 'idle',
-    dnd: 'dnd',
-    invisible: 'invisible',
-};
-cli
-    .command('bot install-url', 'Print the bot install URL')
-    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
-    .option('--gateway', 'Print the gateway install URL and create local gateway credentials if missing')
-    .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
-    .action(async (options) => {
-    try {
-        if (options.dataDir) {
-            setDataDir(options.dataDir);
-            cliLogger.log(`Using data directory: ${getDataDir()}`);
-        }
-        initLogFile(getDataDir());
-        await printDiscordInstallUrlAndExit({
-            gateway: options.gateway,
-            gatewayCallbackUrl: options.gatewayCallbackUrl,
-        });
-    }
-    catch (error) {
-        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
-        process.exit(EXIT_NO_RESTART);
-    }
-});
-// Max length for activity name/state — Discord silently truncates beyond 128 chars.
-const MAX_STATUS_TEXT_LENGTH = 128;
-// Login timeout for temporary discord.js clients (10s).
-const BOT_LOGIN_TIMEOUT_MS = 10_000;
-// Wait for gateway opcode 3 websocket frame to flush before destroying the client.
-const PRESENCE_FLUSH_DELAY_MS = 1200;
-/**
- * Create a temporary discord.js client, connect to gateway, run a callback,
- * then tear down. Includes a login timeout so the command doesn't hang forever.
- */
-async function withTempDiscordClient({ token, onReady, }) {
-    const client = await createDiscordClient();
-    try {
-        await Promise.race([
-            new Promise((resolve, reject) => {
-                client.once(Events.ClientReady, () => {
-                    resolve();
-                });
-                client.once(Events.Error, reject);
-                client.login(token).catch(reject);
-            }),
-            new Promise((_, reject) => {
-                setTimeout(() => {
-                    reject(new Error('Discord login timed out (10s)'));
-                }, BOT_LOGIN_TIMEOUT_MS);
-            }),
-        ]);
-        if (!client.isReady() || !client.user) {
-            throw new Error('Discord client ready but user is missing');
-        }
-        await onReady(client);
-    }
-    finally {
-        void client.destroy();
-    }
-}
-cli
-    .command('bot status set <text>', 'Set the bot presence/status in Discord')
-    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
-    .option('--type <activityType>', 'Activity type: playing, watching, listening, competing, custom (default: custom)')
-    .option('--status <onlineStatus>', 'Online status: online, idle, dnd, invisible (default: online)')
-    .action(async (text, options) => {
-    try {
-        if (options.dataDir) {
-            setDataDir(options.dataDir);
-        }
-        initLogFile(getDataDir());
-        await initDatabase();
-        const botRow = await getBotTokenWithMode();
-        if (!botRow) {
-            cliLogger.error('No bot configured. Run `kimaki` first.');
-            process.exit(EXIT_NO_RESTART);
-        }
-        if (botRow.mode === 'gateway') {
-            cliLogger.error('Cannot set status in gateway mode — it would change the shared bot status for all users.');
-            process.exit(EXIT_NO_RESTART);
-        }
-        if (text.length > MAX_STATUS_TEXT_LENGTH) {
-            cliLogger.error(`Status text too long (${text.length} chars, max ${MAX_STATUS_TEXT_LENGTH}).`);
-            process.exit(EXIT_NO_RESTART);
-        }
-        const activityTypeKey = (options.type || 'custom').toLowerCase();
-        const activityType = ACTIVITY_TYPE_MAP[activityTypeKey];
-        if (activityType === undefined) {
-            cliLogger.error(`Unknown activity type: ${options.type}. Use: playing, watching, listening, competing, custom`);
-            process.exit(EXIT_NO_RESTART);
-        }
-        const statusKey = (options.status || 'online').toLowerCase();
-        const onlineStatus = STATUS_MAP[statusKey];
-        if (!onlineStatus) {
-            cliLogger.error(`Unknown status: ${options.status}. Use: online, idle, dnd, invisible`);
-            process.exit(EXIT_NO_RESTART);
-        }
-        cliLogger.log('Connecting to Discord...');
-        await withTempDiscordClient({
-            token: botRow.token,
-            onReady: async (client) => {
-                // For custom activity type, use state field (shows as the status text).
-                // For other types, use name field (shows as "Playing X", "Watching X", etc).
-                const activity = activityType === ActivityType.Custom
-                    ? { name: 'Custom Status', type: activityType, state: text }
-                    : { name: text, type: activityType };
-                client.user.setPresence({
-                    activities: [activity],
-                    status: onlineStatus,
-                });
-                // setPresence queues a gateway opcode 3 over websocket.
-                // Wait so the frame flushes before we tear down the connection.
-                await new Promise((resolve) => {
-                    setTimeout(resolve, PRESENCE_FLUSH_DELAY_MS);
-                });
-                cliLogger.log(`Status set: ${activityTypeKey === 'custom' ? text : `${activityTypeKey} ${text}`} (${statusKey})`);
-            },
-        });
-        process.exit(0);
-    }
-    catch (error) {
-        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
-        process.exit(EXIT_NO_RESTART);
-    }
-});
-cli
-    .command('bot token', 'Print the bot token for use in CI and automation (KIMAKI_BOT_TOKEN)')
-    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
-    .action(async (options) => {
-    try {
-        if (options.dataDir) {
-            setDataDir(options.dataDir);
-        }
-        initLogFile(getDataDir());
-        await initDatabase();
-        const botRow = await getBotTokenWithMode();
-        if (!botRow) {
-            cliLogger.error('No bot configured. Run `kimaki` first.');
-            process.exit(EXIT_NO_RESTART);
-        }
-        // Print the token to stdout so it can be captured by scripts.
-        // Use process.stdout.write to avoid extra newline from console.log
-        // when piping to other commands.
-        process.stdout.write(botRow.token + '\n');
-        process.exit(0);
-    }
-    catch (error) {
-        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
-        process.exit(EXIT_NO_RESTART);
-    }
-});
-cli
-    .command('bot status clear', 'Clear the bot presence/status')
-    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
-    .action(async (options) => {
-    try {
-        if (options.dataDir) {
-            setDataDir(options.dataDir);
-        }
-        initLogFile(getDataDir());
-        await initDatabase();
-        const botRow = await getBotTokenWithMode();
-        if (!botRow) {
-            cliLogger.error('No bot configured. Run `kimaki` first.');
-            process.exit(EXIT_NO_RESTART);
-        }
-        if (botRow.mode === 'gateway') {
-            cliLogger.error('Cannot clear status in gateway mode — it would change the shared bot status for all users.');
-            process.exit(EXIT_NO_RESTART);
-        }
-        cliLogger.log('Connecting to Discord...');
-        await withTempDiscordClient({
-            token: botRow.token,
-            onReady: async (client) => {
-                client.user.setPresence({
-                    activities: [],
-                    status: 'online',
-                });
-                await new Promise((resolve) => {
-                    setTimeout(resolve, PRESENCE_FLUSH_DELAY_MS);
-                });
-                cliLogger.log('Status cleared');
-            },
-        });
-        process.exit(0);
-    }
-    catch (error) {
-        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
-        process.exit(EXIT_NO_RESTART);
-    }
-});
-export default cli;