@offerpilot/axiomruntime 0.0.1

package/dist/telegram/index.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { fork } from "node:child_process";
+import fs from "node:fs/promises";
+import { getTelegramBotPidPath, getTelegramPidPath } from "../core/config/paths.js";
+import { createBot } from "./bot.js";
+import { writeTelegramLog } from "./log.js";
+const botName = process.env.AI_TELEGRAM_BOT_NAME || "";
+function resolvePidPath() {
+    return botName ? getTelegramBotPidPath(botName) : getTelegramPidPath();
+}
+async function main() {
+    const runtime = await createBot(botName || undefined);
+    const pidPath = resolvePidPath();
+    await fs.writeFile(pidPath, `${process.pid}\n`, "utf8");
+    await writeTelegramLog({
+        action: "bot_start",
+        message: `Telegram bot started with PID ${process.pid}`,
+        metadata: {
+            allowedUsers: runtime.config.allowedUserIds.length,
+            defaultEngine: runtime.config.defaultEngine
+        }
+    });
+    const stop = async (signal, restart = false) => {
+        await writeTelegramLog({ action: "bot_stop", message: `Telegram bot stopping after ${signal}` });
+        runtime.engines.claude.abort(Number.NaN);
+        runtime.engines.codex.abort(Number.NaN);
+        await runtime.bot.stop();
+        runtime.store.close();
+        try {
+            await fs.unlink(resolvePidPath());
+        }
+        catch {
+            // PID file may already be removed by CLI stop.
+        }
+        if (restart) {
+            const entry = process.argv[1];
+            if (!entry)
+                throw new Error("Cannot restart Telegram bot: entry path is unavailable.");
+            const replacement = fork(entry, [], {
+                detached: true,
+                stdio: "ignore",
+                env: { ...process.env, AI_GATEWAY_SOURCE: "telegram-restart" }
+            });
+            replacement.unref();
+            if (replacement.connected)
+                replacement.disconnect();
+            await writeTelegramLog({
+                action: "bot_restart_spawned",
+                message: `Telegram bot replacement started with PID ${replacement.pid ?? "unknown"}`
+            });
+        }
+    };
+    process.once("SIGTERM", () => {
+        void stop("SIGTERM").finally(() => process.exit(0));
+    });
+    process.once("SIGINT", () => {
+        void stop("SIGINT").finally(() => process.exit(0));
+    });
+    process.once("SIGHUP", () => {
+        void stop("SIGHUP", true)
+            .then(() => process.exit(0))
+            .catch(async (error) => {
+            await writeTelegramLog({
+                level: "error",
+                action: "bot_restart_failed",
+                message: error instanceof Error ? error.message : String(error)
+            });
+            process.exit(1);
+        });
+    });
+    await runtime.bot.start({
+        drop_pending_updates: false,
+        onStart: (botInfo) => {
+            void writeTelegramLog({
+                action: "polling_started",
+                message: `Telegram polling started as @${botInfo.username}`,
+                metadata: { username: botInfo.username }
+            });
+        }
+    });
+}
+main().catch(async (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    await writeTelegramLog({ level: "error", action: "bot_fatal", message });
+    try {
+        await fs.unlink(resolvePidPath());
+    }
+    catch {
+        // Ignore cleanup failures during fatal startup errors.
+    }
+    console.error(message);
+    process.exitCode = 1;
+});

package/dist/telegram/interaction/approval.js

