@prestyj/cli 4.2.16 → 4.2.45

package/dist/cli.js

@@ -1,16 +1,39 @@
 #!/usr/bin/env node
+// Catch stray abort-related promise rejections that escape the normal error
+// handling chain (e.g. race conditions during Ctrl+C). Without this, Node.js
+// v25+ crashes the process on any unhandled rejection.
+process.on("unhandledRejection", (reason) => {
+    if (reason instanceof Error) {
+        const msg = reason.message.toLowerCase();
+        if (reason.name === "AbortError" || msg.includes("aborted") || msg.includes("abort")) {
+            // Silently swallow abort rejections — these are expected during cancellation
+            return;
+        }
+    }
+    // Re-throw non-abort rejections so they still crash with a useful stack trace
+    throw reason;
+});
 // Drain performance entries to prevent buffer overflow warning from dependencies
-import { PerformanceObserver } from "node:perf_hooks";
-new PerformanceObserver(() => { }).observe({ entryTypes: ["measure", "mark"] });
+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, spawnSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { createRequire } from "node:module";
-import { runPrintMode } from "./modes/print-mode.js";
-import { runJsonMode } from "./modes/json-mode.js";
 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";
@@ -18,64 +41,19 @@ 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 { discoverSkills } from "./core/skills.js";
+import path from "node:path";
 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";
-// Re-exec with V8 flags for memory management during long sessions
-if (!process.env["EZCODER_V8_FLAGS_SET"]) {
-    const needFlags = [];
-    if (!process.execArgv.some((a) => a.includes("max-old-space-size")))
-        needFlags.push("--max-old-space-size=8192");
-    if (!process.execArgv.includes("--expose-gc"))
-        needFlags.push("--expose-gc");
-    if (needFlags.length > 0) {
-        const result = spawnSync(process.execPath, [...needFlags, ...process.execArgv, ...process.argv.slice(1)], { stdio: "inherit", env: { ...process.env, EZCODER_V8_FLAGS_SET: "1" } });
-        process.exit(result.status ?? (result.signal ? 128 : 1));
-    }
-}
 const _require = createRequire(import.meta.url);
 const CLI_VERSION = _require("../package.json").version;
-const USAGE = `
-Usage: ezcoder [command] [options] [message...]
-
-Commands:
-  login                     Log in to a provider via OAuth
-  logout                    Log out (clear stored credentials)
-  continue                  Resume the most recent session for this directory
-
-Options:
-  -p, --provider <name>     LLM provider (anthropic, openai, glm, moonshot) [default: anthropic]
-  -m, --model <name>        Model name [default: claude-opus-4-6]
-      --base-url <url>      Custom API base URL
-      --system-prompt <text> Override system prompt
-      --thinking <level>    Thinking level (low, medium, high, max)
-      --max-turns <n>       Maximum agent loop turns [default: 40]
-  -s, --session <path>      Resume a specific session file
-      --print               Print mode: one-shot, output to stdout, then exit
-      --json                JSON mode: one-shot, output NDJSON events to stdout
-  -v, --version             Show version number
-  -h, --help                Show this help message
-
-Print mode:
-  echo "hello" | ezcoder --print
-  ezcoder --print "explain this code"
-
-Authentication:
-  ezcoder login             Log in (select provider interactively)
-  ezcoder logout            Log out from all providers
-`.trim();
-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";
-}
 function main() {
     // Silent auto-update check (throttled, non-blocking on failure)
     const updateMessage = checkAndAutoUpdate(CLI_VERSION);
@@ -102,23 +80,48 @@ function main() {
         });
         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: {
-            provider: { type: "string", short: "p" },
-            model: { type: "string", short: "m" },
-            "base-url": { type: "string" },
-            "system-prompt": { type: "string" },
-            thinking: { type: "string" },
-            "max-turns": { type: "string" },
-            session: { type: "string", short: "s" },
-            print: { type: "boolean" },
-            json: { type: "boolean" },
             version: { type: "boolean", short: "v" },
-            help: { type: "boolean", short: "h" },
+            json: { type: "boolean" },
+            rpc: { type: "boolean" },
+            provider: { type: "string" },
+            model: { type: "string" },
+            "max-turns": { type: "string" },
+            "system-prompt": { type: "string" },
         },
         allowPositionals: true,
         strict: true,
@@ -127,9 +130,43 @@ function main() {
         console.log(CLI_VERSION);
         process.exit(0);
     }
