@grinev/opencode-telegram-bot 0.21.1 → 0.21.2

package/dist/{bot/utils/external-user-input.js → app/services/external-user-input-service.js}

@@ -1,7 +1,9 @@
 import { t } from "../../i18n/index.js";
-import { escapePlainTextForTelegramMarkdownV2 } from "../../summary/formatter.js";
-import { sendBotText } from "./telegram-text.js";
 const EXTERNAL_USER_INPUT_MAX_DISPLAY_LENGTH = 2000;
+const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
+function escapePlainTextForTelegramMarkdownV2(text) {
+    return text.replace(MARKDOWN_V2_RESERVED_CHARS, "\\$1");
+}
 function normalizeExternalUserInputText(text) {
     return text.replace(/\r\n/g, "\n").trim();
 }
@@ -35,20 +37,3 @@ export function buildExternalUserInputNotification(text) {
         rawFallbackText: `${title}\n\n${buildQuotedPlainText(displayText)}`,
     };
 }
-export async function deliverExternalUserInputNotification({ api, chatId, currentSessionId, sessionId, text, consumeSuppressedInput, }) {
-    const notification = buildExternalUserInputNotification(text);
-    if (!notification || currentSessionId !== sessionId) {
-        return false;
-    }
-    if (consumeSuppressedInput(sessionId, text)) {
-        return false;
-    }
-    await sendBotText({
-        api,
-        chatId,
-        text: notification.text,
-        rawFallbackText: notification.rawFallbackText,
-        format: "markdown_v2",
-    });
-    return true;
-}

package/dist/app/services/file-browser-service.js