@@ -0,0 +1,108 @@
+import { escapeHtml, truncateText } from "./formatter.js";
+import { buildApprovalKeyboard } from "./keyboards.js";
+const TIMEOUT_MS = 5 * 60 * 1000;
+const ALWAYS_CONFIRM_PATTERNS = [
+    /rm\s+(-rf?|--recursive)/i,
+    /git\s+push\s+.*--force/i,
+    /git\s+reset\s+--hard/i,
+    /DROP\s+(TABLE|DATABASE)/i,
+    /sudo\s+/i,
+    /chmod\s+777/i,
+    />\s*\/dev\//i
+];
+export class ApprovalManager {
+    bot;
+    pending = new Map();
+    constructor(bot) {
+        this.bot = bot;
+    }
+    async request(chatId, req) {
+        const message = await this.bot.api.sendMessage(chatId, formatPermissionMessage(req), {
+            parse_mode: "HTML",
+            reply_markup: buildApprovalKeyboard(req.id)
+        });
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(req.id);
+                resolve(false);
+                void this.markExpired(chatId, message.message_id);
+            }, TIMEOUT_MS);
+            this.pending.set(req.id, {
+                id: req.id,
+                chatId,
+                messageId: message.message_id,
+                resolve,
+                timeout
+            });
+        });
+    }
+    resolve(id, approved) {
+        const entry = this.pending.get(id);
+        if (!entry)
+            return false;
+        clearTimeout(entry.timeout);
+        this.pending.delete(id);
+        entry.resolve(approved);
+        void this.markResolved(entry, approved);
+        return true;
+    }
+    resolveAll(chatId, approved) {
+        let count = 0;
+        for (const [id, entry] of this.pending) {
+            if (entry.chatId === chatId) {
+                clearTimeout(entry.timeout);
+                this.pending.delete(id);
+                entry.resolve(approved);
+                void this.markResolved(entry, approved);
+                count += 1;
+            }
+        }
+        return count;
+    }
+    hasPending(chatId) {
+        return [...this.pending.values()].some((entry) => entry.chatId === chatId);
+    }
+    async markResolved(entry, approved) {
+        if (!entry.messageId)
+            return;
+        try {
+            await this.bot.api.editMessageReplyMarkup(entry.chatId, entry.messageId, {
+                reply_markup: undefined
+            });
+            await this.bot.api.sendMessage(entry.chatId, approved ? "Permission allowed." : "Permission denied.");
+        }
+        catch {
+            // Telegram messages may be gone or no longer editable.
+        }
+    }
+    async markExpired(chatId, messageId) {
+        try {
+            await this.bot.api.editMessageReplyMarkup(chatId, messageId, { reply_markup: undefined });
+            await this.bot.api.sendMessage(chatId, "Permission request timed out.");
+        }
+        catch {
+            // Best-effort UI cleanup.
+        }
+    }
+}
+export function requiresDangerousConfirmation(command) {
+    return ALWAYS_CONFIRM_PATTERNS.some((pattern) => pattern.test(command));
+}
+export function formatPermissionMessage(req) {
+    const lines = [
+        "<b>Permission request</b>",
+        "",
+        `tool: <code>${escapeHtml(req.tool)}</code>`
+    ];
+    if (req.command) {
+        lines.push("command:", `<pre>${escapeHtml(truncateText(req.command, 300))}</pre>`);
+    }
+    if (req.filePath) {
+        lines.push(`file: <code>${escapeHtml(req.filePath)}</code>`);
+    }
+    if (req.description) {
+        lines.push("", escapeHtml(truncateText(req.description, 300)));
+    }
+    lines.push("", "<i>Automatically denied after 5 minutes.</i>");
+    return lines.join("\n");
+}

package/dist/telegram/interaction/command-menu.js