-    if (values.help) {
-        console.log(USAGE);
-        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;
@@ -150,74 +187,27 @@ function main() {
     catch {
         // No settings file or invalid JSON — use defaults
     }
-    // Priority: CLI flag > saved setting > hardcoded default
-    const providerFromFlag = values.provider;
-    const provider = providerFromFlag ?? savedProvider ?? "anthropic";
-    const defaultModel = getHardcodedDefault(provider);
-    // Use saved model only if provider matches (or no provider flag was given)
-    const model = values.model ?? (!providerFromFlag && savedModel ? savedModel : defaultModel);
-    // CLI --thinking flag overrides saved setting; saved thinkingEnabled provides default
-    const thinkingLevel = values.thinking ?? (savedThinkingEnabled ? "medium" : undefined);
-    const maxTurns = values["max-turns"] ? parseInt(values["max-turns"], 10) : undefined;
-    // Print mode
-    if (values.print) {
-        const message = positionals.join(" ").trim() || readStdinSync();
-        if (!message) {
-            console.error("Error: --print requires a message (positional args or stdin)");
-            process.exit(1);
-        }
-        runPrintMode({
-            message,
-            provider,
-            model,
-            baseUrl: values["base-url"],
-            systemPrompt: values["system-prompt"],
-            cwd: process.cwd(),
-            thinkingLevel,
-        }).catch((err) => {
-            log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
-            closeLogger();
-            process.stderr.write(formatUserError(err) + "\n");
-            process.exit(1);
-        });
-        return;
-    }
-    // JSON mode
-    if (values.json) {
-        const message = positionals.join(" ").trim() || readStdinSync();
-        if (!message) {
-            console.error("Error: --json requires a message (positional args or stdin)");
-            process.exit(1);
-        }
-        runJsonMode({
-            message,
-            provider,
-            model,
-            baseUrl: values["base-url"],
-            systemPrompt: values["system-prompt"],
-            cwd: process.cwd(),
-            thinkingLevel,
-            maxTurns,
-        }).catch((err) => {
-            log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
-            closeLogger();
-            process.stderr.write(formatUserError(err) + "\n");
-            process.exit(1);
-        });
-        return;
+    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,
-        baseUrl: values["base-url"],
         cwd,
         thinkingLevel,
-        systemPrompt: values["system-prompt"],
         continueRecent,
-        sessionPath: values.session,
         theme: savedTheme,
     }).catch((err) => {
         log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
@@ -228,42 +218,20 @@ function main() {
 }
 // ── Ink TUI ───────────────────────────────────────────────
 async function runInkTUI(opts) {
-    const { cwd } = opts;
-    let provider = opts.provider;
-    let model = opts.model;
+    const { provider, model, cwd } = opts;
+    // Set model for token estimation accuracy
+    setEstimatorModel(model);
     // Resolve auth
     const paths = await ensureAppDirs();
-    const authStorage = new AuthStorage(paths.authFile);
-    await authStorage.load();
-    let creds;
-    try {
-        creds = await authStorage.resolveCredentials(provider);
-    }
-    catch {
-        // Not logged in — let user pick a provider and log in
-        const picked = await renderLoginSelector();
-        if (!picked) {
-            console.log(chalk.hex("#6b7280")("Login cancelled."));
-            process.exit(0);
-        }
-        provider = picked;
-        // Update model to match the picked provider's default
-        model = getHardcodedDefault(provider);
-        // Check if already logged into the picked provider
-        try {
-            creds = await authStorage.resolveCredentials(provider);
-        }
-        catch {
-            console.log(chalk.hex("#60a5fa")(`\nLogging in to ${displayName(provider)}...\n`));
-            creds = await runInlineLogin(authStorage, provider);
-        }
-    }
     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 = [];
@@ -284,24 +252,45 @@ async function runInkTUI(opts) {
             }
         }
     }
-    // Discover agents and build tools
+    // Ensure project-local .ezcoder directories exist
+    const localGGDir = path.join(cwd, ".ezcoder");
+    await fs.promises.mkdir(path.join(localGGDir, "skills"), { recursive: true });
+    await fs.promises.mkdir(path.join(localGGDir, "commands"), { recursive: true });
+    await fs.promises.mkdir(path.join(localGGDir, "agents"), { recursive: true });
+    // Discover agents and skills
     const agents = await discoverAgents({
         globalAgentsDir: paths.agentsDir,
         projectDir: cwd,
     });
+    const skills = await discoverSkills({
+        globalSkillsDir: paths.skillsDir,
+        projectDir: cwd,
+    });
     // Build system prompt & tools (with sub-agent support)
-    const systemPrompt = opts.systemPrompt ?? (await buildSystemPrompt(cwd));
-    const { tools, processManager } = createTools(cwd, { agents, provider, model });
-    // Connect MCP servers (lazy servers connect on first tool use)
+    const systemPrompt = await buildSystemPrompt(cwd, skills);
+    // Plan mode refs — shared between tools and UI
+    const planModeRef = { current: false };
+    const onEnterPlanRef = {
+        current: () => { },
+    };
+    const onExitPlanRef = {
+        current: () => Promise.resolve("cancelled"),
+    };
+    const { tools, processManager } = createTools(cwd, {
+        agents,
+        skills,
+        provider,
+        model,
+        planModeRef,
+        onEnterPlan: (reason) => onEnterPlanRef.current(reason),
+        onExitPlan: (planPath) => onExitPlanRef.current(planPath),
+    });
+    // Connect MCP servers
     const mcpManager = new MCPClientManager();
     try {
         const providerApiKey = provider === "glm" ? credentialsByProvider["glm"]?.accessToken : undefined;
-        const allConfigs = getMCPServers(provider, providerApiKey);
-        const eagerConfigs = allConfigs.filter((c) => !c.lazy);
-        const lazyConfigs = allConfigs.filter((c) => c.lazy);
-        const mcpTools = await mcpManager.connectAll(eagerConfigs);
-        const lazyTools = mcpManager.registerLazy(lazyConfigs);
-        tools.push(...mcpTools, ...lazyTools);
+        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)}`);
@@ -317,30 +306,49 @@ async function runInkTUI(opts) {
     const sessionManager = new SessionManager(paths.sessionsDir);
     let sessionPath;
     let initialHistory;
-    if (opts.continueRecent || opts.sessionPath) {
-        const existingPath = opts.sessionPath ?? (await sessionManager.getMostRecent(cwd));
-        if (existingPath) {
-            try {
-                const loaded = await sessionManager.load(existingPath);
-                const loadedMessages = sessionManager.getMessages(loaded.entries);
-                if (loadedMessages.length > 0) {
-                    messages.push(...loadedMessages);
-                    sessionPath = existingPath;
-                    log("INFO", "session", `Restored session`, {
-                        path: existingPath,
-                        messageCount: String(loadedMessages.length),
+    // 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,
                     });
-                    initialHistory = messagesToHistoryItems(loadedMessages);
-                    initialHistory.push({
-                        kind: "info",
-                        text: `↻ Restored session (${loadedMessages.length} messages)`,
-                        id: `restore-info`,
+                    // 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
-            }
+        }
+        catch {
+            // Session file corrupt or missing — start fresh
         }
     }
     // Create a new session file if we didn't reuse one
@@ -359,7 +367,6 @@ async function runInkTUI(opts) {
         maxTokens: 16384,
         thinking: opts.thinkingLevel,
         apiKey: creds.accessToken,
-        baseUrl: opts.baseUrl,
         accountId: creds.accountId,
         cwd,
         theme: opts.theme,
@@ -372,18 +379,23 @@ async function runInkTUI(opts) {
         settingsFile: paths.settingsFile,
         mcpManager,
         authStorage,
+        planModeRef,
+        onEnterPlanRef,
+        onExitPlanRef,
+        skills,
     });
     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();
+    const provider = await renderLoginSelector(CLI_VERSION);
     if (!provider) {
         console.log(chalk.hex("#6b7280")("Login cancelled."));
         return;
@@ -436,52 +448,6 @@ async function runLogin() {
         closeLogger();
     }
 }
-// ── Inline Login (auto-triggered when not logged in) ──────
-async function runInlineLogin(authStorage, provider) {
-    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.error(chalk.hex("#ef4444")("No API key provided."));
-                process.exit(1);
-            }
-            creds = {
-                accessToken: apiKey.trim(),
-                refreshToken: "",
-                expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000 * 100,
-            };
-        }
-        else {
-            creds =
-                provider === "anthropic" ? await loginAnthropic(callbacks) : await loginOpenAI(callbacks);
-        }
-        await authStorage.setCredentials(provider, creds);
-        log("INFO", "auth", `Inline login succeeded for ${displayName(provider)}`);
-        console.log(chalk.hex("#4ade80")(`✓ Logged in to ${displayName(provider)}!\n`));
-        return creds;
-    }
-    finally {
-        rl.close();
-    }
-}
 // ── Logout ─────────────────────────────────────────────────
 async function runLogout() {
     const paths = await ensureAppDirs();
@@ -494,17 +460,271 @@ async function runLogout() {
     closeLogger();
     console.log(chalk.green("Logged out successfully."));
 }
-// ── Helpers ────────────────────────────────────────────────
-function readStdinSync() {
-    if (process.stdin.isTTY)
-        return "";
+// ── 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 {
-        return fs.readFileSync(0, "utf-8").trim();
+        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 {
-        return "";
+        // 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 = [
+        " \u2588\u2580\u2580\u2580 \u2580\u2580\u2580\u2588",
+        " \u2588\u2580\u2580   \u2584\u2580 ",
+        " \u2588\u2584\u2584\u2584 \u2588\u2584\u2584\u2584",
+    ];
+    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("EZ Coder") +
+        chalk.hex("#6b7280")(` v${CLI_VERSION}`) +
+        chalk.hex("#6b7280")(" · By ") +
+        chalk.white.bold("Nolan Grout"));
+    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 && ezcoder 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.GG_TELEGRAM_BOT_TOKEN ?? saved?.botToken;
+    const userIdStr = serveValues["user-id"] ?? process.env.GG_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("ezcoder telegram") +
+            " to set up your bot token and user ID.\n\n" +
+            chalk.hex("#6b7280")("Or provide manually:\n") +
+            chalk.hex("#6b7280")("  ezcoder 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";