appback-remoteagent 0.13.0

package/dist/services/bot-management-service.js

@@ -0,0 +1,626 @@
+import { execFile } from "node:child_process";
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export class BotManagementService {
+    dataDir;
+    serviceName;
+    restartHelperPath;
+    envPath;
+    pendingPath;
+    backupsDir;
+    constructor(dataDir, serviceName, restartHelperPath) {
+        this.dataDir = dataDir;
+        this.serviceName = serviceName;
+        this.restartHelperPath = restartHelperPath;
+        this.envPath = path.join(this.dataDir, ".env");
+        this.pendingPath = path.join(this.dataDir, "pending-bot-operation.json");
+        this.backupsDir = path.join(this.dataDir, "backups");
+    }
+    async listBots() {
+        const env = await this.readEnvConfig();
+        const bots = this.zipBots(env.tokens, env.usernames);
+        if (bots.length === 0) {
+            return "No Telegram bots are configured.";
+        }
+        return this.formatBots(bots, env.mainBotId);
+    }
+    async formatCurrentBotSummary(currentBotId) {
+        const env = await this.readEnvConfig();
+        const bots = this.zipBots(env.tokens, env.usernames);
+        const current = this.resolveBotSelector(bots, currentBotId);
+        const main = this.resolveMainBot(bots, env.mainBotId);
+        const currentLabel = current ? `@${current.username} (${current.id})` : currentBotId;
+        const mainLabel = main ? `@${main.username} (${main.id})` : "not configured";
+        const role = current && main && current.id === main.id ? "main" : "sub";
+        return [
+            `bot: ${currentLabel}${current ? ` [${role}]` : ""}`,
+            `mainBot: ${mainLabel}`,
+            `botCount: ${bots.length}`,
+            "sleep: awake",
+        ].join("\n");
+    }
+    async getPendingOperationNotice() {
+        const pending = await this.readPendingOperation();
+        if (!pending) {
+            return undefined;
+        }
+        return {
+            pending: pending.status === "pending",
+            message: this.formatPendingOperationMessage(pending),
+        };
+    }
+    async addBot(token, sourceBotId, sourceBotToken, chatId) {
+        await this.ensureSupported();
+        await this.assertNoPendingOperation();
+        const trimmed = token.trim();
+        if (!trimmed) {
+            throw new Error("Usage: /bot add <token>");
+        }
+        const target = await this.fetchBotIdentity(trimmed);
+        const env = await this.readEnvConfig();
+        const bots = this.zipBots(env.tokens, env.usernames);
+        const existing = bots.find((bot) => bot.token === trimmed
+            || bot.id === target.id
+            || bot.username.toLowerCase() === target.username.toLowerCase());
+        if (existing) {
+            throw new Error(`@${target.username} is already configured.`);
+        }
+        const tokens = [...env.tokens, trimmed];
+        const usernames = [...env.usernames, target.username];
+        const mainBotId = this.resolveMainBotId(this.zipBots(tokens, usernames), env.mainBotId);
+        const backupEnvPath = await this.backupEnv();
+        const pending = {
+            version: 1,
+            action: "add",
+            status: "pending",
+            requestedAt: new Date().toISOString(),
+            chatId,
+            replyToken: sourceBotToken,
+            notifyViaUsername: sourceBotId,
+            sourceBotId,
+            target: {
+                id: target.id,
+                username: target.username,
+            },
+            backupEnvPath,
+        };
+        try {
+            await this.writePendingOperation(pending);
+            await this.writeEnvConfig(env.lines, tokens, usernames, mainBotId);
+            await this.launchRestartJob();
+        }
+        catch (error) {
+            await this.restoreBackup(backupEnvPath).catch(() => undefined);
+            await this.clearPendingOperation().catch(() => undefined);
+            throw error;
+        }
+        return {
+            message: [
+                `Applying bot add for @${target.username} (${target.id}).`,
+                "The runtime will restart once and then report the result here.",
+            ].join("\n\n"),
+        };
+    }
+    async removeBot(selector, sourceBotId, sourceBotToken, chatId) {
+        await this.ensureSupported();
+        await this.assertNoPendingOperation();
+        const trimmed = selector.trim();
+        if (!trimmed) {
+            throw new Error("Usage: /bot remove <username|id>");
+        }
+        const env = await this.readEnvConfig();
+        const bots = this.zipBots(env.tokens, env.usernames);
+        const target = this.resolveBotSelector(bots, trimmed);
+        if (!target) {
+            throw new Error(`Bot was not found: ${trimmed}`);
+        }
+        if (bots.length <= 1) {
+            throw new Error("Cannot remove the last configured bot.");
+        }
+        const remainingBots = bots.filter((value) => value.token !== target.token);
+        const tokens = remainingBots.map((value) => value.token);
+        const usernames = remainingBots.map((value) => value.username);
+        const currentMain = this.resolveMainBot(bots, env.mainBotId);
+        const nextMainBotId = currentMain?.token === target.token
+            ? this.promoteMainBotAfterRemoval(bots, target)?.id.toString()
+            : this.resolveMainBotId(remainingBots, env.mainBotId);
+        const replyToken = tokens.includes(sourceBotToken) ? sourceBotToken : tokens[0];
+        const notifyViaUsername = remainingBots.find((bot) => bot.token === replyToken)?.username;
+        const backupEnvPath = await this.backupEnv();
+        const pending = {
+            version: 1,
+            action: "remove",
+            status: "pending",
+            requestedAt: new Date().toISOString(),
+            chatId,
+            replyToken,
+            notifyViaUsername,
+            sourceBotId,
+            target: {
+                id: target.id,
+                username: target.username,
+            },
+            backupEnvPath,
+        };
+        try {
+            await this.writePendingOperation(pending);
+            await this.writeEnvConfig(env.lines, tokens, usernames, nextMainBotId);
+            await this.launchRestartJob();
+        }
+        catch (error) {
+            await this.restoreBackup(backupEnvPath).catch(() => undefined);
+            await this.clearPendingOperation().catch(() => undefined);
+            throw error;
+        }
+        const promoted = nextMainBotId ? remainingBots.find((bot) => String(bot.id) === nextMainBotId) : undefined;
+        const mainLine = promoted && currentMain?.token === target.token
+            ? `Main bot will be promoted to @${promoted.username} (${promoted.id}).`
+            : undefined;
+        const notifyLine = replyToken === sourceBotToken || !notifyViaUsername
+            ? "The runtime will restart once and then report the result here."
+            : `The runtime will restart once and then report the result through @${notifyViaUsername}.`;
+        return {
+            message: [
+                `Applying bot removal for @${target.username} (${target.id}).`,
+                mainLine,
+                notifyLine,
+            ].filter(Boolean).join("\n\n"),
+        };
+    }
+    async setMainBot(selector) {
+        await this.ensureSupported();
+        await this.assertNoPendingOperation();
+        const trimmed = selector.trim();
+        if (!trimmed) {
+            throw new Error("Usage: /bot main <number|@username|id>");
+        }
+        const env = await this.readEnvConfig();
+        const bots = this.zipBots(env.tokens, env.usernames);
+        const target = this.resolveBotSelector(bots, trimmed);
+        if (!target) {
+            throw new Error(`Bot was not found: ${trimmed}`);
+        }
+        await this.writeEnvConfig(env.lines, env.tokens, env.usernames, String(target.id));
+        return {
+            message: [
+                `Set main bot to @${target.username} (${target.id}).`,
+                "",
+                this.formatBots(bots, String(target.id)),
+            ].join("\n"),
+        };
+    }
+    async doctorBots(sourceBotId, sourceBotToken, chatId) {
+        await this.ensureSupported();
+        await this.assertNoPendingOperation();
+        const env = await this.readEnvConfig();
+        const bots = this.zipBots(env.tokens, env.usernames);
+        if (bots.length === 0) {
+            return { message: "No Telegram bots are configured." };
+        }
+        const alive = [];
+        const dead = [];
+        const transient = [];
+        for (const bot of bots) {
+            try {
+                await this.fetchBotIdentity(bot.token);
+                alive.push(bot);
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                if (this.isDeadBotError(reason)) {
+                    dead.push(bot);
+                }
+                else {
+                    transient.push({ bot, reason });
+                    alive.push(bot);
+                }
+            }
+        }
+        if (dead.length === 0) {
+            return {
+                message: [
+                    "Bot doctor completed. No dead bots were removed.",
+                    `alive: ${alive.length}`,
+                    transient.length > 0 ? `temporary issues: ${transient.length}` : undefined,
+                    ...transient.map(({ bot, reason }) => `- @${bot.username} (${bot.id}): ${reason}`),
+                ].filter(Boolean).join("\n"),
+            };
+        }
+        if (alive.length === 0) {
+            throw new Error("Bot doctor found every configured bot dead. Refusing to remove the last usable bot.");
+        }
+        const tokens = alive.map((bot) => bot.token);
+        const usernames = alive.map((bot) => bot.username);
+        const mainBotId = this.resolveMainBotId(alive, env.mainBotId);
+        const replyToken = tokens.includes(sourceBotToken) ? sourceBotToken : tokens[0];
+        const notifyViaUsername = alive.find((bot) => bot.token === replyToken)?.username;
+        const backupEnvPath = await this.backupEnv();
+        const pending = {
+            version: 1,
+            action: "doctor",
+            status: "pending",
+            requestedAt: new Date().toISOString(),
+            chatId,
+            replyToken,
+            notifyViaUsername,
+            sourceBotId,
+            targets: dead.map((bot) => ({
+                id: bot.id,
+                username: bot.username,
+            })),
+            backupEnvPath,
+        };
+        try {
+            await this.writePendingOperation(pending);
+            await this.writeEnvConfig(env.lines, tokens, usernames, mainBotId);
+            await this.launchRestartJob();
+        }
+        catch (error) {
+            await this.restoreBackup(backupEnvPath).catch(() => undefined);
+            await this.clearPendingOperation().catch(() => undefined);
+            throw error;
+        }
+        return {
+            message: [
+                `Bot doctor removed ${dead.length} dead bot(s).`,
+                ...dead.map((bot) => `- @${bot.username} (${bot.id})`),
+                transient.length > 0 ? `Temporary issues were kept: ${transient.length}` : undefined,
+                "The runtime will restart once and then report the result.",
+            ].filter(Boolean).join("\n"),
+        };
+    }
+    async reloadBots(sourceBotId, sourceBotToken, chatId) {
+        await this.ensureSupported();
+        await this.assertNoPendingOperation();
+        const backupEnvPath = await this.backupEnv();
+        const pending = {
+            version: 1,
+            action: "reload",
+            status: "pending",
+            requestedAt: new Date().toISOString(),
+            chatId,
+            replyToken: sourceBotToken,
+            notifyViaUsername: sourceBotId,
+            sourceBotId,
+            backupEnvPath,
+        };
+        try {
+            await this.writePendingOperation(pending);
+            await this.launchRestartJob();
+        }
+        catch (error) {
+            await this.clearPendingOperation().catch(() => undefined);
+            throw error;
+        }
+        return {
+            message: "Restarting the runtime now. I will report the result here after it comes back.",
+        };
+    }
+    async reportPendingOperationResult() {
+        const pending = await this.readPendingOperation();
+        if (!pending) {
+            return;
+        }
+        const env = await this.readEnvConfig().catch(() => undefined);
+        const bots = env ? this.zipBots(env.tokens, env.usernames) : [];
+        const mainBotId = this.resolveMainBotId(bots, env?.mainBotId);
+        const listLines = bots.length > 0
+            ? this.formatBotListLines(bots, mainBotId).map((line) => `- ${line.replace(/^\d+\.\s*/, "")}`)
+            : ["- none"];
+        const lines = pending.status === "rolled_back"
+            ? [
+                "Bot configuration failed and was rolled back.",
+                `Action: ${pending.action}`,
+                pending.target ? `Target: @${pending.target.username} (${pending.target.id})` : undefined,
+                this.formatPendingTargets(pending),
+                pending.reason ? `Reason: ${pending.reason}` : undefined,
+                "Current configured bots:",
+                ...listLines,
+            ]
+            : [
+                "Bot configuration applied successfully.",
+                `Action: ${pending.action}`,
+                pending.target ? `Target: @${pending.target.username} (${pending.target.id})` : undefined,
+                this.formatPendingTargets(pending),
+                "Current configured bots:",
+                ...listLines,
+            ];
+        try {
+            await this.sendTelegramMessage(pending.replyToken, pending.chatId, lines.filter(Boolean).join("\n"));
+            await this.clearPendingOperation();
+            await fs.rm(pending.backupEnvPath, { force: true }).catch(() => undefined);
+        }
+        catch (error) {
+            console.error("Failed to report pending bot operation result:", error);
+        }
+    }
+    async assertNoPendingOperation() {
+        const pending = await this.readPendingOperation();
+        if (!pending || pending.status !== "pending") {
+            return;
+        }
+        throw new Error(this.formatPendingOperationMessage(pending));
+    }
+    formatPendingOperationMessage(pending) {
+        const actionLine = `Action: ${pending.action}`;
+        const targetLine = pending.target
+            ? `Target: @${pending.target.username} (${pending.target.id})`
+            : undefined;
+        const targetsLine = this.formatPendingTargets(pending);
+        if (pending.status === "rolled_back") {
+            return [
+                "The last bot configuration change failed and was rolled back.",
+                actionLine,
+                targetLine,
+                targetsLine,
+                pending.reason ? `Reason: ${pending.reason}` : undefined,
+            ].filter(Boolean).join("\n");
+        }
+        return [
+            "A bot configuration change is still being applied.",
+            actionLine,
+            targetLine,
+            targetsLine,
+            "Wait for the \"Bot configuration applied successfully.\" message, then try again.",
+        ].filter(Boolean).join("\n");
+    }
+    formatPendingTargets(pending) {
+        if (!pending.targets || pending.targets.length === 0) {
+            return undefined;
+        }
+        return `Targets: ${pending.targets.map((target) => `@${target.username} (${target.id})`).join(", ")}`;
+    }
+    async ensureSupported() {
+        if (process.platform === "win32") {
+            throw new Error("Bot management restart is not supported on this Windows runtime.");
+        }
+        await fs.access(this.restartHelperPath).catch(() => {
+            throw new Error(`Restart helper is missing: ${this.restartHelperPath}`);
+        });
+    }
+    async launchRestartJob() {
+        const unitName = `remoteagent-bot-op-${Date.now()}`;
+        try {
+            const { stderr } = await execFileAsync("sudo", [
+                "-n",
+                "systemd-run",
+                "--unit",
+                unitName,
+                "--collect",
+                "--service-type=exec",
+                this.restartHelperPath,
+                this.serviceName,
+                this.dataDir,
+            ]);
+            const output = stderr?.trim();
+            if (output) {
+                console.error("bot restart helper stderr:", output);
+            }
+            return;
+        }
+        catch (error) {
+            if (!this.shouldFallbackToUserRestart(error)) {
+                throw error;
+            }
+        }
+        const child = spawn(this.restartHelperPath, [this.serviceName, this.dataDir], {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+    }
+    shouldFallbackToUserRestart(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return /sudo: a password is required/i.test(message)
+            || /command not found/i.test(message)
+            || /systemd-run/i.test(message);
+    }
+    isDeadBotError(reason) {
+        return /unauthorized/i.test(reason)
+            || /not found/i.test(reason)
+            || /invalid token/i.test(reason);
+    }
+    async fetchBotIdentity(token) {
+        const url = `https://api.telegram.org/bot${token}/getMe`;
+        const { stdout, stderr } = await execFileAsync("curl", ["-sS", "--max-time", "20", url]);
+        if (stderr?.trim()) {
+            console.error("curl stderr for getMe:", stderr.trim());
+        }
+        const payload = JSON.parse(stdout);
+        if (!payload.ok || !payload.result?.id || !payload.result.username) {
+            throw new Error(payload.description || "Telegram getMe failed for the supplied bot token.");
+        }
+        return {
+            index: 0,
+            token,
+            id: payload.result.id,
+            username: payload.result.username,
+        };
+    }
+    async readEnvConfig() {
+        const text = await fs.readFile(this.envPath, "utf8");
+        const lines = text.split(/\r?\n/);
+        const tokenLine = lines.find((line) => line.startsWith("TELEGRAM_BOT_TOKENS="));
+        const singleTokenLine = lines.find((line) => line.startsWith("TELEGRAM_BOT_TOKEN="));
+        const usernameLine = lines.find((line) => line.startsWith("TELEGRAM_BOT_USERNAMES="));
+        const mainBotLine = lines.find((line) => line.startsWith("TELEGRAM_MAIN_BOT_ID="));
+        const tokens = tokenLine
+            ? this.parseCsv(tokenLine.slice("TELEGRAM_BOT_TOKENS=".length))
+            : singleTokenLine
+                ? [singleTokenLine.slice("TELEGRAM_BOT_TOKEN=".length).trim()].filter(Boolean)
+                : [];
+        const usernames = usernameLine ? this.parseCsv(usernameLine.slice("TELEGRAM_BOT_USERNAMES=".length)) : [];
+        return {
+            lines,
+            tokens,
+            usernames,
+            mainBotId: mainBotLine?.slice("TELEGRAM_MAIN_BOT_ID=".length).trim() || undefined,
+        };
+    }
+    async writeEnvConfig(originalLines, tokens, usernames, mainBotId) {
+        const normalizedUsernames = this.normalizeUsernames(tokens, usernames);
+        const normalizedMainBotId = this.resolveMainBotId(this.zipBots(tokens, normalizedUsernames), mainBotId);
+        const nextLines = [];
+        let hasMulti = false;
+        let hasSingle = false;
+        let hasUsernames = false;
+        let hasMainBot = false;
+        for (const line of originalLines) {
+            if (line.startsWith("TELEGRAM_BOT_TOKENS=")) {
+                nextLines.push(`TELEGRAM_BOT_TOKENS=${tokens.join(",")}`);
+                hasMulti = true;
+                continue;
+            }
+            if (line.startsWith("TELEGRAM_BOT_TOKEN=")) {
+                nextLines.push(`TELEGRAM_BOT_TOKEN=${tokens[0] ?? ""}`);
+                hasSingle = true;
+                continue;
+            }
+            if (line.startsWith("TELEGRAM_BOT_USERNAMES=")) {
+                nextLines.push(`TELEGRAM_BOT_USERNAMES=${normalizedUsernames.join(",")}`);
+                hasUsernames = true;
+                continue;
+            }
+            if (line.startsWith("TELEGRAM_MAIN_BOT_ID=")) {
+                if (normalizedMainBotId) {
+                    nextLines.push(`TELEGRAM_MAIN_BOT_ID=${normalizedMainBotId}`);
+                }
+                hasMainBot = true;
+                continue;
+            }
+            nextLines.push(line);
+        }
+        if (!hasMulti) {
+            nextLines.unshift(`TELEGRAM_BOT_TOKENS=${tokens.join(",")}`);
+        }
+        if (!hasSingle) {
+            nextLines.unshift(`TELEGRAM_BOT_TOKEN=${tokens[0] ?? ""}`);
+        }
+        if (!hasUsernames) {
+            nextLines.unshift(`TELEGRAM_BOT_USERNAMES=${normalizedUsernames.join(",")}`);
+        }
+        if (!hasMainBot && normalizedMainBotId) {
+            nextLines.unshift(`TELEGRAM_MAIN_BOT_ID=${normalizedMainBotId}`);
+        }
+        const output = `${nextLines.filter((line, index, all) => !(index === all.length - 1 && line === "")).join("\n")}\n`;
+        await fs.writeFile(this.envPath, output, "utf8");
+    }
+    normalizeUsernames(tokens, usernames) {
+        return tokens.map((token, index) => usernames[index]?.trim() || `bot_${this.tokenId(token)}`);
+    }
+    zipBots(tokens, usernames) {
+        const normalizedUsernames = this.normalizeUsernames(tokens, usernames);
+        return tokens.map((token, index) => ({
+            index,
+            token,
+            id: this.tokenId(token),
+            username: normalizedUsernames[index],
+        }));
+    }
+    resolveBotSelector(bots, selector) {
+        const normalized = selector.trim();
+        if (/^\d+$/.test(normalized)) {
+            const index = Number.parseInt(normalized, 10);
+            if (index >= 1 && index <= bots.length) {
+                return bots[index - 1];
+            }
+        }
+        const withoutAt = normalized.startsWith("@") ? normalized.slice(1) : normalized;
+        return bots.find((bot) => bot.username.toLowerCase() === withoutAt.toLowerCase()
+            || String(bot.id) === withoutAt
+            || bot.token === normalized);
+    }
+    formatBots(bots, mainBotId) {
+        if (bots.length === 0) {
+            return "No Telegram bots are configured.";
+        }
+        return [
+            `Configured bots (${bots.length})`,
+            ...this.formatBotListLines(bots, mainBotId),
+        ].join("\n");
+    }
+    formatBotListLines(bots, explicitMainBotId) {
+        const mainBotId = this.resolveMainBotId(bots, explicitMainBotId);
+        return bots.map((bot, index) => {
+            const suffix = String(bot.id) === mainBotId ? " [main]" : "";
+            return `${index + 1}. @${bot.username} (${bot.id})${suffix}`;
+        });
+    }
+    resolveMainBot(bots, mainBotId) {
+        if (bots.length === 0) {
+            return undefined;
+        }
+        const explicit = mainBotId ? bots.find((bot) => String(bot.id) === mainBotId) : undefined;
+        return explicit ?? bots[0];
+    }
+    resolveMainBotId(bots, mainBotId) {
+        return this.resolveMainBot(bots, mainBotId)?.id.toString();
+    }
+    promoteMainBotAfterRemoval(bots, removed) {
+        const remaining = bots.filter((bot) => bot.token !== removed.token);
+        return remaining[removed.index] ?? remaining[0];
+    }
+    async listConfiguredBots() {
+        const env = await this.readEnvConfig();
+        return this.zipBots(env.tokens, env.usernames);
+    }
+    tokenId(token) {
+        return Number.parseInt(token.split(":", 1)[0] ?? "0", 10);
+    }
+    parseCsv(value) {
+        return value
+            .split(/[\r\n,]+/)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    async backupEnv() {
+        await fs.mkdir(this.backupsDir, { recursive: true });
+        const backupPath = path.join(this.backupsDir, `telegram-bots-${Date.now()}.env.bak`);
+        await fs.copyFile(this.envPath, backupPath);
+        return backupPath;
+    }
+    async restoreBackup(backupPath) {
+        await fs.copyFile(backupPath, this.envPath);
+    }
+    async writePendingOperation(operation) {
+        await fs.writeFile(this.pendingPath, JSON.stringify(operation, null, 2), "utf8");
+    }
+    async readPendingOperation() {
+        const raw = await fs.readFile(this.pendingPath, "utf8").catch(() => undefined);
+        if (!raw?.trim()) {
+            return undefined;
+        }
+        return JSON.parse(raw);
+    }
+    async clearPendingOperation() {
+        await fs.rm(this.pendingPath, { force: true }).catch(() => undefined);
+    }
+    async sendTelegramMessage(token, chatId, text) {
+        const url = `https://api.telegram.org/bot${token}/sendMessage`;
+        const payload = JSON.stringify({
+            chat_id: chatId,
+            text,
+        });
+        const { stdout, stderr } = await execFileAsync("curl", [
+            "-sS",
+            "--max-time",
+            "20",
+            "-H",
+            "Content-Type: application/json",
+            "-d",
+            payload,
+            url,
+        ]);
+        if (stderr?.trim()) {
+            console.error("curl stderr for sendMessage:", stderr.trim());
+        }
+        const parsed = JSON.parse(stdout);
+        if (!parsed.ok) {
+            throw new Error(parsed.description || "sendMessage failed.");
+        }
+    }
+}