@@ -0,0 +1,253 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { writeTelegramLog } from "../log.js";
+const MAX_TELEGRAM_COMMANDS = 100;
+const BASE_COMMANDS = [
+    { command: "claude", description: "使用 Claude Code", prompt: "/claude" },
+    { command: "codex", description: "使用 Codex", prompt: "/codex" },
+    { command: "reset", description: "重置会话信息", prompt: "/reset" },
+    { command: "fresh", description: "清空聊天窗口", prompt: "/fresh" },
+    { command: "cwd", description: "查看或切换工作路径", prompt: "/cwd" },
+    { command: "config", description: "查看或编辑 Bot 配置", prompt: "/config" },
+    { command: "provider", description: "管理 AI Provider", prompt: "/provider" },
+    { command: "usage", description: "查看当前会话额度", prompt: "/usage" },
+    { command: "remember", description: "保存一条 Bot 记忆", prompt: "/remember" },
+    { command: "forget", description: "删除 Bot 记忆", prompt: "/forget" },
+    { command: "memories", description: "查看 Bot 记忆", prompt: "/memories" },
+    { command: "memory", description: "管理 Bot 记忆", prompt: "/memory" },
+    { command: "pin", description: "固定一条重要对话", prompt: "/pin" },
+    { command: "unpin", description: "取消固定对话", prompt: "/unpin" },
+    { command: "command", description: "注册自定义命令", prompt: "/__register_command" },
+    { command: "terminal", description: "执行终端命令", prompt: "/terminal" },
+    { command: "restart", description: "重启 Bot", prompt: "/restart" },
+    { command: "help", description: "查看帮助", prompt: "/help" }
+];
+const BUILTIN_CLI_COMMANDS = {
+    claude: [
+        { command: "add_dir", description: "Claude Code: add working directories", prompt: "/add-dir" },
+        { command: "agents", description: "Claude Code: manage agents", prompt: "/agents" },
+        { command: "clear", description: "Claude Code: clear conversation", prompt: "/clear" },
+        { command: "compact", description: "Claude Code: compact context", prompt: "/compact" },
+        { command: "config", description: "Claude Code: open config", prompt: "/config" },
+        { command: "cost", description: "Claude Code: show cost", prompt: "/cost" },
+        { command: "doctor", description: "Claude Code: health check", prompt: "/doctor" },
+        { command: "help_claude", description: "Claude Code: slash command help", prompt: "/help" },
+        { command: "ide", description: "Claude Code: manage IDE connection", prompt: "/ide" },
+        { command: "init", description: "Claude Code: initialize project memory", prompt: "/init" },
+        { command: "login", description: "Claude Code: login", prompt: "/login" },
+        { command: "logout", description: "Claude Code: logout", prompt: "/logout" },
+        { command: "mcp", description: "Claude Code: manage MCP", prompt: "/mcp" },
+        { command: "memory", description: "Claude Code: edit memory", prompt: "/memory" },
+        { command: "model", description: "Claude Code: switch model", prompt: "/model" },
+        { command: "permissions", description: "Claude Code: manage permissions", prompt: "/permissions" },
+        { command: "pr_comments", description: "Claude Code: view PR comments", prompt: "/pr-comments" },
+        { command: "resume", description: "Claude Code: resume conversation", prompt: "/resume" },
+        { command: "review", description: "Claude Code: review changes", prompt: "/review" },
+        { command: "status", description: "Claude Code: show status", prompt: "/status" },
+        { command: "terminal_setup", description: "Claude Code: terminal setup", prompt: "/terminal-setup" },
+        { command: "vim", description: "Claude Code: toggle vim mode", prompt: "/vim" }
+    ],
+    codex: [
+        { command: "clear", description: "Codex: clear conversation", prompt: "/clear" },
+        { command: "compact", description: "Codex: compact context", prompt: "/compact" },
+        { command: "help_codex", description: "Codex: slash command help", prompt: "/help" },
+        { command: "init", description: "Codex: initialize project instructions", prompt: "/init" },
+        { command: "model", description: "Codex: switch model", prompt: "/model" },
+        { command: "new", description: "Codex: new conversation", prompt: "/new" },
+        { command: "review", description: "Codex: review changes", prompt: "/review" },
+        { command: "status", description: "Codex: show status", prompt: "/status" }
+    ]
+};
+export function getBaseBotCommands() {
+    return BASE_COMMANDS.map(toBotCommand);
+}
+export function getChatBotCommands(engine, customCommands = []) {
+    return getCommandMappings(engine, customCommands).map(toBotCommand).slice(0, MAX_TELEGRAM_COMMANDS);
+}
+export function getCommandMappings(engine, customCommands = []) {
+    const custom = customCommands.map((c) => ({
+        command: c.name,
+        description: c.description,
+        prompt: `/__custom_${c.name}`
+    }));
+    return mergeCommandMappings([
+        ...BASE_COMMANDS,
+        ...BUILTIN_CLI_COMMANDS[engine],
+        ...custom,
+        ...readConfiguredCommands(engine)
+    ]);
+}
+export function resolveMappedCommand(engine, command, customCommands = []) {
+    const normalized = normalizeTelegramCommandName(command);
+    return getCommandMappings(engine, customCommands).find((item) => item.command === normalized) ?? null;
+}
+export async function setDefaultCommandMenu(bot) {
+    await bot.api.setMyCommands(getBaseBotCommands());
+}
+export async function setChatCommandMenu(bot, chatId, engine, customCommands = []) {
+    await bot.api.setMyCommands(getChatBotCommands(engine, customCommands), {
+        scope: { type: "chat", chat_id: chatId }
+    });
+}
+export async function resetChatCommandMenu(bot, chatId) {
+    await bot.api.deleteMyCommands({
+        scope: { type: "chat", chat_id: chatId }
+    });
+}
+export async function safeSetDefaultCommandMenu(bot) {
+    try {
+        await setDefaultCommandMenu(bot);
+    }
+    catch (error) {
+        await writeTelegramLog({
+            level: "warn",
+            action: "set_commands_failed",
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+}
+export async function safeSetChatCommandMenu(bot, chatId, engine, customCommands = []) {
+    try {
+        await setChatCommandMenu(bot, chatId, engine, customCommands);
+    }
+    catch (error) {
+        await writeTelegramLog({
+            level: "warn",
+            action: "set_chat_commands_failed",
+            message: error instanceof Error ? error.message : String(error),
+            metadata: { chatId, engine }
+        });
+    }
+}
+export async function safeResetChatCommandMenu(bot, chatId) {
+    try {
+        await resetChatCommandMenu(bot, chatId);
+    }
+    catch (error) {
+        await writeTelegramLog({
+            level: "warn",
+            action: "reset_chat_commands_failed",
+            message: error instanceof Error ? error.message : String(error),
+            metadata: { chatId }
+        });
+    }
+}
+export function parseTelegramCommand(text) {
+    const match = text.match(/^\/([A-Za-z0-9_]+)(?:@[A-Za-z0-9_]+)?(?:\s+([\s\S]*))?$/);
+    if (!match)
+        return null;
+    return {
+        command: normalizeTelegramCommandName(match[1] ?? ""),
+        args: (match[2] ?? "").trim()
+    };
+}
+function toBotCommand(mapping) {
+    return {
+        command: mapping.command,
+        description: truncateDescription(mapping.description)
+    };
+}
+function readConfiguredCommands(engine) {
+    const roots = getCommandRoots(engine);
+    const commands = [];
+    for (const root of roots) {
+        commands.push(...readCommandFiles(root, root));
+    }
+    return commands;
+}
+function getCommandRoots(engine) {
+    const home = os.homedir();
+    if (engine === "claude") {
+        return [
+            path.join(home, ".claude", "commands"),
+            path.join(home, ".config", "ai", "claude", "commands"),
+            path.join(home, ".config", "ai", "claude", "plugins", "cache"),
+            path.join(home, ".config", "ai", "claude", "plugins", "marketplaces")
+        ];
+    }
+    return [
+        path.join(home, ".codex", "commands"),
+        path.join(home, ".config", "ai", "codex", "commands"),
+        path.join(home, ".config", "ai", "codex", "plugins", "cache")
+    ];
+}
+function readCommandFiles(root, current, depth = 0) {
+    if (!fs.existsSync(current) || depth > 8)
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(current, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        const filePath = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...readCommandFiles(root, filePath, depth + 1));
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".md"))
+            continue;
+        const mapping = commandFromMarkdown(root, filePath);
+        if (mapping)
+            results.push(mapping);
+    }
+    return results;
+}
+function commandFromMarkdown(root, filePath) {
+    const originalName = path.basename(filePath, ".md");
+    const command = normalizeTelegramCommandName(originalName);
+    if (!command)
+        return null;
+    let description = `${originalName} command`;
+    try {
+        const content = fs.readFileSync(filePath, "utf8");
+        const title = content.match(/^#\s+(.+)$/m)?.[1]?.trim();
+        const descriptionLine = content.match(/^description:\s*["']?(.+?)["']?\s*$/im)?.[1]?.trim();
+        description = descriptionLine || title || description;
+    }
+    catch {
+        // Keep the fallback description when command metadata is unreadable.
+    }
+    return {
+        command,
+        description,
+        prompt: `/${originalName}`
+    };
+}
+function mergeCommandMappings(commands) {
+    const seen = new Set();
+    const result = [];
+    for (const command of commands) {
+        const normalized = normalizeTelegramCommandName(command.command);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        result.push({
+            command: normalized,
+            description: truncateDescription(command.description || command.prompt),
+            prompt: command.prompt
+        });
+    }
+    return result;
+}
+function normalizeTelegramCommandName(value) {
+    return value
+        .trim()
+        .replace(/^\//, "")
+        .replace(/\.md$/i, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9_]/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 32);
+}
+function truncateDescription(value) {
+    const normalized = value.replace(/\s+/g, " ").trim() || "Run command";
+    return normalized.length <= 120 ? normalized : `${normalized.slice(0, 117)}...`;
+}