@@ -0,0 +1,265 @@
+import { promises as fs } from "node:fs";
+import { realpath } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { t } from "../../i18n/index.js";
+import { getCurrentProject } from "../stores/settings-store.js";
+import { logger } from "../../utils/logger.js";
+export const MAX_ENTRIES_PER_PAGE = 8;
+let resolvedRoots = null;
+export function getHomeDirectory() {
+    return os.homedir();
+}
+export function pathToDisplayPath(absolutePath) {
+    const home = getHomeDirectory();
+    if (absolutePath === home) {
+        return "~";
+    }
+    if (absolutePath.startsWith(home + path.sep)) {
+        return "~" + absolutePath.slice(home.length);
+    }
+    return absolutePath;
+}
+export async function scanDirectory(dirPath, page = 0) {
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        const subdirs = [];
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                subdirs.push({
+                    name: entry.name,
+                    fullPath: path.join(dirPath, entry.name),
+                });
+            }
+        }
+        subdirs.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" }));
+        const parentPath = path.dirname(dirPath);
+        const hasParent = dirPath !== path.parse(dirPath).root;
+        const totalPages = Math.max(1, Math.ceil(subdirs.length / MAX_ENTRIES_PER_PAGE));
+        const safePage = Math.max(0, Math.min(page, totalPages - 1));
+        const start = safePage * MAX_ENTRIES_PER_PAGE;
+        return {
+            entries: subdirs.slice(start, start + MAX_ENTRIES_PER_PAGE),
+            totalCount: subdirs.length,
+            page: safePage,
+            currentPath: dirPath,
+            displayPath: pathToDisplayPath(dirPath),
+            hasParent,
+            parentPath: hasParent ? parentPath : null,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error) {
+            const code = error.code;
+            if (code === "ENOENT" || code === "ELOOP") {
+                return { error: `Directory not found: ${dirPath}`, code: "ENOENT" };
+            }
+            if (code === "EACCES" || code === "EPERM") {
+                return { error: `Permission denied: ${dirPath}`, code: "EACCES" };
+            }
+            if (code === "ENOTDIR") {
+                return { error: `Not a directory: ${dirPath}`, code: "ENOTDIR" };
+            }
+        }
+        return {
+            error: error instanceof Error ? error.message : "Unknown error",
+            code: "UNKNOWN",
+        };
+    }
+}
+export function buildEntryLabel(entry) {
+    return `📁 ${entry.name}`;
+}
+export function buildTreeHeader(displayPath, totalCount, page, totalPages) {
+    let header = `📂 ${displayPath}`;
+    if (totalPages > 1) {
+        header += `  (${page + 1}/${totalPages})`;
+    }
+    if (totalCount === 0) {
+        header += `\n${t("open.no_subfolders")}`;
+    }
+    else if (totalCount === 1) {
+        header += `\n${t("open.subfolder_count", { count: String(totalCount) })}`;
+    }
+    else {
+        header += `\n${t("open.subfolders_count", { count: String(totalCount) })}`;
+    }
+    return header;
+}
+export function isScanError(result) {
+    return "error" in result;
+}
+function isWindows() {
+    return process.platform === "win32";
+}
+function expandTilde(p) {
+    if (p === "~") {
+        return os.homedir();
+    }
+    if (p.startsWith("~/") || p.startsWith("~\\")) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    return p;
+}
+function resolveConfiguredPath(p) {
+    return path.resolve(expandTilde(p));
+}
+function normalizePath(p) {
+    const resolved = resolveConfiguredPath(p);
+    return isWindows() ? resolved.toLowerCase() : resolved;
+}
+export function initBrowserRoots(raw) {
+    if (!raw || raw.trim() === "") {
+        resolvedRoots = [resolveConfiguredPath(os.homedir())];
+        logger.debug(`[BrowserRoots] No OPEN_BROWSER_ROOTS configured, defaulting to home: ${resolvedRoots[0]}`);
+        return;
+    }
+    const entries = raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    const roots = entries.map((entry) => resolveConfiguredPath(entry));
+    if (roots.length === 0) {
+        resolvedRoots = [resolveConfiguredPath(os.homedir())];
+        logger.warn("[BrowserRoots] All configured roots were invalid, falling back to home directory");
+    }
+    else {
+        resolvedRoots = roots;
+        logger.info(`[BrowserRoots] Configured roots: ${roots.join(", ")}`);
+    }
+}
+export function getBrowserRoots() {
+    if (resolvedRoots === null) {
+        initBrowserRoots(process.env.OPEN_BROWSER_ROOTS);
+    }
+    return resolvedRoots;
+}
+export function getBrowserRootPaths() {
+    return getBrowserRoots();
+}
+export function isWithinAllowedRoot(targetPath) {
+    const normalizedTarget = normalizePath(targetPath);
+    for (const root of getBrowserRoots()) {
+        const normalizedRoot = normalizePath(root);
+        if (normalizedTarget === normalizedRoot) {
+            return true;
+        }
+        if (normalizedTarget.startsWith(normalizedRoot + "/") ||
+            normalizedTarget.startsWith(normalizedRoot + "\\")) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function isWithinAllowedRootSafe(targetPath) {
+    let resolved = targetPath;
+    try {
+        resolved = await realpath(targetPath);
+    }
+    catch {
+        // Path doesn't exist yet or can't be resolved; use the original value.
+    }
+    return isWithinAllowedRoot(resolved);
+}
+export function isAllowedRoot(targetPath) {
+    const normalizedTarget = normalizePath(targetPath);
+    return getBrowserRoots().some((root) => normalizePath(root) === normalizedTarget);
+}
+export function __resetBrowserRootsForTests() {
+    resolvedRoots = null;
+}
+function usesWindowsPath(filePath) {
+    return /^[A-Za-z]:[\\/]/.test(filePath) || filePath.startsWith("\\\\");
+}
+function getPathApi(filePath) {
+    return usesWindowsPath(filePath) ? path.win32 : path.posix;
+}
+export function joinPath(parentPath, childName) {
+    return getPathApi(parentPath).join(parentPath, childName);
+}
+export function getBaseName(filePath) {
+    return getPathApi(filePath).basename(filePath);
+}
+export function getParentPath(filePath) {
+    return getPathApi(filePath).dirname(filePath);
+}
+function getRootPath(filePath) {
+    return getPathApi(filePath).parse(filePath).root;
+}
+function isSamePath(leftPath, rightPath) {
+    return getPathApi(rightPath).relative(rightPath, leftPath) === "";
+}
+export function isPathWithinDirectory(targetPath, directoryPath) {
+    const pathApi = getPathApi(directoryPath);
+    const relativePath = pathApi.relative(directoryPath, targetPath);
+    return relativePath === "" || (!relativePath.startsWith("..") && !pathApi.isAbsolute(relativePath));
+}
+export function getProjectRoot() {
+    return getCurrentProject()?.worktree ?? null;
+}
+export function isWithinProjectRoot(targetPath) {
+    const projectRoot = getProjectRoot();
+    return projectRoot !== null && isPathWithinDirectory(targetPath, projectRoot);
+}
+export function isProjectRoot(targetPath) {
+    const projectRoot = getProjectRoot();
+    return projectRoot !== null && isSamePath(targetPath, projectRoot);
+}
+export async function scanLsDirectory(dirPath, page = 0) {
+    try {
+        if (!isWithinProjectRoot(dirPath)) {
+            return { error: t("ls.access_denied") };
+        }
+        const dirEntries = await fs.readdir(dirPath, { withFileTypes: true });
+        const entries = dirEntries
+            .map((entry) => ({
+            name: entry.name,
+            fullPath: joinPath(dirPath, entry.name),
+            type: entry.isDirectory() ? "directory" : "file",
+        }))
+            .sort((left, right) => {
+            if (left.type !== right.type) {
+                return left.type === "directory" ? -1 : 1;
+            }
+            return left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
+        });
+        const totalPages = Math.max(1, Math.ceil(entries.length / MAX_ENTRIES_PER_PAGE));
+        const safePage = Math.max(0, Math.min(page, totalPages - 1));
+        const startIndex = safePage * MAX_ENTRIES_PER_PAGE;
+        return {
+            entries: entries.slice(startIndex, startIndex + MAX_ENTRIES_PER_PAGE),
+            totalCount: entries.length,
+            currentPath: dirPath,
+            displayPath: pathToDisplayPath(dirPath),
+            hasParent: dirPath !== getRootPath(dirPath),
+            page: safePage,
+        };
+    }
+    catch (error) {
+        return {
+            error: `${t("ls.scan_error")}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}
+export async function getFileDetails(filePath) {
+    try {
+        if (!isWithinProjectRoot(filePath)) {
+            return { error: t("ls.access_denied") };
+        }
+        const stat = await fs.stat(filePath);
+        if (!stat.isFile()) {
+            return { error: t("commands.download.not_file") };
+        }
+        return {
+            name: getBaseName(filePath),
+            fullPath: filePath,
+            size: stat.size,
+            modified: stat.mtime,
+        };
+    }
+    catch (error) {
+        return {
+            error: `${t("ls.scan_error")}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}

package/dist/{bot/utils/file-download.js → app/services/file-download-service.js}

@@ -1,16 +1,19 @@
-// @ts-expect-error — node-fetch v2 ships no TS types and we avoid adding @types/node-fetch
+// @ts-expect-error - node-fetch v2 ships no TS types and we avoid adding @types/node-fetch
 import nodeFetch from "node-fetch";
 import { Agent as HttpsAgent } from "https";
-import { logger } from "../../utils/logger.js";
 import { config } from "../../config.js";
-import { buildTelegramFileUrl } from "./telegram-file-url.js";
-const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB Telegram limit
-/**
- * Download a photo from Telegram servers
- * @param api Grammy API instance
- * @param fileId Telegram file_id
- * @returns Downloaded photo buffer and path
- */
+import { logger } from "../../utils/logger.js";
+const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024;
+const DEFAULT_TELEGRAM_API_ROOT = "https://api.telegram.org";
+function telegramFileUrlBase() {
+    const apiRoot = config.telegram.apiRoot
+        ? config.telegram.apiRoot.replace(/\/+$/, "")
+        : DEFAULT_TELEGRAM_API_ROOT;
+    return `${apiRoot}/file/bot`;
+}
+export function buildTelegramFileUrl(filePath) {
+    return `${telegramFileUrlBase()}${config.telegram.token}/${filePath}`;
+}
 export async function downloadTelegramFile(api, fileId) {
     logger.debug(`[FileDownload] Getting file info for fileId=${fileId}`);
     const file = await api.getFile(fileId);
@@ -24,7 +27,6 @@ export async function downloadTelegramFile(api, fileId) {
     const fileUrl = buildTelegramFileUrl(file.file_path);
     logger.debug(`[FileDownload] Downloading from ${fileUrl.replace(config.telegram.token, "***")}`);
     const fetchOptions = {};
-    // Use proxy if configured
     if (config.telegram.proxyUrl) {
         const { HttpsProxyAgent } = await import("https-proxy-agent");
         fetchOptions.agent = new HttpsProxyAgent(config.telegram.proxyUrl);
@@ -32,7 +34,6 @@ export async function downloadTelegramFile(api, fileId) {
     else if (config.telegram.forceIpv4) {
         fetchOptions.agent = new HttpsAgent({ family: 4, keepAlive: true });
     }
-    // Send shared secret when custom API root expects it
     if (config.telegram.proxySecret) {
         fetchOptions.headers = {
             ...fetchOptions.headers,
@@ -51,32 +52,17 @@ export async function downloadTelegramFile(api, fileId) {
         filePath: file.file_path,
     };
 }
-/**
- * Convert buffer to base64 data URI
- * @param buffer File buffer
- * @param mimeType MIME type (e.g., "image/jpeg")
- * @returns Data URI string
- */
 export function toDataUri(buffer, mimeType) {
     const base64 = buffer.toString("base64");
     return `data:${mimeType};base64,${base64}`;
 }
-/**
- * Check if photo size is within limits
- * @param fileSize Photo size in bytes
- * @param maxSizeKb Maximum size in KB (from config)
- * @returns true if within limit
- */
 export function isFileSizeAllowed(fileSize, maxSizeKb) {
     if (!fileSize) {
-        return true; // Unknown size, allow (will be checked on download)
+        return true;
     }
     const maxBytes = maxSizeKb * 1024;
     return fileSize <= maxBytes;
 }
-/**
- * Get human-readable photo size
- */
 export function formatFileSize(bytes) {
     if (bytes < 1024) {
         return `${bytes}B`;

package/dist/app/services/mcp-catalog-service.js

@@ -0,0 +1,79 @@
+import { opencodeClient } from "../../opencode/client.js";
+function normalizeDirectoryForMcpApi(directory) {
+    return directory.replace(/\\/g, "/");
+}
+function parseMcpCatalogServers(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        const servers = [];
+        for (const item of value) {
+            if (!item || typeof item !== "object") {
+                return null;
+            }
+            const name = item.name;
+            const status = item.status;
+            if (typeof name !== "string" || !status || typeof status !== "object") {
+                return null;
+            }
+            const s = status;
+            if (typeof s.status !== "string") {
+                return null;
+            }
+            const mcpStatus = { status: s.status };
+            if ("error" in s && typeof s.error === "string") {
+                mcpStatus.error = s.error;
+            }
+            servers.push({ name, status: mcpStatus });
+        }
+        return servers;
+    }
+    const entries = Object.entries(value);
+    const servers = [];
+    for (const [name, status] of entries) {
+        if (!status || typeof status !== "object") {
+            return null;
+        }
+        const s = status;
+        if (typeof s.status !== "string") {
+            return null;
+        }
+        const mcpStatus = { status: s.status };
+        if ("error" in s && typeof s.error === "string") {
+            mcpStatus.error = s.error;
+        }
+        servers.push({ name, status: mcpStatus });
+    }
+    return servers;
+}
+export async function loadMcpCatalog(projectDirectory) {
+    const { data, error } = await opencodeClient.mcp.status({
+        directory: normalizeDirectoryForMcpApi(projectDirectory),
+    });
+    if (error || !data) {
+        throw error || new Error("No MCP status data received");
+    }
+    const servers = parseMcpCatalogServers(data);
+    if (!servers) {
+        throw new Error("Invalid MCP status data format");
+    }
+    return servers;
+}
+export async function toggleMcpCatalogServer(projectDirectory, serverName, enable) {
+    const params = {
+        name: serverName,
+        directory: normalizeDirectoryForMcpApi(projectDirectory),
+    };
+    if (enable) {
+        const { error } = await opencodeClient.mcp.connect(params);
+        if (error) {
+            throw error;
+        }
+        return;
+    }
+    const { error } = await opencodeClient.mcp.disconnect(params);
+    if (error) {
+        throw error;
+    }
+}

package/dist/app/services/message-history-service.js

@@ -0,0 +1,81 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { logger } from "../../utils/logger.js";
+const LATEST_ASSISTANT_RESPONSE_MESSAGES_LIMIT = 20;
+function extractTextParts(parts) {
+    const text = parts
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("")
+        .trim();
+    return text.length > 0 ? text : null;
+}
+export async function loadUserMessages(sessionId, directory) {
+    const { data, error } = await opencodeClient.session.messages({
+        sessionID: sessionId,
+        directory,
+    });
+    if (error || !data) {
+        throw error || new Error("No message data received");
+    }
+    const { data: sessionData } = await opencodeClient.session.get({
+        sessionID: sessionId,
+        directory,
+    });
+    const revertMessageID = sessionData?.revert?.messageID;
+    const messages = data
+        .map((message) => {
+        if (message.info.role !== "user") {
+            return null;
+        }
+        const text = extractTextParts(message.parts);
+        if (!text) {
+            return null;
+        }
+        return {
+            id: message.info.id ?? `${message.info.time?.created ?? 0}`,
+            text,
+            created: message.info.time?.created ?? 0,
+        };
+    })
+        .filter((message) => Boolean(message))
+        .sort((a, b) => b.created - a.created);
+    if (revertMessageID) {
+        const revertIndex = messages.findIndex((msg) => msg.id === revertMessageID);
+        if (revertIndex !== -1) {
+            return messages.slice(revertIndex + 1);
+        }
+    }
+    return messages;
+}
+export async function loadLatestAssistantResponse(sessionId, directory) {
+    try {
+        const { data: messages, error } = await opencodeClient.session.messages({
+            sessionID: sessionId,
+            directory,
+            limit: LATEST_ASSISTANT_RESPONSE_MESSAGES_LIMIT,
+        });
+        if (error || !messages) {
+            logger.warn("[Messages] Failed to fetch latest assistant response:", error);
+            return null;
+        }
+        const latestResponse = messages.reduce((latest, message) => {
+            if (message.info.role !== "assistant" || message.info.summary) {
+                return latest;
+            }
+            const text = extractTextParts(message.parts);
+            if (!text) {
+                return latest;
+            }
+            const created = message.info.time?.created ?? 0;
+            if (!latest || created >= latest.created) {
+                return { text, created };
+            }
+            return latest;
+        }, null);
+        return latestResponse?.text ?? null;
+    }
+    catch (err) {
+        logger.error("[Messages] Error loading latest assistant response:", err);
+        return null;
+    }
+}

package/dist/{model/capabilities.js → app/services/model-capabilities-service.js}

@@ -1,5 +1,5 @@
-import { opencodeClient } from "../opencode/client.js";
-import { logger } from "../utils/logger.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { logger } from "../../utils/logger.js";
 const capabilitiesCache = {};
 /**
  * Get model capabilities from OpenCode API

package/dist/{model/context-limit.js → app/services/model-context-limit-service.js}

@@ -1,7 +1,7 @@
-import { opencodeClient } from "../opencode/client.js";
-import { logger } from "../utils/logger.js";
-import { DEFAULT_CONTEXT_LIMIT } from "../pinned/format.js";
-import { isExpectedOpencodeUnavailableError } from "../utils/opencode-error.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { logger } from "../../utils/logger.js";
+import { isExpectedOpencodeUnavailableError } from "../../utils/opencode-error.js";
+export const DEFAULT_CONTEXT_LIMIT = 200000;
 const PROVIDER_CACHE_TTL_MS = 10 * 60 * 1000;
 const contextLimitCache = new Map();
 let providersCacheExpiresAt = 0;

package/dist/{model/manager.js → app/services/model-selection-service.js}

@@ -1,7 +1,7 @@
-import { getCurrentModel, setCurrentModel } from "../settings/manager.js";
-import { config } from "../config.js";
-import { opencodeClient } from "../opencode/client.js";
-import { logger } from "../utils/logger.js";
+import { getCurrentModel, setCurrentModel } from "../stores/settings-store.js";
+import { config } from "../../config.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { logger } from "../../utils/logger.js";
 import path from "node:path";
 const MODEL_CATALOG_CACHE_TTL_MS = 10 * 60 * 1000;
 const SERVER_UNAVAILABLE_ERROR_MARKERS = [

package/dist/{project/manager.js → app/services/project-service.js}

@@ -1,8 +1,8 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
-import { opencodeClient } from "../opencode/client.js";
-import { getCachedSessionProjects } from "../session/cache-manager.js";
-import { logger } from "../utils/logger.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCachedSessionProjects } from "./session-cache-service.js";
+import { logger } from "../../utils/logger.js";
 async function getResolvedProjects(options) {
     const includeLinkedWorktrees = options?.includeLinkedWorktrees === true;
     const { data: projects, error } = await opencodeClient.project.list();

package/dist/app/services/project-switch-service.js

@@ -0,0 +1,39 @@
+import { setCurrentProject } from "../stores/settings-store.js";
+import { clearSession } from "./session-service.js";
+import { summaryAggregator } from "../managers/summary-aggregation-manager.js";
+import { detachAttachedSession } from "./attach-service.js";
+import { stopEventListening } from "../../opencode/events.js";
+import { backgroundSessionTracker } from "../managers/background-session-manager.js";
+import { getStoredAgent, resolveProjectAgent } from "./agent-selection-service.js";
+import { getStoredModel } from "./model-selection-service.js";
+import { formatVariantForButton } from "./variant-selection-service.js";
+import { clearAllInteractionState } from "../managers/interaction-manager.js";
+import { logger } from "../../utils/logger.js";
+import { config } from "../../config.js";
+export async function switchToProject(ctx, project, reason, options) {
+    detachAttachedSession(reason);
+    stopEventListening();
+    backgroundSessionTracker.clear();
+    setCurrentProject(project);
+    clearSession();
+    summaryAggregator.clear();
+    clearAllInteractionState(reason);
+    try {
+        await options.presentation.clearPinnedMessage();
+    }
+    catch (err) {
+        logger.error("[Bot] Error clearing pinned message:", err);
+    }
+    options.presentation.initializeKeyboard(ctx);
+    const contextLimit = await options.presentation.refreshContextLimit();
+    options.presentation.updateKeyboardContext({ tokensUsed: 0, tokensLimit: contextLimit });
+    const currentAgent = await resolveProjectAgent(getStoredAgent());
+    const currentModel = getStoredModel();
+    const contextInfo = { tokensUsed: 0, tokensLimit: contextLimit };
+    const variantName = formatVariantForButton(currentModel.variant || "default");
+    options.presentation.updateKeyboardAgent(currentAgent);
+    if (config.bot.trackBackgroundSessions && options.ensureEventSubscription) {
+        await options.ensureEventSubscription(project.worktree);
+    }
+    return options.presentation.createMainKeyboard(currentAgent, currentModel, contextInfo, variantName);
+}

package/dist/{bot/utils/busy-guard.js → app/services/run-control-service.js}

@@ -1,8 +1,7 @@
-import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
-import { attachManager } from "../../attach/manager.js";
-import { reconcileBusyStateNow } from "./busy-reconciliation.js";
-import { t } from "../../i18n/index.js";
+import { attachManager } from "../managers/attach-manager.js";
+import { foregroundSessionState } from "../managers/foreground-session-state-manager.js";
 import { logger } from "../../utils/logger.js";
+import { reconcileBusyStateNow } from "./busy-reconciliation-service.js";
 export function isForegroundBusy() {
     return foregroundSessionState.isBusy() || attachManager.isBusy();
 }
@@ -30,13 +29,3 @@ export async function reconcileForegroundBusyState() {
         }
     }
 }
-export async function replyBusyBlocked(ctx) {
-    const message = t("bot.session_busy");
-    if (ctx.callbackQuery) {
-        await ctx.answerCallbackQuery({ text: message }).catch(() => { });
-        return;
-    }
-    if (ctx.chat) {
-        await ctx.reply(message).catch(() => { });
-    }
-}

package/dist/{scheduled-task/executor.js → app/services/scheduled-task-executor-service.js}

@@ -1,8 +1,8 @@
-import { config } from "../config.js";
-import { t } from "../i18n/index.js";
-import { opencodeClient } from "../opencode/client.js";
-import { logger } from "../utils/logger.js";
-import { cleanupScheduledTaskSessionIgnores, registerScheduledTaskSessionIgnore, } from "./session-ignore.js";
+import { config } from "../../config.js";
+import { t } from "../../i18n/index.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { logger } from "../../utils/logger.js";
+import { cleanupScheduledTaskSessionIgnores, registerScheduledTaskSessionIgnore, } from "./scheduled-task-session-ignore-service.js";
 export const SCHEDULED_TASK_AGENT = "build";
 const SCHEDULED_TASK_SESSION_TITLE = "Scheduled task run";
 const EXECUTION_POLL_INTERVAL_MS = 2000;