@grinev/opencode-telegram-bot 0.16.0 → 0.17.0

package/dist/bot/commands/worktree.js

@@ -0,0 +1,196 @@
+import { InlineKeyboard } from "grammy";
+import { config } from "../../config.js";
+import { getGitWorktreeContext } from "../../git/worktree.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { getProjectByWorktree } from "../../project/manager.js";
+import { upsertSessionDirectory } from "../../session/cache-manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
+import { switchToProject } from "../utils/switch-project.js";
+import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
+import { buildProjectButtonLabel, calculateProjectsPaginationRange } from "./projects.js";
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+const WORKTREE_CALLBACK_PREFIX = "worktree:";
+const WORKTREE_PAGE_CALLBACK_PREFIX = "worktree:page:";
+function formatWorktreeButtonLabel(label, isActive) {
+    const prefix = isActive ? "✅ " : "";
+    const availableLength = MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length;
+    if (label.length <= availableLength) {
+        return `${prefix}${label}`;
+    }
+    return `${prefix}${label.slice(0, Math.max(0, availableLength - 3))}...`;
+}
+function buildWorktreeButtonLabel(index, entry) {
+    return buildProjectButtonLabel(index, entry.path);
+}
+function parseWorktreePageCallback(data) {
+    if (!data.startsWith(WORKTREE_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(WORKTREE_PAGE_CALLBACK_PREFIX.length);
+    if (!/^\d+$/.test(rawPage)) {
+        return null;
+    }
+    return Number.parseInt(rawPage, 10);
+}
+function parseWorktreeIndexCallback(data) {
+    if (!data.startsWith(WORKTREE_CALLBACK_PREFIX) ||
+        data.startsWith(WORKTREE_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawIndex = data.slice(WORKTREE_CALLBACK_PREFIX.length);
+    if (!/^\d+$/.test(rawIndex)) {
+        return null;
+    }
+    return Number.parseInt(rawIndex, 10);
+}
+function buildWorktreeMenuText(page, totalPages) {
+    const baseText = t("worktree.select_with_current");
+    if (totalPages <= 1) {
+        return baseText;
+    }
+    return `${baseText}\n\n${t("projects.page_indicator", {
+        current: String(page + 1),
+        total: String(totalPages),
+    })}`;
+}
+function buildWorktreeKeyboard(worktrees, page) {
+    const keyboard = new InlineKeyboard();
+    const pageSize = config.bot.projectsListLimit;
+    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateProjectsPaginationRange(worktrees.length, page, pageSize);
+    worktrees.slice(startIndex, endIndex).forEach((entry, index) => {
+        const label = buildWorktreeButtonLabel(startIndex + index, entry);
+        keyboard
+            .text(formatWorktreeButtonLabel(label, entry.isCurrent), `${WORKTREE_CALLBACK_PREFIX}${startIndex + index}`)
+            .row();
+    });
+    if (totalPages > 1) {
+        if (normalizedPage > 0) {
+            keyboard.text(t("projects.prev_page"), `${WORKTREE_PAGE_CALLBACK_PREFIX}${normalizedPage - 1}`);
+        }
+        if (normalizedPage < totalPages - 1) {
+            keyboard.text(t("projects.next_page"), `${WORKTREE_PAGE_CALLBACK_PREFIX}${normalizedPage + 1}`);
+        }
+    }
+    return keyboard;
+}
+function buildWorktreeMenuView(worktrees, page) {
+    const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(worktrees.length, page, config.bot.projectsListLimit);
+    return {
+        text: buildWorktreeMenuText(normalizedPage, totalPages),
+        keyboard: buildWorktreeKeyboard(worktrees, normalizedPage),
+    };
+}
+async function loadCurrentWorktreeContext() {
+    const currentProject = getCurrentProject();
+    if (!currentProject) {
+        return { currentProject: null, context: null };
+    }
+    const context = await getGitWorktreeContext(currentProject.worktree);
+    return { currentProject, context };
+}
+export async function worktreeCommand(ctx) {
+    try {
+        if (isForegroundBusy()) {
+            await replyBusyBlocked(ctx);
+            return;
+        }
+        const { currentProject, context } = await loadCurrentWorktreeContext();
+        if (!currentProject) {
+            await ctx.reply(t("worktree.project_not_selected"));
+            return;
+        }
+        if (!context) {
+            await ctx.reply(t("worktree.not_git_repo"));
+            return;
+        }
+        if (context.worktrees.length === 0) {
+            await ctx.reply(t("worktree.empty"));
+            return;
+        }
+        const { text, keyboard } = buildWorktreeMenuView(context.worktrees, 0);
+        await replyWithInlineMenu(ctx, {
+            menuKind: "worktree",
+            text,
+            keyboard,
+        });
+    }
+    catch (error) {
+        logger.error("[Bot] Error loading worktrees:", error);
+        await ctx.reply(t("worktree.fetch_error"));
+    }
+}
+export async function handleWorktreeCallback(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith(WORKTREE_CALLBACK_PREFIX)) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    const page = parseWorktreePageCallback(callbackQuery.data);
+    const index = parseWorktreeIndexCallback(callbackQuery.data);
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "worktree");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        const { currentProject, context } = await loadCurrentWorktreeContext();
+        if (!currentProject) {
+            clearAllInteractionState("worktree_project_missing");
+            await ctx.answerCallbackQuery();
+            await ctx.reply(t("worktree.project_not_selected"));
+            return true;
+        }
+        if (!context) {
+            clearAllInteractionState("worktree_git_context_missing");
+            await ctx.answerCallbackQuery({ text: t("worktree.not_git_repo_callback") });
+            return true;
+        }
+        if (page !== null) {
+            if (context.worktrees.length === 0) {
+                await ctx.answerCallbackQuery({ text: t("worktree.page_empty_callback") });
+                return true;
+            }
+            const { text, keyboard } = buildWorktreeMenuView(context.worktrees, page);
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "worktree"),
+            });
+            return true;
+        }
+        if (index === null) {
+            await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+            return true;
+        }
+        const selectedWorktree = context.worktrees[index];
+        if (!selectedWorktree) {
+            await ctx.answerCallbackQuery({ text: t("worktree.selection_missing_callback") });
+            return true;
+        }
+        if (selectedWorktree.isCurrent) {
+            await ctx.answerCallbackQuery({ text: t("worktree.already_selected_callback") });
+            return true;
+        }
+        logger.info(`[Bot] Worktree selected: ${selectedWorktree.path}`);
+        await upsertSessionDirectory(selectedWorktree.path, Date.now());
+        const projectInfo = await getProjectByWorktree(selectedWorktree.path);
+        const replyKeyboard = await switchToProject(ctx, { ...projectInfo, name: selectedWorktree.path }, "worktree_switched");
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("worktree.selected", { worktree: selectedWorktree.path }), {
+            reply_markup: replyKeyboard,
+        });
+        await ctx.deleteMessage();
+        return true;
+    }
+    catch (error) {
+        logger.error("[Bot] Error handling worktree callback:", error);
+        clearAllInteractionState("worktree_select_error");
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        await ctx.reply(t("worktree.select_error"));
+        return true;
+    }
+}

