@mragentix/cli 4.2.37

package/dist/cli.js

@@ -0,0 +1,772 @@
+#!/usr/bin/env node
+// Drain performance entries to prevent buffer overflow warning from dependencies
+import { PerformanceObserver, performance } from "node:perf_hooks";
+new PerformanceObserver((list) => {
+    for (const entry of list.getEntries()) {
+        if (entry.entryType === "measure")
+            performance.clearMeasures(entry.name);
+        else if (entry.entryType === "mark")
+            performance.clearMarks(entry.name);
+    }
+}).observe({ entryTypes: ["measure", "mark"] });
+import { parseArgs } from "node:util";
+import fs from "node:fs";
+import readline from "node:readline/promises";
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import { renderApp } from "./ui/render.js";
+import { runJsonMode } from "./modes/json-mode.js";
+import { runRpcMode } from "./modes/rpc-mode.js";
+import { runServeMode } from "./modes/serve-mode.js";
+import { renderLoginSelector } from "./ui/login.js";
+import { renderSessionSelector } from "./ui/sessions.js";
+import { formatUserError } from "./utils/error-handler.js";
+import { AuthStorage } from "./core/auth-storage.js";
+import { SessionManager } from "./core/session-manager.js";
+import { ensureAppDirs, getAppPaths } from "./config.js";
+import { initLogger, log, closeLogger } from "./core/logger.js";
+import { buildSystemPrompt } from "./system-prompt.js";
+import { createTools } from "./tools/index.js";
+import { shouldCompact, compact } from "./core/compaction/compactor.js";
+import { setEstimatorModel } from "./core/compaction/token-estimator.js";
+import { getContextWindow } from "./core/model-registry.js";
+import { MCPClientManager, getMCPServers } from "./core/mcp/index.js";
+import { discoverAgents } from "./core/agents.js";
+import { loginAnthropic } from "./core/oauth/anthropic.js";
+import { loginOpenAI } from "./core/oauth/openai.js";
+import chalk from "chalk";
+import { checkAndAutoUpdate } from "./core/auto-update.js";
+const _require = createRequire(import.meta.url);
+const CLI_VERSION = _require("../package.json").version;
+function main() {
+    // Silent auto-update check (throttled, non-blocking on failure)
+    const updateMessage = checkAndAutoUpdate(CLI_VERSION);
+    if (updateMessage) {
+        console.error(chalk.hex("#60a5fa")(updateMessage));
+    }
+    // Handle subcommands before parseArgs
+    const subcommand = process.argv[2];
+    if (subcommand === "login") {
+        runLogin().catch((err) => {
+            log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
+            closeLogger();
+            process.stderr.write(formatUserError(err) + "\n");
+            process.exit(1);
+        });
+        return;
+    }
+    if (subcommand === "logout") {
+        runLogout().catch((err) => {
+            log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
+            closeLogger();
+            process.stderr.write(formatUserError(err) + "\n");
+            process.exit(1);
+        });
+        return;
+    }
+    if (subcommand === "sessions") {
+        process.argv.splice(2, 1);
+        runSessions().catch((err) => {
+            log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
+            closeLogger();
+            process.stderr.write(formatUserError(err) + "\n");
+            process.exit(1);
+        });
+        return;
+    }
+    if (subcommand === "telegram") {
+        runTelegramSetup().catch((err) => {
+            log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
+            closeLogger();
+            process.stderr.write(formatUserError(err) + "\n");
+            process.exit(1);
+        });
+        return;
+    }
+    if (subcommand === "serve") {
+        process.argv.splice(2, 1);
+        runServe().catch((err) => {
+            log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
+            closeLogger();
+            process.stderr.write(formatUserError(err) + "\n");
+            process.exit(1);
+        });
+        return;
+    }
+    if (subcommand === "continue") {
+        // Remove "continue" so parseArgs handles remaining flags
+        process.argv.splice(2, 1);
+    }
+    const { values, positionals } = parseArgs({
+        options: {
+            version: { type: "boolean", short: "v" },
+            json: { type: "boolean" },
+            rpc: { type: "boolean" },
+            provider: { type: "string" },
+            model: { type: "string" },
+            "max-turns": { type: "string" },
+            "system-prompt": { type: "string" },
+        },
+        allowPositionals: true,
+        strict: true,
+    });
+    if (values.version) {
+        console.log(CLI_VERSION);
+        process.exit(0);
+    }
+    // JSON mode — used by sub-agents
+    if (values.json) {
+        const message = positionals[0] ?? "";
+        const jsonProvider = (values.provider ?? "anthropic");
+        const jsonModel = values.model ?? "claude-opus-4-6";
+        const maxTurns = values["max-turns"] ? parseInt(values["max-turns"], 10) : undefined;
+        const systemPrompt = values["system-prompt"];
+        const cwd = process.cwd();
+        runJsonMode({
+            message,
+            provider: jsonProvider,
+            model: jsonModel,
+            cwd,
+            systemPrompt,
+            maxTurns,
+        }).catch((err) => {
+            process.stderr.write(formatUserError(err) + "\n");
+            process.exit(1);
+        });
+        return;
+    }
+    // RPC mode — headless JSON-over-stdio for IDE integrations
+    if (values.rpc) {
+        const rpcProvider = (values.provider ?? "anthropic");
+        const rpcModel = values.model ?? "claude-opus-4-6";
+        const systemPrompt = values["system-prompt"];
+        const cwd = process.cwd();
+        runRpcMode({
+            provider: rpcProvider,
+            model: rpcModel,
+            cwd,
+            systemPrompt,
+        }).catch((err) => {
+            process.stderr.write(formatUserError(err) + "\n");
+            process.exit(1);
+        });
+        return;
+    }
+    // Load saved settings for model/provider persistence
+    let savedProvider;
+    let savedModel;
+    let savedThinkingEnabled = false;
+    let savedTheme = "auto";
+    try {
+        const raw = JSON.parse(fs.readFileSync(getAppPaths().settingsFile, "utf-8"));
+        if (raw.defaultProvider)
+            savedProvider = raw.defaultProvider;
+        if (raw.defaultModel)
+            savedModel = raw.defaultModel;
+        if (raw.thinkingEnabled === true)
+            savedThinkingEnabled = true;
+        if (raw.theme === "dark" || raw.theme === "light" || raw.theme === "auto")
+            savedTheme = raw.theme;
+    }
+    catch {
+        // No settings file or invalid JSON — use defaults
+    }
+    const provider = savedProvider ?? "anthropic";
+    function getHardcodedDefault(p) {
+        if (p === "openai")
+            return "gpt-5.3-codex";
+        if (p === "glm")
+            return "glm-5";
+        if (p === "moonshot")
+            return "kimi-k2.5";
+        return "claude-opus-4-6";
+    }
+    const model = savedModel ?? getHardcodedDefault(provider);
+    const thinkingLevel = savedThinkingEnabled ? "medium" : undefined;
+    // Interactive mode (Ink TUI)
+    const cwd = process.cwd();
+    const continueRecent = subcommand === "continue";
+    runInkTUI({
+        provider,
+        model,
+        cwd,
+        thinkingLevel,
+        continueRecent,
+        theme: savedTheme,
+    }).catch((err) => {
+        log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
+        closeLogger();
+        process.stderr.write(formatUserError(err) + "\n");
+        process.exit(1);
+    });
+}
+// ── Ink TUI ───────────────────────────────────────────────
+async function runInkTUI(opts) {
+    const { provider, model, cwd } = opts;
+    // Set model for token estimation accuracy
+    setEstimatorModel(model);
+    // Resolve auth
+    const paths = await ensureAppDirs();
+    initLogger(paths.logFile, {
+        version: CLI_VERSION,
+        provider,
+        model,
+        thinking: opts.thinkingLevel,
+    });
+    const authStorage = new AuthStorage(paths.authFile);
+    await authStorage.load();
+    const creds = await authStorage.resolveCredentials(provider);
+    // Detect all logged-in providers and preload their credentials
+    const allProviders = ["anthropic", "openai", "glm", "moonshot"];
+    const loggedInProviders = [];
+    const credentialsByProvider = {};
+    for (const p of allProviders) {
+        const stored = await authStorage.getCredentials(p);
+        if (stored) {
+            loggedInProviders.push(p);
+            try {
+                const resolved = await authStorage.resolveCredentials(p);
+                credentialsByProvider[p] = {
+                    accessToken: resolved.accessToken,
+                    accountId: resolved.accountId,
+                };
+            }
+            catch {
+                // Token refresh failed — still mark as logged in
+            }
+        }
+    }
+    // Discover agents and build tools
+    const agents = await discoverAgents({
+        globalAgentsDir: paths.agentsDir,
+        projectDir: cwd,
+    });
+    // Build system prompt & tools (with sub-agent support)
+    const systemPrompt = await buildSystemPrompt(cwd);
+    const { tools, processManager } = createTools(cwd, { agents, provider, model });
+    // Connect MCP servers
+    const mcpManager = new MCPClientManager();
+    try {
+        const providerApiKey = provider === "glm" ? credentialsByProvider["glm"]?.accessToken : undefined;
+        const mcpTools = await mcpManager.connectAll(getMCPServers(provider, providerApiKey));
+        tools.push(...mcpTools);
+    }
+    catch (err) {
+        log("WARN", "mcp", `MCP initialization failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Kill all background processes on exit (synchronous — catches all exit paths)
+    process.on("exit", () => {
+        processManager.shutdownAll();
+        mcpManager.dispose().catch(() => { });
+    });
+    // Seed messages with system prompt
+    const messages = [{ role: "system", content: systemPrompt }];
+    // Session management — create or reuse session file
+    const sessionManager = new SessionManager(paths.sessionsDir);
+    let sessionPath;
+    let initialHistory;
+    // Determine which session to resume (explicit path or most recent)
+    const resumePath = opts.resumeSessionPath ??
+        (opts.continueRecent ? await sessionManager.getMostRecent(cwd) : null);
+    if (resumePath) {
+        try {
+            const loaded = await sessionManager.load(resumePath);
+            const loadedMessages = sessionManager.getMessages(loaded.entries);
+            if (loadedMessages.length > 0) {
+                messages.push(...loadedMessages);
+                sessionPath = resumePath;
+                log("INFO", "session", `Restored session`, {
+                    path: resumePath,
+                    messageCount: String(loadedMessages.length),
+                });
+                // Auto-compact on load if the restored session exceeds the context window.
+                // Without this, huge sessions (1M+ tokens) get loaded into memory and OOM.
+                const contextWindow = getContextWindow(model);
+                if (shouldCompact(messages, contextWindow, 0.8)) {
+                    log("INFO", "session", `Restored session exceeds context — auto-compacting`);
+                    const compacted = await compact(messages, {
+                        provider,
+                        model,
+                        apiKey: creds.accessToken,
+                        contextWindow,
+                    });
+                    // Replace messages array contents with compacted messages
+                    messages.length = 0;
+                    messages.push(...compacted.messages);
+                    log("INFO", "session", `Auto-compaction complete`, {
+                        before: String(compacted.result.originalCount),
+                        after: String(compacted.result.newCount),
+                    });
+                }
+                initialHistory = messagesToHistoryItems(loadedMessages);
+                initialHistory.push({
+                    kind: "info",
+                    text: `↻ Restored session (${loadedMessages.length} messages)`,
+                    id: `restore-info`,
+                });
+            }
+        }
+        catch {
+            // Session file corrupt or missing — start fresh
+        }
+    }
+    // Create a new session file if we didn't reuse one
+    if (!sessionPath) {
+        const session = await sessionManager.create(cwd, provider, model);
+        sessionPath = session.path;
+        log("INFO", "session", `New session created`, { path: sessionPath });
+    }
+    await renderApp({
+        provider,
+        model,
+        tools,
+        webSearch: true,
+        messages,
+        version: CLI_VERSION,
+        maxTokens: 16384,
+        thinking: opts.thinkingLevel,
+        apiKey: creds.accessToken,
+        accountId: creds.accountId,
+        cwd,
+        theme: opts.theme,
+        loggedInProviders,
+        credentialsByProvider,
+        initialHistory,
+        sessionsDir: paths.sessionsDir,
+        sessionPath,
+        processManager,
+        settingsFile: paths.settingsFile,
+        mcpManager,
+        authStorage,
+    });
+    closeLogger();
+}
+// ── Login ──────────────────────────────────────────────────
+async function runLogin() {
+    process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    const paths = await ensureAppDirs();
+    initLogger(paths.logFile, { version: CLI_VERSION });
+    log("INFO", "auth", "Login flow started");
+    const authStorage = new AuthStorage();
+    await authStorage.load();
+    // Phase 1: Ink-based provider selector
+    const provider = await renderLoginSelector(CLI_VERSION);
+    if (!provider) {
+        console.log(chalk.hex("#6b7280")("Login cancelled."));
+        return;
+    }
+    console.log(chalk.hex("#60a5fa").bold("\nLogging in to ") +
+        chalk.hex("#a78bfa")(displayName(provider)) +
+        chalk.hex("#60a5fa").bold("...\n"));
+    // Phase 2: OAuth flow (readline needed for Anthropic code paste)
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const callbacks = {
+            onOpenUrl: (url) => {
+                console.log(chalk.hex("#60a5fa").bold("Opening browser..."));
+                openBrowser(url);
+                console.log(chalk.hex("#6b7280")("\nIf the browser didn't open, visit:\n") +
+                    chalk.hex("#6b7280")(url) +
+                    "\n");
+            },
+            onPromptCode: async (message) => {
+                return rl.question(message + " ");
+            },
+            onStatus: (message) => {
+                console.log(chalk.hex("#6b7280")(message));
+            },
+        };
+        let creds;
+        if (provider === "glm" || provider === "moonshot") {
+            const keyLabel = provider === "glm" ? "Z.AI" : "Moonshot";
+            const apiKey = await rl.question(chalk.hex("#60a5fa")(`Paste your ${keyLabel} API key: `));
+            if (!apiKey.trim()) {
+                console.log(chalk.hex("#ef4444")("No API key provided. Login cancelled."));
+                return;
+            }
+            creds = {
+                accessToken: apiKey.trim(),
+                refreshToken: "",
+                expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000 * 100, // ~100 years
+            };
+        }
+        else {
+            creds =
+                provider === "anthropic" ? await loginAnthropic(callbacks) : await loginOpenAI(callbacks);
+        }
+        await authStorage.setCredentials(provider, creds);
+        log("INFO", "auth", `Login succeeded for ${displayName(provider)}`);
+        console.log(chalk.hex("#4ade80")(`\n✓ Logged in to ${displayName(provider)} successfully!`));
+    }
+    finally {
+        rl.close();
+        closeLogger();
+    }
+}
+// ── Logout ─────────────────────────────────────────────────
+async function runLogout() {
+    const paths = await ensureAppDirs();
+    initLogger(paths.logFile, { version: CLI_VERSION });
+    log("INFO", "auth", "Logout requested");
+    const authStorage = new AuthStorage();
+    await authStorage.load();
+    await authStorage.clearAll();
+    log("INFO", "auth", "Logout succeeded");
+    closeLogger();
+    console.log(chalk.green("Logged out successfully."));
+}
+// ── Sessions ──────────────────────────────────────────────
+async function runSessions() {
+    process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    const paths = await ensureAppDirs();
+    initLogger(paths.logFile, { version: CLI_VERSION });
+    log("INFO", "session", "Sessions selector started");
+    const cwd = process.cwd();
+    const selectedPath = await renderSessionSelector(paths.sessionsDir, cwd, CLI_VERSION);
+    if (!selectedPath) {
+        console.log(chalk.hex("#6b7280")("No session selected."));
+        closeLogger();
+        process.exit(0);
+    }
+    // Load saved settings for provider/model/theme
+    let savedProvider;
+    let savedModel;
+    let savedThinkingEnabled = false;
+    let savedTheme = "auto";
+    try {
+        const raw = JSON.parse(fs.readFileSync(paths.settingsFile, "utf-8"));
+        if (raw.defaultProvider)
+            savedProvider = raw.defaultProvider;
+        if (raw.defaultModel)
+            savedModel = raw.defaultModel;
+        if (raw.thinkingEnabled === true)
+            savedThinkingEnabled = true;
+        if (raw.theme === "dark" || raw.theme === "light" || raw.theme === "auto")
+            savedTheme = raw.theme;
+    }
+    catch {
+        // No settings file — use defaults
+    }
+    const provider = savedProvider ?? "anthropic";
+    function getDefault(p) {
+        if (p === "openai")
+            return "gpt-5.3-codex";
+        if (p === "glm")
+            return "glm-5";
+        if (p === "moonshot")
+            return "kimi-k2.5";
+        return "claude-opus-4-6";
+    }
+    const model = savedModel ?? getDefault(provider);
+    const thinkingLevel = savedThinkingEnabled ? "medium" : undefined;
+    closeLogger();
+    await runInkTUI({
+        provider,
+        model,
+        cwd,
+        thinkingLevel,
+        resumeSessionPath: selectedPath,
+        theme: savedTheme,
+    });
+}
+async function loadTelegramConfig() {
+    try {
+        const raw = await fs.promises.readFile(getAppPaths().telegramFile, "utf-8");
+        const data = JSON.parse(raw);
+        if (data.botToken && data.userId)
+            return data;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveTelegramConfig(config) {
+    const paths = await ensureAppDirs();
+    await fs.promises.writeFile(paths.telegramFile, JSON.stringify(config, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+async function runTelegramSetup() {
+    process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    const paths = await ensureAppDirs();
+    initLogger(paths.logFile, { version: CLI_VERSION });
+    log("INFO", "telegram", "Telegram setup started");
+    const existing = await loadTelegramConfig();
+    // Banner (matches Banner.tsx)
+    const LOGO = [
+        "  ╭●╮ ",
+        " [◉‿◉]",
+        "  ╰┬╯ ",
+    ];
+    const GRADIENT = [
+        "#60a5fa",
+        "#6da1f9",
+        "#7a9df7",
+        "#8799f5",
+        "#9495f3",
+        "#a18ff1",
+        "#a78bfa",
+        "#a18ff1",
+        "#9495f3",
+        "#8799f5",
+        "#7a9df7",
+        "#6da1f9",
+    ];
+    function gradientText(text) {
+        let colorIdx = 0;
+        return text
+            .split("")
+            .map((ch) => {
+            if (ch === " ")
+                return ch;
+            const color = GRADIENT[colorIdx++ % GRADIENT.length];
+            return chalk.hex(color)(ch);
+        })
+            .join("");
+    }
+    const GAP = "   ";
+    console.log();
+    console.log(`  ${gradientText(LOGO[0])}${GAP}` +
+        chalk.hex("#60a5fa").bold("MR Agentix Coder") +
+        chalk.hex("#6b7280")(` v${CLI_VERSION}`) +
+        chalk.hex("#6b7280")(" · By ") +
+        chalk.white.bold("Michael Rathgeb"));
+    console.log(`  ${gradientText(LOGO[1])}${GAP}` + chalk.hex("#a78bfa")("Telegram Setup"));
+    console.log(`  ${gradientText(LOGO[2])}${GAP}` + chalk.hex("#6b7280")("Remote Control"));
+    console.log();
+    if (existing) {
+        console.log(chalk.hex("#6b7280")("  Current config:\n") +
+            chalk.hex("#6b7280")(`    Bot token: ${existing.botToken.slice(0, 10)}...${existing.botToken.slice(-4)}\n`) +
+            chalk.hex("#6b7280")(`    User ID:   ${existing.userId}\n`));
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        // Step 1: Bot token
+        console.log(chalk.hex("#a78bfa")("  Step 1: Bot Token\n") +
+            chalk.hex("#6b7280")("    1. Open BotFather: ") +
+            chalk.hex("#60a5fa").underline("https://t.me/BotFather") +
+            "\n" +
+            chalk.hex("#6b7280")("    2. Send /newbot and follow the prompts\n") +
+            chalk.hex("#6b7280")("    3. Copy the bot token\n"));
+        const tokenPrompt = existing
+            ? chalk.hex("#60a5fa")("  Paste bot token (enter to keep current): ")
+            : chalk.hex("#60a5fa")("  Paste bot token: ");
+        const tokenInput = await rl.question(tokenPrompt);
+        const botToken = tokenInput.trim() || existing?.botToken;
+        if (!botToken) {
+            console.log(chalk.hex("#ef4444")("\n  No bot token provided. Setup cancelled."));
+            return;
+        }
+        // Validate token format (roughly: digits:alphanumeric)
+        if (!/^\d+:[A-Za-z0-9_-]+$/.test(botToken)) {
+            console.log(chalk.hex("#ef4444")("\n  Invalid token format. Expected: 123456789:ABCdef..."));
+            return;
+        }
+        // Step 2: User ID
+        console.log(chalk.hex("#a78bfa")("\n  Step 2: User ID\n") +
+            chalk.hex("#6b7280")("    1. Open userinfobot: ") +
+            chalk.hex("#60a5fa").underline("https://t.me/userinfobot") +
+            "\n" +
+            chalk.hex("#6b7280")("    2. Send any message — it replies with your numeric ID\n") +
+            chalk.hex("#6b7280")("    Only this user ID can control the bot.\n"));
+        const userPrompt = existing
+            ? chalk.hex("#60a5fa")(`  Your Telegram user ID (enter to keep ${existing.userId}): `)
+            : chalk.hex("#60a5fa")("  Your Telegram user ID: ");
+        const userInput = await rl.question(userPrompt);
+        const userId = userInput.trim() ? parseInt(userInput.trim(), 10) : existing?.userId;
+        if (!userId || isNaN(userId)) {
+            console.log(chalk.hex("#ef4444")("\n  Invalid user ID. Must be a number."));
+            return;
+        }
+        // Step 3: Verify bot token by calling getMe
+        console.log(chalk.hex("#6b7280")("\n  Verifying bot token..."));
+        const verifyRes = await fetch(`https://api.telegram.org/bot${botToken}/getMe`, {
+            method: "POST",
+        });
+        const verifyData = (await verifyRes.json());
+        if (!verifyData.ok || !verifyData.result) {
+            console.log(chalk.hex("#ef4444")("\n  Invalid bot token — Telegram rejected it. Check and try again."));
+            return;
+        }
+        const botName = verifyData.result.first_name;
+        const botUsername = verifyData.result.username;
+        // Save config
+        await saveTelegramConfig({ botToken, userId });
+        log("INFO", "telegram", `Telegram setup complete: @${botUsername} (user ${userId})`);
+        console.log(chalk.hex("#4ade80")(`\n  ✓ Connected to @${botUsername} (${botName})\n`) +
+            chalk.hex("#4ade80")(`  ✓ Authorized user ID: ${userId}\n`) +
+            chalk.hex("#4ade80")(`  ✓ Config saved to ${paths.telegramFile}\n\n`) +
+            chalk.hex("#a78bfa")("  For group chats:\n") +
+            chalk.hex("#6b7280")("    1. Message @BotFather → /setprivacy → select your bot → Disable\n") +
+            chalk.hex("#6b7280")("    2. Add the bot to your group\n") +
+            chalk.hex("#6b7280")("    3. Send /link in the group to connect it to a project\n\n") +
+            chalk.hex("#60a5fa")("  To start:\n") +
+            chalk.hex("#6b7280")("    cd your-project && mragentix serve\n"));
+    }
+    finally {
+        rl.close();
+        closeLogger();
+    }
+}
+// ── Serve (Telegram) ─────────────────────────────────────
+async function runServe() {
+    const { values: serveValues } = parseArgs({
+        options: {
+            "bot-token": { type: "string" },
+            "user-id": { type: "string" },
+            provider: { type: "string" },
+            model: { type: "string" },
+        },
+        strict: true,
+    });
+    // Priority: CLI flags > env vars > saved config
+    const saved = await loadTelegramConfig();
+    const botToken = serveValues["bot-token"] ?? process.env.MRAGENTIX_TELEGRAM_BOT_TOKEN ?? saved?.botToken;
+    const userIdStr = serveValues["user-id"] ?? process.env.MRAGENTIX_TELEGRAM_USER_ID;
+    const userId = userIdStr ? parseInt(userIdStr, 10) : saved?.userId;
+    if (!botToken || !userId || isNaN(userId)) {
+        console.error(chalk.hex("#ef4444")("Telegram not configured.\n\n") +
+            "Run " +
+            chalk.hex("#60a5fa").bold("mragentix telegram") +
+            " to set up your bot token and user ID.\n\n" +
+            chalk.hex("#6b7280")("Or provide manually:\n") +
+            chalk.hex("#6b7280")("  mragentix serve --bot-token TOKEN --user-id ID"));
+        process.exit(1);
+    }
+    // Load saved settings
+    let savedProvider;
+    let savedModel;
+    let savedThinkingEnabled = false;
+    try {
+        const raw = JSON.parse(fs.readFileSync(getAppPaths().settingsFile, "utf-8"));
+        if (raw.defaultProvider)
+            savedProvider = raw.defaultProvider;
+        if (raw.defaultModel)
+            savedModel = raw.defaultModel;
+        if (raw.thinkingEnabled === true)
+            savedThinkingEnabled = true;
+    }
+    catch {
+        // No settings file
+    }
+    const provider = serveValues.provider ?? savedProvider ?? "anthropic";
+    function getDefault(p) {
+        if (p === "openai")
+            return "gpt-5.3-codex";
+        if (p === "glm")
+            return "glm-5";
+        if (p === "moonshot")
+            return "kimi-k2.5";
+        return "claude-opus-4-6";
+    }
+    const model = serveValues.model ?? savedModel ?? getDefault(provider);
+    const thinkingLevel = savedThinkingEnabled ? "medium" : undefined;
+    const paths = await ensureAppDirs();
+    initLogger(paths.logFile, {
+        version: CLI_VERSION,
+        provider,
+        model,
+    });
+    setEstimatorModel(model);
+    await runServeMode({
+        provider,
+        model,
+        cwd: process.cwd(),
+        version: CLI_VERSION,
+        thinkingLevel,
+        telegram: { botToken, userId },
+    });
+}
+// ── Helpers ────────────────────────────────────────────────
+function displayName(provider) {
+    if (provider === "anthropic")
+        return "Anthropic";
+    if (provider === "glm")
+        return "Z.AI (GLM)";
+    if (provider === "moonshot")
+        return "Moonshot";
+    return "OpenAI";
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((b) => b.type === "text" && b.text)
+        .map((b) => b.text)
+        .join("\n");
+}
+function messagesToHistoryItems(msgs) {
+    const items = [];
+    let id = 0;
+    // Index tool results by toolCallId for pairing with tool calls
+    const toolResults = new Map();
+    for (const msg of msgs) {
+        if (msg.role === "tool") {
+            for (const tr of msg.content) {
+                toolResults.set(tr.toolCallId, {
+                    content: tr.content,
+                    isError: tr.isError ?? false,
+                });
+            }
+        }
+    }
+    const roleCounts = {};
+    const blockTypeCounts = {};
+    for (const msg of msgs) {
+        roleCounts[msg.role] = (roleCounts[msg.role] ?? 0) + 1;
+        if (msg.role === "user") {
+            const text = extractText(msg.content);
+            if (text)
+                items.push({ kind: "user", text, id: `restore-${id++}` });
+        }
+        else if (msg.role === "assistant") {
+            const content = msg.content;
+            if (typeof content === "string") {
+                if (content)
+                    items.push({ kind: "assistant", text: content, id: `restore-${id++}` });
+                continue;
+            }
+            // Count block types for debugging
+            for (const block of content) {
+                blockTypeCounts[block.type] = (blockTypeCounts[block.type] ?? 0) + 1;
+            }
+            // Process content blocks in order — text and tool calls
+            const text = extractText(content);
+            if (text)
+                items.push({ kind: "assistant", text, id: `restore-${id++}` });
+            for (const block of content) {
+                if (block.type === "tool_call") {
+                    const result = toolResults.get(block.id);
+                    items.push({
+                        kind: "tool_done",
+                        name: block.name,
+                        args: block.args,
+                        result: result?.content ?? "",
+                        isError: result?.isError ?? false,
+                        durationMs: 0,
+                        id: `restore-${id++}`,
+                    });
+                }
+            }
+        }
+    }
+    log("INFO", "session", "messagesToHistoryItems", {
+        totalMessages: String(msgs.length),
+        roleCounts: JSON.stringify(roleCounts),
+        blockTypeCounts: JSON.stringify(blockTypeCounts),
+        toolResultsIndexed: String(toolResults.size),
+        historyItemsProduced: String(items.length),
+        itemKinds: JSON.stringify(items.map((i) => i.kind)),
+    });
+    return items;
+}
+function openBrowser(url) {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    execFile(cmd, [url], () => {
+        // Ignore errors — user can copy URL manually
+    });
+}
+main();
+//# sourceMappingURL=cli.js.map