@otto-assistant/bridge 0.4.92

package/dist/commands/tasks.js

@@ -0,0 +1,205 @@
+// /tasks command — list all scheduled tasks sorted by next run time.
+// Renders a markdown table that the CV2 pipeline auto-formats for Discord,
+// including HTML-backed action buttons for cancellable tasks.
+import { ButtonInteraction, ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'discord.js';
+import { cancelScheduledTask, listScheduledTasks, } from '../database.js';
+import { splitTablesFromMarkdown } from '../format-tables.js';
+import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
+import { formatTimeAgo } from './worktrees.js';
+function formatTimeUntil(date) {
+    const diffMs = date.getTime() - Date.now();
+    if (diffMs <= 0) {
+        return 'due now';
+    }
+    const totalSeconds = Math.floor(diffMs / 1000);
+    if (totalSeconds < 60) {
+        return `in ${totalSeconds}s`;
+    }
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60) {
+        return `in ${totalMinutes}m`;
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours < 24) {
+        return minutes > 0 ? `in ${hours}h ${minutes}m` : `in ${hours}h`;
+    }
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return remainingHours > 0 ? `in ${days}d ${remainingHours}h` : `in ${days}d`;
+}
+function scheduleLabel(task) {
+    if (task.schedule_kind === 'cron') {
+        return task.cron_expr || 'cron';
+    }
+    return 'one-time';
+}
+function canCancelTask(task) {
+    return task.status === 'planned' || task.status === 'running';
+}
+// Escape pipe chars and collapse whitespace so free-text fields don't break
+// GFM table column alignment.
+function sanitizeTableCell(value) {
+    return value.replaceAll('|', '\\|').replace(/\s+/g, ' ').trim();
+}
+function buildCancelButtonHtml({ buttonId }) {
+    return `<button id="${buttonId}" variant="secondary">Delete</button>`;
+}
+function buildActionCell(task) {
+    if (!canCancelTask(task)) {
+        return '-';
+    }
+    return buildCancelButtonHtml({ buttonId: `cancel-task-${task.id}` });
+}
+// Cap rows to avoid exceeding Discord's 40-component CV2 limit.
+// Each cancellable row renders as text + action row + button (~4 components),
+// so 10 rows is a safe ceiling.
+const MAX_TASK_ROWS = 10;
+function buildTaskTable({ tasks, }) {
+    const header = '| ID | Status | Prompt | Schedule | Next Run | Action |';
+    const separator = '|---|---|---|---|---|---|';
+    const rows = tasks.map((task) => {
+        const id = String(task.id);
+        const status = task.status;
+        const prompt = sanitizeTableCell(task.prompt_preview.length > 240
+            ? task.prompt_preview.slice(0, 237) + '...'
+            : task.prompt_preview);
+        const schedule = sanitizeTableCell(scheduleLabel(task));
+        const nextRun = (() => {
+            if (task.status === 'completed' ||
+                task.status === 'cancelled' ||
+                task.status === 'failed') {
+                return task.last_run_at ? formatTimeAgo(task.last_run_at) : '-';
+            }
+            return formatTimeUntil(task.next_run_at);
+        })();
+        const action = buildActionCell(task);
+        return `| ${id} | ${status} | ${prompt} | ${schedule} | ${nextRun} | ${action} |`;
+    });
+    return [header, separator, ...rows].join('\n');
+}
+function getTasksActionOwnerKey({ userId, channelId, }) {
+    return `tasks:${userId}:${channelId}`;
+}
+async function renderTasksReply({ guildId, userId, channelId, showAll, notice, editReply, }) {
+    const ownerKey = getTasksActionOwnerKey({ userId, channelId });
+    cancelHtmlActionsForOwner(ownerKey);
+    const statuses = showAll
+        ? undefined
+        : ['planned', 'running'];
+    const allTasks = await listScheduledTasks({ statuses });
+    if (allTasks.length === 0) {
+        const message = notice
+            ? `${notice}\n\nNo scheduled tasks found.`
+            : 'No scheduled tasks found.';
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: message,
+        };
+        await editReply({
+            components: [textDisplay],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const tasks = allTasks.slice(0, MAX_TASK_ROWS);
+    const truncatedNotice = allTasks.length > MAX_TASK_ROWS
+        ? `Showing ${MAX_TASK_ROWS}/${allTasks.length} tasks. Use \`kimaki task list\` for full list.`
+        : undefined;
+    const combinedNotice = [notice, truncatedNotice].filter(Boolean).join('\n');
+    const cancellableTasksByButtonId = new Map();
+    tasks.forEach((task) => {
+        if (!canCancelTask(task)) {
+            return;
+        }
+        cancellableTasksByButtonId.set(`cancel-task-${task.id}`, task);
+    });
+    const tableMarkdown = buildTaskTable({ tasks });
+    const markdown = combinedNotice
+        ? `${combinedNotice}\n\n${tableMarkdown}`
+        : tableMarkdown;
+    const segments = splitTablesFromMarkdown(markdown, {
+        resolveButtonCustomId: ({ button }) => {
+            const task = cancellableTasksByButtonId.get(button.id);
+            if (!task) {
+                return new Error(`No task registered for button ${button.id}`);
+            }
+            const actionId = registerHtmlAction({
+                ownerKey,
+                threadId: String(task.id),
+                run: async ({ interaction }) => {
+                    await handleCancelTaskAction({
+                        interaction,
+                        taskId: task.id,
+                        showAll,
+                    });
+                },
+            });
+            return buildHtmlActionCustomId(actionId);
+        },
+    });
+    const components = segments.flatMap((segment) => {
+        if (segment.type === 'components') {
+            return segment.components;
+        }
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: segment.text,
+        };
+        return [textDisplay];
+    });
+    await editReply({
+        components,
+        flags: MessageFlags.IsComponentsV2,
+    });
+}
+async function handleCancelTaskAction({ interaction, taskId, showAll, }) {
+    const guildId = interaction.guildId;
+    if (!guildId) {
+        await interaction.editReply({
+            components: [
+                {
+                    type: ComponentType.TextDisplay,
+                    content: 'This action can only be used in a server.',
+                },
+            ],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const cancelled = await cancelScheduledTask(taskId);
+    const notice = cancelled
+        ? `Cancelled task #${taskId}.`
+        : `Task #${taskId} not found or already finalized.`;
+    await renderTasksReply({
+        guildId,
+        userId: interaction.user.id,
+        channelId: interaction.channelId,
+        showAll,
+        notice,
+        editReply: (options) => {
+            return interaction.editReply(options);
+        },
+    });
+}
+export async function handleTasksCommand({ command, }) {
+    const guildId = command.guildId;
+    if (!guildId) {
+        await command.reply({
+            content: 'This command can only be used in a server.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const showAll = command.options.getBoolean('all') ?? false;
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    await renderTasksReply({
+        guildId,
+        userId: command.user.id,
+        channelId: command.channelId,
+        showAll,
+        editReply: (options) => {
+            return command.editReply(options);
+        },
+    });
+}

package/dist/commands/types.js

@@ -0,0 +1,2 @@
+// Shared types for command handlers.
+export {};

package/dist/commands/undo-redo.js

@@ -0,0 +1,305 @@
+// Undo/Redo commands - /undo, /redo
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.UNDO_REDO);
+async function waitForSessionIdle({ client, sessionId, directory, timeoutMs = 2_000, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const statusResponse = await client.session.status({ directory });
+        const sessionStatus = statusResponse.data?.[sessionId];
+        if (!sessionStatus || sessionStatus.type === 'idle') {
+            return;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 50);
+        });
+    }
+}
+export async function handleUndoCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory, workingDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to undo: ${getClient.message}`);
+        return;
+    }
+    try {
+        const client = getClient();
+        // Fetch session to check existing revert state
+        const sessionResponse = await client.session.get({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (sessionResponse.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(sessionResponse.error)}`);
+            return;
+        }
+        // Abort if session is busy before reverting, matching TUI behavior
+        // (use-session-commands.tsx always aborts non-idle sessions before revert).
+        // session.status() returns a sparse map — only non-idle sessions have entries,
+        // so a missing key means idle.
+        const statusResponse = await client.session.status({
+            directory: workingDirectory,
+        });
+        const sessionStatus = statusResponse.data?.[sessionId];
+        if (sessionStatus && sessionStatus.type !== 'idle') {
+            await client.session.abort({
+                sessionID: sessionId,
+                directory: workingDirectory,
+            }).catch((error) => {
+                logger.warn(`[UNDO] abort failed for ${sessionId}`, error);
+            });
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+        }
+        const messagesResponse = await client.session.messages({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (messagesResponse.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(messagesResponse.error)}`);
+            return;
+        }
+        if (!messagesResponse.data || messagesResponse.data.length === 0) {
+            await command.editReply('No messages to undo');
+            return;
+        }
+        // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
+        // find the last user message that is before the current revert point
+        // (or the last user message if no revert is active). This matches the
+        // TUI's `findLast(userMessages(), (x) => !revert || x.id < revert)`.
+        const currentRevert = sessionResponse.data?.revert?.messageID;
+        const userMessages = messagesResponse.data.filter((m) => {
+            return m.info.role === 'user';
+        });
+        const targetUserMessage = [...userMessages].reverse().find((m) => {
+            return !currentRevert || m.info.id < currentRevert;
+        });
+        if (!targetUserMessage) {
+            await command.editReply('No messages to undo');
+            return;
+        }
+        const targetAssistantMessage = [...messagesResponse.data].reverse().find((m) => {
+            return m.info.role === 'assistant' && m.info.parentID === targetUserMessage.info.id;
+        });
+        const revertMessageId = targetAssistantMessage?.info.id || targetUserMessage.info.id;
+        // session.revert() reverts filesystem patches (file edits, writes) and
+        // marks the session with revert.messageID. Messages are NOT deleted — they
+        // get cleaned up automatically on the next promptAsync() call via
+        // SessionRevert.cleanup(). The model only sees messages before the revert
+        // point when processing the next prompt.
+        logger.log(`[UNDO] session.revert start messageId=${revertMessageId}`);
+        let response = await client.session.revert({
+            sessionID: sessionId,
+            directory: workingDirectory,
+            messageID: revertMessageId,
+        });
+        logger.log(`[UNDO] session.revert done error=${Boolean(response.error)}`);
+        if (response.error) {
+            logger.log('[UNDO] retry wait idle before revert retry');
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+            logger.log('[UNDO] retry revert start');
+            response = await client.session.revert({
+                sessionID: sessionId,
+                directory: workingDirectory,
+                messageID: revertMessageId,
+            });
+            logger.log(`[UNDO] retry revert done error=${Boolean(response.error)}`);
+            if (response.error) {
+                await command.editReply(`Failed to undo: ${JSON.stringify(response.error)}`);
+                return;
+            }
+        }
+        const diffInfo = response.data?.revert?.diff
+            ? `\n\`\`\`diff\n${response.data.revert.diff.slice(0, 1500)}\n\`\`\``
+            : '';
+        await command.editReply(`Undone - reverted last assistant message${diffInfo}`);
+        logger.log(`Session ${sessionId} reverted at message ${revertMessageId}`);
+    }
+    catch (error) {
+        logger.error('[UNDO] Error:', error);
+        await command.editReply(`Failed to undo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRedoCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory, workingDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to redo: ${getClient.message}`);
+        return;
+    }
+    try {
+        const client = getClient();
+        // Fetch session to check existing revert state
+        const sessionResponse = await client.session.get({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (sessionResponse.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(sessionResponse.error)}`);
+            return;
+        }
+        const revertMessageID = sessionResponse.data?.revert?.messageID;
+        if (!revertMessageID) {
+            await command.editReply('Nothing to redo - no previous undo found');
+            return;
+        }
+        // Abort if session is busy before reverting/unreverting — both enforce
+        // assertNotBusy in OpenCode and would fail with "Session is busy"
+        const redoStatusResponse = await client.session.status({
+            directory: workingDirectory,
+        });
+        const redoSessionStatus = redoStatusResponse.data?.[sessionId];
+        if (redoSessionStatus && redoSessionStatus.type !== 'idle') {
+            await client.session.abort({
+                sessionID: sessionId,
+                directory: workingDirectory,
+            }).catch((error) => {
+                logger.warn(`[REDO] abort failed for ${sessionId}`, error);
+            });
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 500);
+        });
+        // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
+        // find the next user message after the current revert point. If one exists,
+        // move the revert cursor forward to it (one step redo). If none exists,
+        // fully unrevert — we're at the end of the message history.
+        const messagesResponse = await client.session.messages({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (messagesResponse.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(messagesResponse.error)}`);
+            return;
+        }
+        const userMessages = (messagesResponse.data ?? []).filter((m) => {
+            return m.info.role === 'user';
+        });
+        const nextMessage = userMessages.find((m) => {
+            return m.info.id > revertMessageID;
+        });
+        if (!nextMessage) {
+            // No more messages after revert point — fully unrevert
+            const response = await client.session.unrevert({
+                sessionID: sessionId,
+                directory: workingDirectory,
+            });
+            if (response.error) {
+                await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
+                return;
+            }
+            await command.editReply('Restored - session fully back to previous state');
+            logger.log(`Session ${sessionId} unrevert completed`);
+            return;
+        }
+        // Move revert cursor forward one step to the next user message
+        const response = await client.session.revert({
+            sessionID: sessionId,
+            directory: workingDirectory,
+            messageID: nextMessage.info.id,
+        });
+        if (response.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
+            return;
+        }
+        await command.editReply('Restored one step forward');
+        logger.log(`Session ${sessionId} redo: moved revert to ${nextMessage.info.id}`);
+    }
+    catch (error) {
+        logger.error('[REDO] Error:', error);
+        await command.editReply(`Failed to redo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/unset-model.js

@@ -0,0 +1,138 @@
+// /unset-model-override command - Remove model overrides and use default instead.
+import { ChatInputCommandInteraction, ChannelType, MessageFlags, } from 'discord.js';
+import { getChannelModel, getSessionModel, getThreadSession, clearSessionModel, } from '../database.js';
+import { getPrisma } from '../db.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { getRuntime } from '../session-handler/thread-session-runtime.js';
+import { getCurrentModelInfo } from './model.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const unsetModelLogger = createLogger(LogPrefix.MODEL);
+function formatModelSource(type, agentName) {
+    switch (type) {
+        case 'session':
+            return 'session override';
+        case 'agent':
+            return `agent "${agentName}"`;
+        case 'channel':
+            return 'channel override';
+        case 'global':
+            return 'global default';
+        case 'opencode-config':
+        case 'opencode-recent':
+        case 'opencode-provider-default':
+            return 'opencode default';
+        default:
+            return 'none';
+    }
+}
+/**
+ * Handle the /unset-model-override slash command.
+ * In thread: clears session override if exists, otherwise channel override.
+ * In channel: clears channel override.
+ */
+export async function handleUnsetModelCommand({ interaction, appId, }) {
+    unsetModelLogger.log('[UNSET-MODEL] handleUnsetModelCommand called');
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let targetChannelId;
+    let sessionId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = await getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        targetChannelId = textChannel?.id || channel.id;
+        sessionId = await getThreadSession(thread.id);
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = await getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
+        return;
+    }
+    // Check what overrides exist
+    const [sessionPref, channelPref] = await Promise.all([
+        sessionId ? getSessionModel(sessionId) : Promise.resolve(undefined),
+        getChannelModel(targetChannelId),
+    ]);
+    let clearedType = null;
+    let clearedModel;
+    if (isThread && sessionId && sessionPref) {
+        // In thread with session override: clear session
+        await clearSessionModel(sessionId);
+        clearedType = 'session';
+        clearedModel = sessionPref.modelId;
+        unsetModelLogger.log(`[UNSET-MODEL] Cleared session model for ${sessionId}`);
+    }
+    else if (channelPref) {
+        // Clear channel override
+        const prisma = await getPrisma();
+        await prisma.channel_models.deleteMany({
+            where: { channel_id: targetChannelId },
+        });
+        clearedType = 'channel';
+        clearedModel = channelPref.modelId;
+        unsetModelLogger.log(`[UNSET-MODEL] Cleared channel model for ${targetChannelId}`);
+    }
+    else {
+        await interaction.editReply({
+            content: 'No model override to clear.',
+        });
+        return;
+    }
+    // Get the new model that will be used
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    let newModelText = 'unknown';
+    if (!(getClient instanceof Error)) {
+        const newModelInfo = await getCurrentModelInfo({
+            sessionId,
+            channelId: targetChannelId,
+            appId,
+            getClient,
+        });
+        newModelText =
+            newModelInfo.type === 'none'
+                ? 'none'
+                : `\`${newModelInfo.model}\` (${formatModelSource(newModelInfo.type, 'agentName' in newModelInfo ? newModelInfo.agentName : undefined)})`;
+    }
+    // Check if there's a running request and abort+retry with new model (only for session changes in threads)
+    let retried = false;
+    if (isThread && clearedType === 'session' && sessionId) {
+        const runtime = getRuntime(channel.id);
+        if (runtime) {
+            retried = await runtime.retryLastUserPrompt();
+        }
+    }
+    const clearedTypeText = clearedType === 'session' ? 'Session' : 'Channel';
+    const retriedText = retried
+        ? '\n_Restarting current request with new model..._'
+        : '';
+    await interaction.editReply({
+        content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}${retriedText}`,
+    });
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,42 @@
+// /upgrade-and-restart command - Upgrade kimaki to the latest version and restart the bot.
+// Checks npm for a newer version, installs it globally, then spawns a new kimaki process.
+// The new process kills the old one on startup (kimaki's single-instance lock).
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { getCurrentVersion, upgrade } from '../upgrade.js';
+import { spawn } from 'node:child_process';
+const logger = createLogger(LogPrefix.CLI);
+export async function handleUpgradeAndRestartCommand({ command, }) {
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    logger.log('[UPGRADE] /upgrade-and-restart triggered');
+    try {
+        const currentVersion = getCurrentVersion();
+        const newVersion = await upgrade();
+        if (!newVersion) {
+            await command.editReply({
+                content: `Already on latest version: **v${currentVersion}**`,
+            });
+            return;
+        }
+        await command.editReply({
+            content: `Upgraded kimaki **v${currentVersion}** -> **v${newVersion}**. Restarting bot...`,
+        });
+        // Spawning bare `kimaki` works even if the user originally ran via npx/bunx:
+        // `npm i -g kimaki@latest` creates a global bin link, and npx resolves
+        // local -> global -> cache -> registry, so it prefers the global install.
+        // bunx shares the same global cache, so it also picks up the new version.
+        const child = spawn('kimaki', process.argv.slice(2), {
+            shell: true,
+            stdio: 'ignore',
+            detached: true,
+        });
+        child.unref();
+        logger.debug('Started new background kimaki');
+    }
+    catch (error) {
+        logger.error('[UPGRADE] Failed:', error);
+        await command.editReply({
+            content: `Upgrade failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}