package/dist/bot/handlers/inline-menu.js

@@ -11,6 +11,7 @@ const INLINE_MENU_KINDS = [
     "variant",
     "context",
     "open",
+    "worktree",
 ];
 function isInlineMenuKind(value) {
     return INLINE_MENU_KINDS.includes(value);

package/dist/bot/handlers/voice.js

@@ -156,8 +156,15 @@ export async function handleVoiceMessage(ctx, deps) {
             logger.warn("[Voice] Failed to edit status message with recognized text:", editError);
         }
         logger.info(`[Voice] Transcribed audio: ${recognizedText.length} chars`);
+        let textForLLM = recognizedText;
+        const notePrompt = config.stt.notePrompt.trim();
+        if (notePrompt && notePrompt.toLowerCase() !== "false" && notePrompt !== "0") {
+            const llmNote = `[Note: ${notePrompt}]`;
+            logger.debug(`[Voice] Added STT note to LLM prompt: ${llmNote}`);
+            textForLLM = `${llmNote}\n${recognizedText}`;
+        }
         // Process the recognized text as a prompt
-        await processPrompt(ctx, recognizedText, deps);
+        await processPrompt(ctx, textForLLM, deps);
     }
     catch (err) {
         const errorMessage = err instanceof Error ? err.message : "unknown error";

package/dist/bot/index.js

@@ -16,6 +16,7 @@ import { AGENT_MODE_BUTTON_TEXT_PATTERN, MODEL_BUTTON_TEXT_PATTERN, VARIANT_BUTT
 import { sessionsCommand, handleSessionSelect } from "./commands/sessions.js";
 import { newCommand } from "./commands/new.js";
 import { projectsCommand, handleProjectSelect } from "./commands/projects.js";
+import { worktreeCommand, handleWorktreeCallback } from "./commands/worktree.js";
 import { openCommand, handleOpenCallback, clearOpenPathIndex } from "./commands/open.js";
 import { abortCommand } from "./commands/abort.js";
 import { opencodeStartCommand } from "./commands/opencode-start.js";
@@ -24,6 +25,7 @@ import { renameCommand, handleRenameCancel, handleRenameTextAnswer } from "./com
 import { handleTaskCallback, handleTaskTextInput, taskCommand } from "./commands/task.js";
 import { handleTaskListCallback, taskListCommand } from "./commands/tasklist.js";
 import { commandsCommand, handleCommandsCallback, handleCommandTextArguments, } from "./commands/commands.js";
+import { skillsCommand, handleSkillsCallback, handleSkillTextArguments, } from "./commands/skills.js";
 import { ttsCommand } from "./commands/tts.js";
 import { handleQuestionCallback, showCurrentQuestion, handleQuestionTextAnswer, } from "./handlers/question.js";
 import { handlePermissionCallback, showPermissionRequest } from "./handlers/permission.js";
@@ -36,7 +38,7 @@ import { questionManager } from "../question/manager.js";
 import { interactionManager } from "../interaction/manager.js";
 import { clearAllInteractionState } from "../interaction/cleanup.js";
 import { keyboardManager } from "../keyboard/manager.js";
-import { subscribeToEvents } from "../opencode/events.js";
+import { stopEventListening, subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
 import { formatToolInfo } from "../summary/formatter.js";
 import { renderSubagentCards } from "../summary/subagent-formatter.js";
@@ -68,6 +70,7 @@ import { prepareAssistantFinalStreamingPayload, prepareAssistantStreamingPayload
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
+let heartbeatTimer = null;
 const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
 const RESPONSE_STREAM_THROTTLE_MS = config.bot.responseStreamThrottleMs;
 const RESPONSE_STREAM_TEXT_LIMIT = 3800;
@@ -442,6 +445,9 @@ async function ensureEventSubscription(directory) {
         if (!currentSession || currentSession.id !== fileInfo.sessionId) {
             return;
         }
+        if (config.bot.hideToolFileMessages) {
+            return;
+        }
         try {
             await toolCallStreamer.breakSession(fileInfo.sessionId, "tool_file_boundary");
             const toolMessage = formatToolInfo(fileInfo);
@@ -718,6 +724,10 @@ export function createBot() {
     clearAllInteractionState("bot_startup");
     sessionCompletionTasks.clear();
     assistantRunState.clearAll("bot_startup");
+    if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+    }
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;
@@ -740,7 +750,7 @@ export function createBot() {
     const bot = new Bot(config.telegram.token, botOptions);
     // Heartbeat for diagnostics: verify the event loop is not blocked
     let heartbeatCounter = 0;
-    setInterval(() => {
+    heartbeatTimer = setInterval(() => {
         heartbeatCounter++;
         if (heartbeatCounter % 6 === 0) {
             // Log every 30 seconds (5 sec * 6)
@@ -793,6 +803,7 @@ export function createBot() {
     bot.command("opencode_start", opencodeStartCommand);
     bot.command("opencode_stop", opencodeStopCommand);
     bot.command("projects", projectsCommand);
+    bot.command("worktree", worktreeCommand);
     bot.command("open", openCommand);
     bot.command("sessions", sessionsCommand);
     bot.command("new", newCommand);
@@ -801,6 +812,7 @@ export function createBot() {
     bot.command("tasklist", taskListCommand);
     bot.command("rename", renameCommand);
     bot.command("commands", commandsCommand);
+    bot.command("skills", skillsCommand);
     bot.on("message:text", unknownCommandMiddleware);
     bot.on("callback_query:data", async (ctx) => {
         logger.debug(`[Bot] Received callback_query:data: ${ctx.callbackQuery?.data}`);
@@ -817,6 +829,7 @@ export function createBot() {
             }
             const handledSession = await handleSessionSelect(ctx);
             const handledProject = await handleProjectSelect(ctx);
+            const handledWorktree = await handleWorktreeCallback(ctx);
             const handledOpen = await handleOpenCallback(ctx);
             const handledQuestion = await handleQuestionCallback(ctx);
             const handledPermission = await handlePermissionCallback(ctx);
@@ -828,10 +841,12 @@ export function createBot() {
             const handledTaskList = await handleTaskListCallback(ctx);
             const handledRenameCancel = await handleRenameCancel(ctx);
             const handledCommands = await handleCommandsCallback(ctx, { bot, ensureEventSubscription });
-            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}`);
+            const handledSkills = await handleSkillsCallback(ctx, { bot, ensureEventSubscription });
+            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, skills=${handledSkills}`);
             if (!handledInlineCancel &&
                 !handledSession &&
                 !handledProject &&
+                !handledWorktree &&
                 !handledOpen &&
                 !handledQuestion &&
                 !handledPermission &&
@@ -842,7 +857,8 @@ export function createBot() {
                 !handledTask &&
                 !handledTaskList &&
                 !handledRenameCancel &&
-                !handledCommands) {
+                !handledCommands &&
+                !handledSkills) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
                 await ctx.answerCallbackQuery({ text: t("callback.unknown_command") });
             }
@@ -1041,6 +1057,10 @@ export function createBot() {
         if (handledCommandArgs) {
             return;
         }
+        const handledSkillArgs = await handleSkillTextArguments(ctx, promptDeps);
+        if (handledSkillArgs) {
+            return;
+        }
         await processUserPrompt(ctx, text, promptDeps);
         logger.debug("[Bot] message:text handler completed (prompt sent in background)");
     });
@@ -1053,3 +1073,18 @@ export function createBot() {
     });
     return bot;
 }
+export function cleanupBotRuntime(reason) {
+    stopEventListening();
+    summaryAggregator.clear();
+    responseStreamer.clearAll(reason);
+    toolCallStreamer.clearAll(reason);
+    toolMessageBatcher.clearAll(reason);
+    sessionCompletionTasks.clear();
+    assistantRunState.clearAll(reason);
+    if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+    }
+    botInstance = null;
+    chatIdInstance = null;
+}

package/dist/cli/args.js

@@ -1,4 +1,11 @@
-import { t } from "../i18n/index.js";
+const CLI_MESSAGES = {
+    unknownCommand: (value) => `Unknown command: ${value}`,
+    modeRequiresValue: "Option --mode requires a value: sources|installed",
+    invalidMode: (value) => `Invalid mode value: ${value}. Expected sources|installed`,
+    unknownOption: (value) => `Unknown option: ${value}`,
+    modeOnlyStart: "Option --mode is supported only for the start command",
+    daemonOnlyStart: "Option --daemon is supported only for the start command",
+};
 const SUPPORTED_COMMANDS = ["start", "status", "stop", "config"];
 function isCliCommand(value) {
     return SUPPORTED_COMMANDS.includes(value);
@@ -16,6 +23,7 @@ export function parseCliArgs(argv) {
     const args = [...argv];
     let command = "start";
     let mode;
+    let daemon = false;
     let showHelp = false;
     let currentIndex = 0;
     const firstArg = args[0];
@@ -23,8 +31,9 @@ export function parseCliArgs(argv) {
         if (!isCliCommand(firstArg)) {
             return {
                 command,
+                daemon,
                 showHelp: true,
-                error: t("cli.args.unknown_command", { value: firstArg }),
+                error: CLI_MESSAGES.unknownCommand(firstArg),
             };
         }
         command = firstArg;
@@ -37,23 +46,30 @@ export function parseCliArgs(argv) {
             currentIndex += 1;
             continue;
         }
+        if (token === "--daemon") {
+            daemon = true;
+            currentIndex += 1;
+            continue;
+        }
         if (token === "--mode") {
             const modeValue = args[currentIndex + 1];
             if (!modeValue || modeValue.startsWith("-")) {
                 return {
                     command,
+                    daemon,
                     mode,
                     showHelp: true,
-                    error: t("cli.args.mode_requires_value"),
+                    error: CLI_MESSAGES.modeRequiresValue,
                 };
             }
             const parsedMode = normalizeMode(modeValue);
             if (!parsedMode) {
                 return {
                     command,
+                    daemon,
                     mode,
                     showHelp: true,
-                    error: t("cli.args.invalid_mode", { value: modeValue }),
+                    error: CLI_MESSAGES.invalidMode(modeValue),
                 };
             }
             mode = parsedMode;
@@ -66,9 +82,10 @@ export function parseCliArgs(argv) {
             if (!parsedMode) {
                 return {
                     command,
+                    daemon,
                     mode,
                     showHelp: true,
-                    error: t("cli.args.invalid_mode", { value: modeValue }),
+                    error: CLI_MESSAGES.invalidMode(modeValue),
                 };
             }
             mode = parsedMode;
@@ -77,21 +94,33 @@ export function parseCliArgs(argv) {
         }
         return {
             command,
+            daemon,
             mode,
             showHelp: true,
-            error: t("cli.args.unknown_option", { value: token }),
+            error: CLI_MESSAGES.unknownOption(token),
         };
     }
     if (command !== "start" && mode) {
         return {
             command,
+            daemon,
+            mode,
+            showHelp: true,
+            error: CLI_MESSAGES.modeOnlyStart,
+        };
+    }
+    if (command !== "start" && daemon) {
+        return {
+            command,
+            daemon,
             mode,
             showHelp: true,
-            error: t("cli.args.mode_only_start"),
+            error: CLI_MESSAGES.daemonOnlyStart,
         };
     }
     return {
         command,
+        daemon,
         mode,
         showHelp,
     };

package/dist/cli.js

@@ -1,10 +1,38 @@
 #!/usr/bin/env node
 import { parseCliArgs } from "./cli/args.js";
 import { resolveRuntimeMode, setRuntimeMode } from "./runtime/mode.js";
-import { t } from "./i18n/index.js";
+import { getRuntimePaths } from "./runtime/paths.js";
 const EXIT_SUCCESS = 0;
 const EXIT_RUNTIME_ERROR = 1;
 const EXIT_INVALID_ARGS = 2;
+const CLI_USAGE = `Usage:
+  opencode-telegram [start] [--daemon] [--mode installed]
+  opencode-telegram status
+  opencode-telegram stop
+  opencode-telegram config
+
+Notes:
+  - No command defaults to start
+  - start runs in foreground by default
+  - --daemon is supported for the installed runtime only`;
+const CLI_MESSAGES = {
+    daemonRequiresInstalled: "Daemon mode is supported only for the installed runtime. Use `opencode-telegram start` for foreground source runs.",
+    unknownServiceError: "Unknown service error.",
+    cleanupStale: "Removed stale daemon state file.",
+    cleanupInvalid: "Removed invalid daemon state file.",
+    startSuccess: "OpenCode Telegram Bot daemon started.",
+    startAlreadyRunning: "OpenCode Telegram Bot daemon is already running.",
+    statusRunning: "Service status: running",
+    statusStopped: "Service status: stopped",
+    stopSuccess: "OpenCode Telegram Bot daemon stopped.",
+    stopAlreadyStopped: "OpenCode Telegram Bot daemon is not running.",
+    linePid: (pid) => `PID: ${pid}`,
+    lineStartedAt: (startedAt) => `Started at: ${startedAt}`,
+    lineUptimeSec: (seconds) => `Uptime: ${seconds} sec`,
+    lineLogFile: (filePath) => `Log file: ${filePath}`,
+    lineAppHome: (appHome) => `App home: ${appHome}`,
+    errorPrefix: (message) => `CLI error: ${message}`,
+};
 function writeStdout(message) {
     process.stdout.write(`${message}\n`);
 }
@@ -12,18 +40,33 @@ function writeStderr(message) {
     process.stderr.write(`${message}\n`);
 }
 function printUsage() {
-    writeStdout(t("cli.usage"));
+    writeStdout(CLI_USAGE);
 }
-function getPlaceholderMessage(command) {
-    if (command === "status") {
-        return t("cli.placeholder.status");
+function formatServiceCleanupMessage(cleanupReason) {
+    if (cleanupReason === "stale") {
+        return CLI_MESSAGES.cleanupStale;
     }
-    if (command === "stop") {
-        return t("cli.placeholder.stop");
+    if (cleanupReason === "invalid") {
+        return CLI_MESSAGES.cleanupInvalid;
     }
-    return t("cli.placeholder.unavailable");
+    return null;
 }
-async function runStartCommand(mode) {
+function formatServiceDetails(details) {
+    const uptimeSec = Math.max(0, Math.floor((Date.now() - Date.parse(details.startedAt)) / 1000));
+    return [
+        CLI_MESSAGES.linePid(details.pid),
+        CLI_MESSAGES.lineStartedAt(details.startedAt),
+        CLI_MESSAGES.lineUptimeSec(uptimeSec),
+        CLI_MESSAGES.lineLogFile(details.logFilePath),
+        CLI_MESSAGES.lineAppHome(details.appHome),
+    ].join("\n");
+}
+function writeOptionalLine(message) {
+    if (message) {
+        writeStdout(message);
+    }
+}
+async function runStartCommand(mode, daemon) {
     const modeResult = resolveRuntimeMode({
         defaultMode: "installed",
         explicitMode: mode,
@@ -32,10 +75,46 @@ async function runStartCommand(mode) {
         throw new Error(modeResult.error);
     }
     setRuntimeMode(modeResult.mode);
-    const { initializeLogger } = await import("./utils/logger.js");
-    await initializeLogger();
+    if (daemon && modeResult.mode !== "installed") {
+        throw new Error(CLI_MESSAGES.daemonRequiresInstalled);
+    }
     const { ensureRuntimeConfigForStart } = await import("./runtime/bootstrap.js");
     await ensureRuntimeConfigForStart();
+    if (daemon) {
+        const { startBotDaemon } = await import("./service/manager.js");
+        const result = await startBotDaemon(modeResult.mode);
+        const cleanupMessage = formatServiceCleanupMessage(result.cleanupReason);
+        const runtimePaths = getRuntimePaths();
+        writeOptionalLine(cleanupMessage);
+        if (!result.success) {
+            if (result.alreadyRunning && result.service) {
+                writeStdout(CLI_MESSAGES.startAlreadyRunning);
+                writeStdout("");
+                writeStdout(formatServiceDetails({
+                    pid: result.service.pid,
+                    startedAt: result.service.startedAt,
+                    logFilePath: result.service.logFilePath,
+                    appHome: runtimePaths.appHome,
+                }));
+                return EXIT_SUCCESS;
+            }
+            throw new Error(result.error || CLI_MESSAGES.unknownServiceError);
+        }
+        if (!result.service) {
+            throw new Error(CLI_MESSAGES.unknownServiceError);
+        }
+        writeStdout(CLI_MESSAGES.startSuccess);
+        writeStdout("");
+        writeStdout(formatServiceDetails({
+            pid: result.service.pid,
+            startedAt: result.service.startedAt,
+            logFilePath: result.service.logFilePath,
+            appHome: runtimePaths.appHome,
+        }));
+        return EXIT_SUCCESS;
+    }
+    const { initializeLogger } = await import("./utils/logger.js");
+    await initializeLogger();
     const { startBotApp } = await import("./app/start-bot-app.js");
     await startBotApp();
     return EXIT_SUCCESS;
@@ -48,8 +127,40 @@ async function runConfigCommand() {
     await runConfigWizardCommand();
     return EXIT_SUCCESS;
 }
-async function runPlaceholderCommand(command) {
-    writeStdout(getPlaceholderMessage(command));
+async function runStatusCommand() {
+    setRuntimeMode("installed");
+    const { getBotServiceStatus } = await import("./service/manager.js");
+    const runtimePaths = getRuntimePaths();
+    const status = await getBotServiceStatus();
+    writeOptionalLine(formatServiceCleanupMessage(status.cleanupReason));
+    if (status.status !== "running" || !status.service) {
+        writeStdout(CLI_MESSAGES.statusStopped);
+        writeStdout(CLI_MESSAGES.lineAppHome(runtimePaths.appHome));
+        return EXIT_SUCCESS;
+    }
+    writeStdout(CLI_MESSAGES.statusRunning);
+    writeStdout("");
+    writeStdout(formatServiceDetails({
+        pid: status.service.pid,
+        startedAt: status.service.startedAt,
+        logFilePath: status.service.logFilePath,
+        appHome: runtimePaths.appHome,
+    }));
+    return EXIT_SUCCESS;
+}
+async function runStopCommand() {
+    setRuntimeMode("installed");
+    const { stopBotDaemon } = await import("./service/manager.js");
+    const result = await stopBotDaemon();
+    writeOptionalLine(formatServiceCleanupMessage(result.cleanupReason));
+    if (!result.success) {
+        throw new Error(result.error || CLI_MESSAGES.unknownServiceError);
+    }
+    if (result.alreadyStopped) {
+        writeStdout(CLI_MESSAGES.stopAlreadyStopped);
+        return EXIT_SUCCESS;
+    }
+    writeStdout(CLI_MESSAGES.stopSuccess);
     return EXIT_SUCCESS;
 }
 async function runCli(argv) {
@@ -62,12 +173,15 @@ async function runCli(argv) {
         return parsedArgs.error ? EXIT_INVALID_ARGS : EXIT_SUCCESS;
     }
     if (parsedArgs.command === "start") {
-        return runStartCommand(parsedArgs.mode);
+        return runStartCommand(parsedArgs.mode, parsedArgs.daemon);
     }
     if (parsedArgs.command === "config") {
         return runConfigCommand();
     }
-    return runPlaceholderCommand(parsedArgs.command);
+    if (parsedArgs.command === "status") {
+        return runStatusCommand();
+    }
+    return runStopCommand();
 }
 void runCli(process.argv.slice(2))
     .then((exitCode) => {
@@ -75,10 +189,10 @@ void runCli(process.argv.slice(2))
 })
     .catch((error) => {
     if (error instanceof Error) {
-        writeStderr(t("cli.error.prefix", { message: error.message }));
+        writeStderr(CLI_MESSAGES.errorPrefix(error.message));
     }
     else {
-        writeStderr(t("cli.error.prefix", { message: String(error) }));
+        writeStderr(CLI_MESSAGES.errorPrefix(String(error)));
     }
     process.exitCode = EXIT_RUNTIME_ERROR;
 });