@tspappsen/elamax 1.2.3

package/dist/telegram/bot.js

@@ -0,0 +1,344 @@
+import { Bot } from "grammy";
+import { createWriteStream } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { pipeline } from "node:stream/promises";
+import { config, persistModel } from "../config.js";
+import { sendToOrchestrator, cancelCurrentMessage, getWorkers, getLastRouteResult, invalidateSession } from "../copilot/orchestrator.js";
+import { chunkMessage, toTelegramMarkdown } from "./formatter.js";
+import { searchMemories } from "../store/db.js";
+import { listSkills } from "../copilot/skills.js";
+import { restartDaemon } from "../daemon.js";
+import { getRouterConfig, updateRouterConfig } from "../copilot/router.js";
+let bot;
+async function sendTelegramResponse(ctx, text, replyParams, indicator) {
+    const formatted = toTelegramMarkdown(text) + (indicator?.markdownSuffix ?? "");
+    const chunks = chunkMessage(formatted);
+    const fallbackChunks = chunkMessage(text + (indicator?.plainSuffix ?? ""));
+    const sendChunk = async (chunk, fallback, isFirst) => {
+        const opts = isFirst
+            ? { parse_mode: "MarkdownV2", reply_parameters: replyParams }
+            : { parse_mode: "MarkdownV2" };
+        await ctx.reply(chunk, opts).catch(() => ctx.reply(fallback, isFirst ? { reply_parameters: replyParams } : {}));
+    };
+    try {
+        for (let i = 0; i < chunks.length; i++) {
+            await sendChunk(chunks[i], fallbackChunks[i] ?? chunks[i], i === 0);
+        }
+    }
+    catch {
+        try {
+            for (let i = 0; i < fallbackChunks.length; i++) {
+                await ctx.reply(fallbackChunks[i], i === 0 ? { reply_parameters: replyParams } : {});
+            }
+        }
+        catch {
+            // Nothing more we can do
+        }
+    }
+}
+function startTypingIndicator(ctx) {
+    let typingInterval;
+    void ctx.replyWithChatAction("typing").catch(() => { });
+    typingInterval = setInterval(() => {
+        void ctx.replyWithChatAction("typing").catch(() => { });
+    }, 4000);
+    return () => {
+        if (typingInterval) {
+            clearInterval(typingInterval);
+            typingInterval = undefined;
+        }
+    };
+}
+async function handleTelegramTurn(ctx, prompt, options) {
+    if (!ctx.chat || !ctx.message) {
+        return;
+    }
+    const chatId = ctx.chat.id;
+    const userMessageId = ctx.message.message_id;
+    const replyParams = { message_id: userMessageId };
+    const stopTyping = startTypingIndicator(ctx);
+    try {
+        await sendToOrchestrator(prompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
+            if (!done) {
+                return;
+            }
+            stopTyping();
+            const routeResult = getLastRouteResult();
+            const indicator = routeResult && routeResult.routerMode === "auto"
+                ? {
+                    markdownSuffix: `\n\n_⚡ auto · ${routeResult.model}_`,
+                    plainSuffix: `\n\n⚡ auto · ${routeResult.model}`,
+                }
+                : undefined;
+            void sendTelegramResponse(ctx, text, replyParams, indicator);
+        }, options);
+    }
+    finally {
+        stopTyping();
+    }
+}
+async function activeModelSupportsVision() {
+    try {
+        const { getClient } = await import("../copilot/client.js");
+        const client = await getClient();
+        const models = await client.listModels();
+        return models.find((model) => model.id === config.copilotModel)?.capabilities.supports.vision;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sanitizeFileName(fileName) {
+    return fileName.replace(/[^a-zA-Z0-9._-]/g, "-");
+}
+async function downloadTelegramFile(ctx, fileId, preferredName) {
+    const file = await ctx.api.getFile(fileId);
+    if (!file.file_path) {
+        throw new Error("Telegram did not provide a downloadable file path.");
+    }
+    const tempDir = await mkdtemp(join(tmpdir(), "max-telegram-"));
+    const sourceName = preferredName || basename(file.file_path);
+    const safeName = sanitizeFileName(sourceName) || `image${extname(file.file_path) || ".jpg"}`;
+    const filePath = join(tempDir, safeName);
+    const url = `https://api.telegram.org/file/bot${config.telegramBotToken}/${file.file_path}`;
+    const response = await fetch(url);
+    if (!response.ok || !response.body) {
+        throw new Error(`Telegram file download failed (${response.status} ${response.statusText})`);
+    }
+    await pipeline(response.body, createWriteStream(filePath));
+    return { tempDir, filePath };
+}
+async function removeTempDir(tempDir) {
+    if (!tempDir)
+        return;
+    try {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort cleanup
+    }
+}
+async function handleTelegramImageMessage(ctx, fileId, prompt, preferredName) {
+    const supportsVision = await activeModelSupportsVision();
+    if (supportsVision === false) {
+        await ctx.reply(`The current model (${config.copilotModel}) can't analyze images. Switch to a vision-capable model with /model and try again.`);
+        return;
+    }
+    let tempDir;
+    try {
+        const downloaded = await downloadTelegramFile(ctx, fileId, preferredName);
+        tempDir = downloaded.tempDir;
+        await handleTelegramTurn(ctx, prompt, {
+            attachments: [{
+                    type: "file",
+                    path: downloaded.filePath,
+                    displayName: preferredName,
+                }],
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        await ctx.reply(`I couldn't process that image: ${msg}`);
+    }
+    finally {
+        await removeTempDir(tempDir);
+    }
+}
+export function createBot() {
+    if (!config.telegramBotToken) {
+        throw new Error("Telegram bot token is missing. Run 'max setup' and enter the bot token from @BotFather.");
+    }
+    if (config.authorizedUserId === undefined) {
+        throw new Error("Telegram user ID is missing. Run 'max setup' and enter your Telegram user ID (get it from @userinfobot).");
+    }
+    bot = new Bot(config.telegramBotToken);
+    // Auth middleware — only allow the authorized user
+    bot.use(async (ctx, next) => {
+        if (config.authorizedUserId !== undefined && ctx.from?.id !== config.authorizedUserId) {
+            return; // Silently ignore unauthorized users
+        }
+        await next();
+    });
+    // /start and /help
+    bot.command("start", (ctx) => ctx.reply("Max is online. Send me anything."));
+    bot.command("help", (ctx) => ctx.reply("I'm Max, your AI daemon.\n\n" +
+        "Just send me a message and I'll handle it.\n\n" +
+        "Commands:\n" +
+        "/cancel — Cancel the current message\n" +
+        "/model — Show current model\n" +
+        "/model <name> — Switch model\n" +
+        "/auto — Toggle auto model routing\n" +
+        "/memory — Show stored memories\n" +
+        "/skills — List installed skills\n" +
+        "/workers — List active worker sessions\n" +
+        "/restart — Restart Max\n" +
+        "/help — Show this help"));
+    bot.command("cancel", async (ctx) => {
+        const cancelled = await cancelCurrentMessage();
+        await ctx.reply(cancelled ? "⛔ Cancelled." : "Nothing to cancel.");
+    });
+    bot.command("model", async (ctx) => {
+        const arg = ctx.match?.trim();
+        if (arg) {
+            // Validate against available models before persisting
+            try {
+                const { getClient } = await import("../copilot/client.js");
+                const client = await getClient();
+                const models = await client.listModels();
+                const match = models.find((m) => m.id === arg);
+                if (!match) {
+                    const suggestions = models
+                        .filter((m) => m.id.includes(arg) || m.id.toLowerCase().includes(arg.toLowerCase()))
+                        .map((m) => m.id);
+                    const hint = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : "";
+                    await ctx.reply(`Model '${arg}' not found.${hint}`);
+                    return;
+                }
+            }
+            catch {
+                // If validation fails (client not ready), allow the switch — will fail on next message if wrong
+            }
+            const previous = config.copilotModel;
+            config.copilotModel = arg;
+            persistModel(arg);
+            invalidateSession();
+            await ctx.reply(`Model: ${previous} → ${arg}`);
+        }
+        else {
+            await ctx.reply(`Current model: ${config.copilotModel}`);
+        }
+    });
+    bot.command("memory", async (ctx) => {
+        const memories = searchMemories(undefined, undefined, 50);
+        if (memories.length === 0) {
+            await ctx.reply("No memories stored.");
+        }
+        else {
+            const lines = memories.map((m) => `#${m.id} [${m.category}] ${m.content}`);
+            await ctx.reply(lines.join("\n") + `\n\n${memories.length} total`);
+        }
+    });
+    bot.command("skills", async (ctx) => {
+        const skills = listSkills();
+        if (skills.length === 0) {
+            await ctx.reply("No skills installed.");
+        }
+        else {
+            const lines = skills.map((s) => `• ${s.name} (${s.source}) — ${s.description}`);
+            await ctx.reply(lines.join("\n"));
+        }
+    });
+    bot.command("workers", async (ctx) => {
+        const workers = Array.from(getWorkers().values());
+        if (workers.length === 0) {
+            await ctx.reply("No active worker sessions.");
+        }
+        else {
+            const lines = workers.map((w) => `• ${w.name} (${w.workingDir}) — ${w.status}`);
+            await ctx.reply(lines.join("\n"));
+        }
+    });
+    bot.command("restart", async (ctx) => {
+        await ctx.reply("⏳ Restarting Max...");
+        setTimeout(() => {
+            restartDaemon().catch((err) => {
+                console.error("[max] Restart failed:", err);
+            });
+        }, 500);
+    });
+    bot.command("auto", async (ctx) => {
+        const current = getRouterConfig();
+        const newState = !current.enabled;
+        updateRouterConfig({ enabled: newState });
+        const label = newState
+            ? "⚡ Auto mode on"
+            : `Auto mode off · using ${config.copilotModel}`;
+        await ctx.reply(label);
+    });
+    // Handle all text messages
+    bot.on("message:text", async (ctx) => {
+        await handleTelegramTurn(ctx, ctx.message.text);
+    });
+    bot.on("message:photo", async (ctx) => {
+        const photo = ctx.message.photo.at(-1);
+        if (!photo) {
+            await ctx.reply("I couldn't find a usable photo in that message.");
+            return;
+        }
+        const prompt = ctx.message.caption?.trim() || "Please analyze the attached image.";
+        await handleTelegramImageMessage(ctx, photo.file_id, prompt, `telegram-photo-${photo.file_unique_id}.jpg`);
+    });
+    bot.on("message:document", async (ctx) => {
+        const document = ctx.message.document;
+        if (!document.mime_type?.startsWith("image/")) {
+            return;
+        }
+        const extension = extname(document.file_name || "") || ".png";
+        const prompt = ctx.message.caption?.trim() || "Please analyze the attached image.";
+        await handleTelegramImageMessage(ctx, document.file_id, prompt, document.file_name || `telegram-image-${document.file_unique_id}${extension}`);
+    });
+    return bot;
+}
+export async function startBot() {
+    if (!bot)
+        throw new Error("Bot not created");
+    console.log("[max] Telegram bot starting...");
+    bot.start({
+        onStart: () => console.log("[max] Telegram bot connected"),
+    }).catch((err) => {
+        if (err?.error_code === 401) {
+            console.error("[max] ⚠️ Telegram bot token is invalid or expired. Run 'max setup' and re-enter your bot token from @BotFather.");
+        }
+        else if (err?.error_code === 409) {
+            console.error("[max] ⚠️ Another bot instance is already running with this token. Stop the other instance first.");
+        }
+        else {
+            console.error("[max] ❌ Telegram bot failed to start:", err?.message || err);
+        }
+    });
+}
+export async function stopBot() {
+    if (bot) {
+        await bot.stop();
+    }
+}
+/** Send an unsolicited message to the authorized user (for background task completions). */
+export async function sendProactiveMessage(text) {
+    if (!bot || config.authorizedUserId === undefined)
+        return;
+    const formatted = toTelegramMarkdown(text);
+    const chunks = chunkMessage(formatted);
+    const fallbackChunks = chunkMessage(text);
+    for (let i = 0; i < chunks.length; i++) {
+        try {
+            await bot.api.sendMessage(config.authorizedUserId, chunks[i], { parse_mode: "MarkdownV2" });
+        }
+        catch {
+            try {
+                await bot.api.sendMessage(config.authorizedUserId, fallbackChunks[i] ?? chunks[i]);
+            }
+            catch {
+                // Bot may not be connected yet
+            }
+        }
+    }
+}
+/** Send a photo to the authorized user. Accepts a file path or URL. */
+export async function sendPhoto(photo, caption) {
+    if (!bot || config.authorizedUserId === undefined)
+        return;
+    try {
+        const { InputFile } = await import("grammy");
+        const input = photo.startsWith("http") ? photo : new InputFile(photo);
+        await bot.api.sendPhoto(config.authorizedUserId, input, {
+            caption,
+        });
+    }
+    catch (err) {
+        console.error("[max] Failed to send photo:", err instanceof Error ? err.message : err);
+        throw err;
+    }
+}
+//# sourceMappingURL=bot.js.map

package/dist/telegram/formatter.js

@@ -0,0 +1,96 @@
+const TELEGRAM_MAX_LENGTH = 4096;
+/**
+ * Split a long message into chunks that fit within Telegram's message limit.
+ * Tries to split at newlines, then spaces, falling back to hard cuts.
+ */
+export function chunkMessage(text) {
+    if (text.length <= TELEGRAM_MAX_LENGTH) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= TELEGRAM_MAX_LENGTH) {
+            chunks.push(remaining);
+            break;
+        }
+        let splitAt = remaining.lastIndexOf("\n", TELEGRAM_MAX_LENGTH);
+        if (splitAt < TELEGRAM_MAX_LENGTH * 0.3) {
+            splitAt = remaining.lastIndexOf(" ", TELEGRAM_MAX_LENGTH);
+        }
+        if (splitAt < TELEGRAM_MAX_LENGTH * 0.3) {
+            splitAt = TELEGRAM_MAX_LENGTH;
+        }
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).trimStart();
+    }
+    return chunks;
+}
+/**
+ * Escape special characters for Telegram MarkdownV2 plain text segments.
+ */
+function escapeSegment(text) {
+    return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+}
+/**
+ * Convert a markdown table into a readable mobile-friendly list.
+ * Returns already-escaped MarkdownV2 text ready to be stashed.
+ * *Casa del Poeta* — $383 · ⭐ 4.89
+ */
+function convertTable(table) {
+    const rows = table.trim().split("\n").filter(row => !/^\|[-| :]+\|$/.test(row.trim()));
+    const parsed = rows.map(row => row.split("|").map(c => c.trim()).filter(Boolean));
+    if (parsed.length === 0)
+        return "";
+    // Skip header row, format data rows as: *first col* — rest · rest
+    const dataRows = parsed.length > 1 ? parsed.slice(1) : parsed;
+    return dataRows.map(cols => {
+        if (cols.length === 0)
+            return "";
+        const first = `*${escapeSegment(cols[0])}*`;
+        const rest = cols.slice(1).map(c => escapeSegment(c)).join(" · ");
+        return rest ? `${first} — ${rest}` : first;
+    }).join("\n");
+}
+/**
+ * Convert standard markdown from the AI into Telegram MarkdownV2.
+ * Handles bold, italic, code blocks, headers, tables, and horizontal rules.
+ */
+export function toTelegramMarkdown(text) {
+    // 1. Stash code blocks (protect from processing)
+    const stash = [];
+    const stashToken = (s) => { stash.push(s); return `\x00STASH${stash.length - 1}\x00`; };
+    let out = text;
+    // Stash fenced code blocks
+    out = out.replace(/```([a-z]*)\n?([\s\S]*?)```/g, (_m, lang, code) => stashToken("```" + (lang || "") + "\n" + code.trim() + "\n```"));
+    // Stash inline code
+    out = out.replace(/`([^`\n]+)`/g, (_m, code) => stashToken("`" + code + "`"));
+    // 2. Convert tables before any escaping — stash result to avoid double-escaping
+    out = out.replace(/(?:^\|.+\|[ \t]*$\n?)+/gm, (table) => stashToken(convertTable(table) + "\n"));
+    // 3. Convert headers → bold
+    out = out.replace(/^#{1,6}\s+(.+)$/gm, (_m, title) => `**${title.trim()}**`);
+    // 4. Remove horizontal rules
+    out = out.replace(/^[-*_]{3,}\s*$/gm, "");
+    // 5. Extract bold/italic markers before escaping
+    const boldParts = [];
+    out = out.replace(/\*\*(.+?)\*\*/g, (_m, inner) => {
+        boldParts.push(inner);
+        return `\x00BOLD${boldParts.length - 1}\x00`;
+    });
+    const italicParts = [];
+    out = out.replace(/\*(.+?)\*/g, (_m, inner) => {
+        italicParts.push(inner);
+        return `\x00ITALIC${italicParts.length - 1}\x00`;
+    });
+    // 6. Escape everything that remains
+    out = escapeSegment(out);
+    // 7. Restore bold and italic with escaped inner text
+    out = out.replace(/\x00BOLD(\d+)\x00/g, (_m, i) => `*${escapeSegment(boldParts[+i])}*`);
+    out = out.replace(/\x00ITALIC(\d+)\x00/g, (_m, i) => `_${escapeSegment(italicParts[+i])}_`);
+    // 8. Restore stashed code blocks/inline code
+    out = out.replace(/\x00STASH(\d+)\x00/g, (_m, i) => stash[+i]);
+    // 9. Clean up excessive blank lines
+    out = out.replace(/\n{3,}/g, "\n\n");
+    return out.trim();
+}
+//# sourceMappingURL=formatter.js.map