@grinev/opencode-telegram-bot 0.1.0-rc.1

package/dist/bot/commands/projects.js

@@ -0,0 +1,104 @@
+import { InlineKeyboard } from "grammy";
+import { setCurrentProject, getCurrentProject } from "../../settings/manager.js";
+import { getProjects } from "../../project/manager.js";
+import { clearSession } from "../../session/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { logger } from "../../utils/logger.js";
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+function formatProjectButtonLabel(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))}...`;
+}
+export async function projectsCommand(ctx) {
+    try {
+        const projects = await getProjects();
+        if (projects.length === 0) {
+            await ctx.reply("📭 Проектов нет.");
+            return;
+        }
+        const keyboard = new InlineKeyboard();
+        const currentProject = getCurrentProject();
+        projects.forEach((project, index) => {
+            const isActive = currentProject &&
+                (project.id === currentProject.id || project.worktree === currentProject.worktree);
+            const label = project.name
+                ? `${index + 1}. ${project.name}`
+                : `${index + 1}. ${project.worktree}`;
+            const labelWithCheck = formatProjectButtonLabel(label, Boolean(isActive));
+            keyboard.text(labelWithCheck, `project:${project.id}`).row();
+        });
+        if (currentProject) {
+            const projectName = currentProject.name || currentProject.worktree;
+            await ctx.reply(`Выберите проект:\n\nТекущий: 🏗 ${projectName}`, { reply_markup: keyboard });
+        }
+        else {
+            await ctx.reply("Выберите проект:", { reply_markup: keyboard });
+        }
+    }
+    catch (error) {
+        logger.error("[Bot] Error fetching projects:", error);
+        await ctx.reply("🔴 OpenCode Server недоступен или произошла ошибка при получении списка проектов.");
+    }
+}
+export async function handleProjectSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("project:")) {
+        return false;
+    }
+    const projectId = callbackQuery.data.replace("project:", "");
+    try {
+        const projects = await getProjects();
+        const selectedProject = projects.find((p) => p.id === projectId);
+        if (!selectedProject) {
+            throw new Error(`Project with id ${projectId} not found`);
+        }
+        logger.info(`[Bot] Project selected: ${selectedProject.name || selectedProject.worktree} (id: ${projectId})`);
+        setCurrentProject(selectedProject);
+        clearSession();
+        summaryAggregator.clear();
+        // Clear pinned message when switching projects
+        try {
+            await pinnedMessageManager.clear();
+        }
+        catch (err) {
+            logger.error("[Bot] Error clearing pinned message:", err);
+        }
+        // Initialize keyboard manager if not already
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        // Refresh context limit for current model
+        await pinnedMessageManager.refreshContextLimit();
+        const contextLimit = pinnedMessageManager.getContextLimit();
+        // Reset context to 0 (no session selected) with current model's limit
+        keyboardManager.updateContext(0, contextLimit);
+        // Get current state for keyboard (with context = 0)
+        const currentAgent = getStoredAgent();
+        const currentModel = getStoredModel();
+        const contextInfo = { tokensUsed: 0, tokensLimit: contextLimit };
+        const variantName = formatVariantForButton(currentModel.variant || "default");
+        const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo, variantName);
+        const projectName = selectedProject.name || selectedProject.worktree;
+        await ctx.answerCallbackQuery();
+        await ctx.reply(`✅ Проект выбран: ${projectName}\n\n📋 Сессия сброшена. Используйте /sessions или /new для работы с этим проектом.`, {
+            reply_markup: keyboard,
+        });
+        await ctx.deleteMessage();
+    }
+    catch (error) {
+        logger.error("[Bot] Error selecting project:", error);
+        await ctx.answerCallbackQuery();
+        await ctx.reply("🔴 Ошибка при выборе проекта.");
+    }
+    return true;
+}

package/dist/bot/commands/server-restart.js

@@ -0,0 +1,23 @@
+import { restartServer, isServerRunning } from "../../opencode/server.js";
+export async function serverRestartCommand(ctx) {
+    try {
+        const wasRunning = isServerRunning();
+        if (wasRunning) {
+            await ctx.reply("🔄 Перезапускаю OpenCode сервер...");
+        }
+        else {
+            await ctx.reply("🚀 Запускаю OpenCode сервер...");
+        }
+        const result = await restartServer();
+        if (result.success) {
+            await ctx.reply(`✅ Сервер ${wasRunning ? "перезапущен" : "запущен"} успешно!\n\n${result.message}`);
+        }
+        else {
+            await ctx.reply(`🔴 Ошибка:\n\n${result.message}`);
+        }
+    }
+    catch (error) {
+        console.error("Error restarting server:", error);
+        await ctx.reply("🔴 Произошла ошибка при попытке перезапустить сервер.");
+    }
+}

package/dist/bot/commands/server-start.js

@@ -0,0 +1,23 @@
+import { startServer, isServerRunning } from "../../opencode/server.js";
+export async function serverStartCommand(ctx) {
+    try {
+        if (isServerRunning()) {
+            await ctx.reply("🟢 **Сервер уже запущен**\n\nИспользуйте /server_restart для перезапуска.", {
+                parse_mode: "Markdown",
+            });
+            return;
+        }
+        await ctx.reply("🔄 Запускаю OpenCode сервер...");
+        const result = await startServer();
+        if (result.success) {
+            await ctx.reply(`✅ ${result.message}\n\nСервер готов к работе!`);
+        }
+        else {
+            await ctx.reply(`🔴 Ошибка запуска сервера:\n\n${result.message}`);
+        }
+    }
+    catch (error) {
+        console.error("Error starting server:", error);
+        await ctx.reply("🔴 Произошла ошибка при попытке запустить сервер.");
+    }
+}

package/dist/bot/commands/sessions.js

@@ -0,0 +1,240 @@
+import { InlineKeyboard } from "grammy";
+import { opencodeClient } from "../../opencode/client.js";
+import { setCurrentSession } from "../../session/manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { logger } from "../../utils/logger.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+import { config } from "../../config.js";
+export async function sessionsCommand(ctx) {
+    try {
+        const maxSessions = config.bot.sessionsListLimit;
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply("🏗 Проект не выбран.\n\nСначала выберите проект командой /projects.");
+            return;
+        }
+        logger.debug(`[Sessions] Fetching sessions for directory: ${currentProject.worktree}`);
+        const { data: sessions, error } = await opencodeClient.session.list({
+            directory: currentProject.worktree,
+            limit: maxSessions,
+        });
+        if (error || !sessions) {
+            throw error || new Error("No data received from server");
+        }
+        logger.debug(`[Sessions] Found ${sessions.length} sessions`);
+        sessions.forEach((session) => {
+            logger.debug(`[Sessions] Session: ${session.title} | ${session.directory}`);
+        });
+        if (sessions.length === 0) {
+            await ctx.reply("📭 Сессий нет.\n\nСоздайте новую сессию командой /new.");
+            return;
+        }
+        const keyboard = new InlineKeyboard();
+        sessions.forEach((session, index) => {
+            const date = new Date(session.time.created).toLocaleDateString("ru-RU");
+            const label = `${index + 1}. ${session.title} (${date})`;
+            keyboard.text(label, `session:${session.id}`).row();
+        });
+        await ctx.reply("Выберите сессию:", {
+            reply_markup: keyboard,
+        });
+    }
+    catch (error) {
+        logger.error("[Sessions] Error fetching sessions:", error);
+        await ctx.reply("🔴 OpenCode Server недоступен или произошла ошибка при получении списка сессий.");
+    }
+}
+export async function handleSessionSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("session:")) {
+        return false;
+    }
+    const sessionId = callbackQuery.data.replace("session:", "");
+    try {
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.answerCallbackQuery();
+            await ctx.reply("🔴 Проект не выбран. Используйте /projects.");
+            return true;
+        }
+        const { data: session, error } = await opencodeClient.session.get({
+            sessionID: sessionId,
+            directory: currentProject.worktree,
+        });
+        if (error || !session) {
+            throw error || new Error("Failed to get session details");
+        }
+        logger.info(`[Bot] Session selected: id=${session.id}, title="${session.title}", project=${currentProject.worktree}`);
+        const sessionInfo = {
+            id: session.id,
+            title: session.title,
+            directory: currentProject.worktree,
+        };
+        setCurrentSession(sessionInfo);
+        await ctx.answerCallbackQuery();
+        let loadingMessageId = null;
+        if (ctx.chat) {
+            try {
+                const loadingMessage = await ctx.api.sendMessage(ctx.chat.id, `⏳ Загружаю контекст и последние сообщения...`);
+                loadingMessageId = loadingMessage.message_id;
+            }
+            catch (err) {
+                logger.error("[Sessions] Failed to send loading message:", err);
+            }
+        }
+        // Initialize pinned message manager if not already
+        if (!pinnedMessageManager.isInitialized() && ctx.chat) {
+            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
+        }
+        // Initialize keyboard manager if not already
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        try {
+            // Create new pinned message for this session
+            await pinnedMessageManager.onSessionChange(session.id, session.title);
+            // Load context from session history (for existing sessions)
+            // Wait for it to complete so keyboard has correct context
+            await pinnedMessageManager.loadContextFromHistory(session.id, currentProject.worktree);
+        }
+        catch (err) {
+            logger.error("[Bot] Error initializing pinned message:", err);
+        }
+        if (ctx.chat) {
+            const chatId = ctx.chat.id;
+            // Update keyboard with loaded context (callback executes async via setImmediate, so update manually)
+            const contextInfo = pinnedMessageManager.getContextInfo();
+            if (contextInfo) {
+                keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+            }
+            // Delete loading message
+            if (loadingMessageId) {
+                try {
+                    await ctx.api.deleteMessage(chatId, loadingMessageId);
+                }
+                catch (err) {
+                    logger.debug("[Sessions] Failed to delete loading message:", err);
+                }
+            }
+            // Send session selection confirmation with updated keyboard
+            const keyboard = keyboardManager.getKeyboard();
+            try {
+                await ctx.api.sendMessage(chatId, `✅ Сессия выбрана: ${session.title}`, {
+                    reply_markup: keyboard,
+                });
+            }
+            catch (err) {
+                logger.error("[Sessions] Failed to send selection message:", err);
+            }
+            // Send preview asynchronously
+            safeBackgroundTask({
+                taskName: "sessions.sendPreview",
+                task: () => sendSessionPreview(ctx.api, chatId, null, session.title, session.id, currentProject.worktree),
+            });
+        }
+        await ctx.deleteMessage();
+    }
+    catch (error) {
+        logger.error("[Sessions] Error selecting session:", error);
+        await ctx.answerCallbackQuery();
+        await ctx.reply("🔴 Ошибка при выборе сессии.");
+    }
+    return true;
+}
+const PREVIEW_MESSAGES_LIMIT = 6;
+const PREVIEW_ITEM_MAX_LENGTH = 420;
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+function extractTextParts(parts) {
+    const textParts = parts
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text);
+    if (textParts.length === 0) {
+        return null;
+    }
+    const text = textParts.join("").trim();
+    return text.length > 0 ? text : null;
+}
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    const clipped = text.slice(0, Math.max(0, maxLength - 3)).trimEnd();
+    return `${clipped}...`;
+}
+async function loadSessionPreview(sessionId, directory) {
+    try {
+        const { data: messages, error } = await opencodeClient.session.messages({
+            sessionID: sessionId,
+            directory,
+            limit: PREVIEW_MESSAGES_LIMIT,
+        });
+        if (error || !messages) {
+            logger.warn("[Sessions] Failed to fetch session messages:", error);
+            return [];
+        }
+        const items = messages
+            .map(({ info, parts }) => {
+            const role = info.role;
+            if (role !== "user" && role !== "assistant") {
+                return null;
+            }
+            if (role === "assistant" && info.summary) {
+                return null;
+            }
+            const text = extractTextParts(parts);
+            if (!text) {
+                return null;
+            }
+            const created = info.time?.created ?? 0;
+            return {
+                role,
+                text: truncateText(text, PREVIEW_ITEM_MAX_LENGTH),
+                created,
+            };
+        })
+            .filter((item) => Boolean(item));
+        return items.sort((a, b) => a.created - b.created);
+    }
+    catch (err) {
+        logger.error("[Sessions] Error loading session preview:", err);
+        return [];
+    }
+}
+function formatSessionPreview(sessionTitle, items) {
+    const lines = [];
+    if (items.length === 0) {
+        lines.push("Последних сообщений нет.");
+        return lines.join("\n");
+    }
+    lines.push("Последние сообщения:");
+    items.forEach((item, index) => {
+        const label = item.role === "user" ? "Вы:" : "Агент:";
+        lines.push(`${label} ${item.text}`);
+        if (index < items.length - 1) {
+            lines.push("");
+        }
+    });
+    const rawMessage = lines.join("\n");
+    return truncateText(rawMessage, TELEGRAM_MESSAGE_LIMIT);
+}
+async function sendSessionPreview(api, chatId, messageId, sessionTitle, sessionId, directory) {
+    const previewItems = await loadSessionPreview(sessionId, directory);
+    const finalText = formatSessionPreview(sessionTitle, previewItems);
+    if (messageId) {
+        try {
+            await api.editMessageText(chatId, messageId, finalText);
+            return;
+        }
+        catch (err) {
+            logger.warn("[Sessions] Failed to edit preview message, sending new one:", err);
+        }
+    }
+    try {
+        await api.sendMessage(chatId, finalText);
+    }
+    catch (err) {
+        logger.error("[Sessions] Failed to send session preview message:", err);
+    }
+}

package/dist/bot/commands/start.js

@@ -0,0 +1,40 @@
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+export async function startCommand(ctx) {
+    if (ctx.chat) {
+        if (!pinnedMessageManager.isInitialized()) {
+            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
+        }
+        keyboardManager.initialize(ctx.api, ctx.chat.id);
+    }
+    if (pinnedMessageManager.getContextLimit() === 0) {
+        await pinnedMessageManager.refreshContextLimit();
+    }
+    // Get current agent, model, and context
+    const currentAgent = getStoredAgent();
+    const currentModel = getStoredModel();
+    const variantName = formatVariantForButton(currentModel.variant || "default");
+    const contextInfo = pinnedMessageManager.getContextInfo() ??
+        (pinnedMessageManager.getContextLimit() > 0
+            ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
+            : null);
+    keyboardManager.updateAgent(currentAgent);
+    keyboardManager.updateModel(currentModel);
+    if (contextInfo) {
+        keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+    }
+    const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
+    await ctx.reply("👋 Добро пожаловать в OpenCode Telegram Bot!\n\n" +
+        "Используйте команды:\n" +
+        "/projects — выбрать проект\n" +
+        "/sessions — список сессий\n" +
+        "/new — новая сессия\n" +
+        "/agent — сменить режим\n" +
+        "/model — выбрать модель\n" +
+        "/status — статус\n" +
+        "/help — справка", { reply_markup: keyboard });
+}

package/dist/bot/commands/status.js

@@ -0,0 +1,63 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentSession } from "../../session/manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { fetchCurrentAgent } from "../../agent/manager.js";
+import { getAgentDisplayName } from "../../agent/types.js";
+import { fetchCurrentModel } from "../../model/manager.js";
+import { formatModelForDisplay } from "../../model/types.js";
+import { processManager } from "../../process/manager.js";
+import { logger } from "../../utils/logger.js";
+export async function statusCommand(ctx) {
+    try {
+        const { data, error } = await opencodeClient.global.health();
+        if (error || !data) {
+            throw error || new Error("No data received from server");
+        }
+        let message = "🟢 **OpenCode Server запущен**\n\n";
+        message += `Статус: ${data.healthy ? "Healthy" : "Unhealthy"}\n`;
+        if (data.version) {
+            message += `Версия: ${data.version}\n`;
+        }
+        // Add process management information
+        if (processManager.isRunning()) {
+            const uptime = processManager.getUptime();
+            const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
+            message += `Управляется ботом: Да\n`;
+            message += `PID: ${processManager.getPID()}\n`;
+            message += `Uptime: ${uptimeStr} сек\n`;
+        }
+        else {
+            message += `Управляется ботом: Нет\n`;
+        }
+        // Add agent mode information
+        const currentAgent = await fetchCurrentAgent();
+        const agentDisplay = currentAgent ? getAgentDisplayName(currentAgent) : "не установлен";
+        message += `Режим: ${agentDisplay}\n`;
+        // Add model information
+        const currentModel = fetchCurrentModel();
+        const modelDisplay = formatModelForDisplay(currentModel.providerID, currentModel.modelID);
+        message += `Модель: ${modelDisplay}\n`;
+        const currentProject = getCurrentProject();
+        if (currentProject) {
+            const projectName = currentProject.name || currentProject.worktree;
+            message += `\n🏗 Проект: ${projectName}\n`;
+        }
+        else {
+            message += "\n🏗 Проект: не выбран\n";
+            message += "Используйте /projects для выбора проекта";
+        }
+        const currentSession = getCurrentSession();
+        if (currentSession) {
+            message += `\n📋 Текущая сессия: ${currentSession.title}\n`;
+        }
+        else {
+            message += "\n📋 Текущая сессия: не выбрана\n";
+            message += "Используйте /sessions для выбора или /new для создания";
+        }
+        await ctx.reply(message, { parse_mode: "Markdown" });
+    }
+    catch (error) {
+        logger.error("[Bot] Error checking server status:", error);
+        await ctx.reply("🔴 OpenCode Server недоступен\n\n" + "Используйте /opencode_start для запуска сервера.");
+    }
+}

package/dist/bot/commands/stop.js

@@ -0,0 +1,92 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { stopEventListening } from "../../opencode/events.js";
+import { getCurrentSession } from "../../session/manager.js";
+import { permissionManager } from "../../permission/manager.js";
+import { questionManager } from "../../question/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { logger } from "../../utils/logger.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function stopLocalStreaming() {
+    stopEventListening();
+    summaryAggregator.clear();
+    questionManager.clear();
+    permissionManager.clear();
+}
+async function pollSessionStatus(sessionId, directory, maxWaitMs = 5000) {
+    const startedAt = Date.now();
+    const pollIntervalMs = 500;
+    while (Date.now() - startedAt < maxWaitMs) {
+        try {
+            const { data, error } = await opencodeClient.session.status({ directory });
+            if (error || !data) {
+                break;
+            }
+            const sessionStatus = data[sessionId];
+            if (!sessionStatus) {
+                return "not-found";
+            }
+            if (sessionStatus.type === "idle" || sessionStatus.type === "error") {
+                return "idle";
+            }
+            if (sessionStatus.type !== "busy") {
+                return "not-found";
+            }
+            await sleep(pollIntervalMs);
+        }
+        catch (error) {
+            logger.warn("[Stop] Failed to poll session status:", error);
+            break;
+        }
+    }
+    return "busy";
+}
+export async function stopCommand(ctx) {
+    try {
+        const currentSession = getCurrentSession();
+        if (!currentSession) {
+            await ctx.reply("🛑 Агент не был запущен\n\nСначала создайте сессию командой /new или выберите существующую через /sessions.");
+            return;
+        }
+        stopLocalStreaming();
+        const waitingMessage = await ctx.reply("🛑 Отключил поток событий и отправляю сигнал прерывания...\n\nОжидание остановки агента.");
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5000);
+        try {
+            const { data: abortResult, error: abortError } = await opencodeClient.session.abort({
+                sessionID: currentSession.id,
+                directory: currentSession.directory,
+            }, { signal: controller.signal });
+            clearTimeout(timeoutId);
+            if (abortError) {
+                logger.warn("[Stop] Abort request failed:", abortError);
+                await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, "⚠️ Поток событий остановлен, но сервер не подтвердил прерывание.\n\nПроверьте /status и повторите /stop через пару секунд.");
+                return;
+            }
+            if (abortResult !== true) {
+                await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, "⚠️ Поток событий остановлен, но агент мог уже завершиться к моменту запроса.");
+                return;
+            }
+            const finalStatus = await pollSessionStatus(currentSession.id, currentSession.directory, 5000);
+            if (finalStatus === "idle" || finalStatus === "not-found") {
+                await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, "✅ Действие агента прервано. Новые сообщения от текущего запуска больше не придут.");
+            }
+            else {
+                await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, "⚠️ Сигнал отправлен, но агент еще busy.\n\nПоток событий уже отключен, поэтому бот не будет присылать промежуточные сообщения.");
+            }
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === "AbortError") {
+                await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, "⚠️ Таймаут запроса на прерывание.\n\nПоток событий уже отключен, повторите /stop через пару секунд.");
+            }
+            else {
+                logger.error("[Stop] Error while aborting session:", error);
+                await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, "⚠️ Поток событий остановлен локально, но при прерывании на сервере произошла ошибка.");
+            }
+        }
+    }
+    catch (error) {
+        logger.error("[Stop] Unexpected error:", error);
+        await ctx.reply("🔴 Ошибка при прерывании действия.\n\nПоток событий остановлен, попробуйте /stop еще раз.");
+    }
+}