@prestyj/cli 4.3.15 → 4.3.54

package/dist/cli.js

@@ -13,25 +13,38 @@ process.on("unhandledRejection", (reason) => {
     // 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
+// Drain ALL performance entries to prevent unbounded memory growth.
+// Node emits entries for marks, measures, resource timing (HTTP), DNS, net, etc.
+// Without clearing, these accumulate across every LLM call and tool execution.
 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"] });
+{
+    const allTypes = PerformanceObserver.supportedEntryTypes.filter((t) => t !== "gc" && t !== "function");
+    new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+            switch (entry.entryType) {
+                case "measure":
+                    performance.clearMeasures(entry.name);
+                    break;
+                case "mark":
+                    performance.clearMarks(entry.name);
+                    break;
+                case "resource":
+                    performance.clearResourceTimings();
+                    break;
+            }
+        }
+    }).observe({ entryTypes: allTypes });
+}
 import { parseArgs } from "node:util";
 import fs from "node:fs";
 import readline from "node:readline/promises";
-import { execFile } from "node:child_process";
+import { execFile, spawnSync } 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 { runAgentHomeMode } from "./modes/agent-home-mode.js";
 import { renderLoginSelector } from "./ui/login.js";
 import { renderSessionSelector } from "./ui/sessions.js";
 import { formatUserError } from "./utils/error-handler.js";
@@ -41,10 +54,11 @@ import { ensureAppDirs, getAppPaths, loadSavedSettings } from "./config.js";
 import { initLogger, log, closeLogger } from "./core/logger.js";
 import { setStreamDiagnostic } from "@prestyj/agent";
 import { buildSystemPrompt } from "./system-prompt.js";
+import { isEyesActive, journalCount } from "@prestyj/ezcoder-eyes";
 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 { getContextWindow, getDefaultModel } 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";
@@ -116,6 +130,7 @@ function printHelp() {
     const cmds = [
         ["login", "Log in to an AI provider (Anthropic, OpenAI)"],
         ["logout", "Log out and clear stored credentials"],
+        ["doctor", "Diagnose and fix auth/config issues"],
         ["sessions", "Browse and resume previous sessions"],
         ["continue", "Resume the most recent session"],
         ["serve", "Start the HTTP/WebSocket API server"],
@@ -131,7 +146,7 @@ function printHelp() {
         ["-h, --help", "Show this help message"],
         ["-v, --version", "Show version number"],
         ["--provider <name>", "AI provider (anthropic, xiaomi, openai, glm, moonshot)"],
-        ["--model <name>", "Model to use (e.g. claude-sonnet-4-6, gpt-4.1)"],
+        ["--model <name>", "Model to use (e.g. claude-sonnet-4-6, gpt-5.5)"],
         ["--max-turns <n>", "Maximum agent turns per prompt"],
         ["--system-prompt <text>", "Override the system prompt"],
         ["--json", "JSON output mode (for sub-agents)"],
@@ -174,7 +189,7 @@ function main() {
     // Silent auto-update check (throttled, non-blocking on failure)
     const updateMessage = checkAndAutoUpdate(CLI_VERSION);
     if (updateMessage) {
-        console.error(chalk.hex("#60a5fa")(updateMessage));
+        console.error(chalk.bold.hex("#4ade80")(`✨ ${updateMessage}`));
     }
     // Intercept --help / -h before anything else so it works with subcommands
     // (e.g. `ezcoder login --help` or `ezcoder --help`)
@@ -184,6 +199,24 @@ function main() {
     }
     // Handle subcommands before parseArgs
     const subcommand = process.argv[2];
+    // Passthrough to @prestyj/ezcoder-eyes CLI. Agents call this from bash as
+    // `ezcoder eyes log rough "..."` etc. — `ezcoder` is guaranteed on PATH
+    // (user launched it), so this avoids depending on nested bin visibility in
+    // global npm/pnpm installs.
+    if (subcommand === "eyes") {
+        let cliPath;
+        try {
+            cliPath = _require.resolve("@prestyj/ezcoder-eyes/cli");
+        }
+        catch {
+            process.stderr.write("ezcoder-eyes package not installed\n");
+            process.exit(1);
+        }
+        const r = spawnSync(process.execPath, [cliPath, ...process.argv.slice(3)], {
+            stdio: "inherit",
+        });
+        process.exit(r.status ?? 0);
+    }
     if (subcommand === "login") {
         runLogin().catch((err) => {
             log("ERROR", "fatal", err instanceof Error ? err.message : String(err));
@@ -231,6 +264,13 @@ function main() {
         });
         return;
     }
+    if (subcommand === "doctor") {
+        runDoctor().catch((err) => {
+            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);
@@ -261,7 +301,7 @@ function main() {
     if (values.json) {
         const message = positionals[0] ?? "";
         const jsonProvider = (values.provider ?? "anthropic");
-        const jsonModel = values.model ?? "claude-opus-4-6";
+        const jsonModel = values.model ?? "claude-opus-4-7";
         const maxTurns = values["max-turns"] ? parseInt(values["max-turns"], 10) : undefined;
         const systemPrompt = values["system-prompt"];
         const cwd = process.cwd();
@@ -281,7 +321,7 @@ function main() {
     // 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 rpcModel = values.model ?? "claude-opus-4-7";
         const systemPrompt = values["system-prompt"];
         const cwd = process.cwd();
         runRpcMode({
@@ -301,14 +341,16 @@ function main() {
     const provider = saved.provider ?? "anthropic";
     function getHardcodedDefault(p) {
         if (p === "openai")
-            return "gpt-5.4";
+            return "gpt-5.5";
         if (p === "glm")
             return "glm-5.1";
         if (p === "moonshot")
-            return "kimi-k2.5";
+            return "kimi-k2.6";
         if (p === "minimax")
             return "MiniMax-M2.7";
-        return "claude-opus-4-6";
+        if (p === "openrouter")
+            return "qwen/qwen3.6-plus";
+        return "claude-opus-4-7";
     }
     const model = saved.model ?? getHardcodedDefault(provider);
     const thinkingLevel = saved.thinkingEnabled ? "medium" : undefined;
@@ -331,45 +373,42 @@ function main() {
 }
 // ── Ink TUI ───────────────────────────────────────────────
 async function runInkTUI(opts) {
-    const { provider, model, cwd } = opts;
-    // Set model for token estimation accuracy
-    setEstimatorModel(model);
-    // Resolve auth
+    const { cwd } = opts;
+    // Resolve auth first so we can pick an active provider the user has
+    // actually logged in with — we must never default to a provider they
+    // haven't authenticated against.
     const paths = await ensureAppDirs();
-    initLogger(paths.logFile, {
-        version: CLI_VERSION,
-        provider,
-        model,
-        thinking: opts.thinkingLevel,
-    });
     // Wire stream stall diagnostics into the debug log
     setStreamDiagnostic((phase, data) => {
         log("INFO", "stream", phase, data);
     });
     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", "xiaomi", "openai", "glm", "moonshot", "minimax"];
-    const loggedInProviders = [];
+    const { provider, model, loggedInProviders } = await resolveActiveProvider(authStorage, opts.provider, opts.model);
+    // Preload every logged-in provider's credentials for the model switcher.
     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,
-                    baseUrl: resolved.baseUrl,
-                };
-            }
-            catch {
-                // Token refresh failed — still mark as logged in
-            }
+    for (const p of loggedInProviders) {
+        try {
+            const resolved = await authStorage.resolveCredentials(p);
+            credentialsByProvider[p] = {
+                accessToken: resolved.accessToken,
+                accountId: resolved.accountId,
+                baseUrl: resolved.baseUrl,
+            };
+        }
+        catch {
+            // Token refresh failed — still leave them in loggedInProviders
         }
     }
+    // Set model for token estimation accuracy (after provider is finalized)
+    setEstimatorModel(model);
+    initLogger(paths.logFile, {
+        version: CLI_VERSION,
+        provider,
+        model,
+        thinking: opts.thinkingLevel,
+    });
+    const creds = await authStorage.resolveCredentials(provider);
     // Ensure project-local .ezcoder directories exist
     const localEzDir = path.join(cwd, ".ezcoder");
     await fs.promises.mkdir(path.join(localEzDir, "skills"), { recursive: true });
@@ -475,6 +514,21 @@ async function runInkTUI(opts) {
         sessionPath = session.path;
         log("INFO", "session", `New session created`, { path: sessionPath });
     }
+    // Eyes startup banner — surface open journal signals from past sessions so the
+    // user isn't relying on reading agent prose to know improvements are pending.
+    if (isEyesActive(cwd)) {
+        const openCount = journalCount({ status: "open" }, cwd);
+        if (openCount > 0) {
+            const s = openCount === 1 ? "" : "s";
+            if (!initialHistory)
+                initialHistory = [];
+            initialHistory.push({
+                kind: "info",
+                text: `👁  Eyes: ${openCount} open improvement signal${s} from recent sessions. Run /eyes-improve to triage.`,
+                id: "eyes-banner",
+            });
+        }
+    }
     await renderApp({
         provider,
         model,
@@ -543,31 +597,27 @@ async function runLogin() {
         if (provider === "glm" ||
             provider === "moonshot" ||
             provider === "xiaomi" ||
-            provider === "minimax") {
+            provider === "minimax" ||
+            provider === "openrouter") {
             const keyLabel = provider === "glm"
                 ? "Z.AI"
                 : provider === "xiaomi"
                     ? "Xiaomi MiMo"
                     : provider === "minimax"
                         ? "MiniMax"
-                        : "Moonshot";
+                        : provider === "openrouter"
+                            ? "OpenRouter"
+                            : "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;
             }
-            let baseUrl;
-            if (provider === "xiaomi") {
-                const urlInput = await rl.question(chalk.hex("#60a5fa")(`Base URL ${chalk.hex("#6b7280")("(Enter for default, or paste token plan URL)")}: `));
-                if (urlInput.trim()) {
-                    baseUrl = urlInput.trim();
-                }
-            }
             creds = {
                 accessToken: apiKey.trim(),
                 refreshToken: "",
                 expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000 * 100, // ~100 years
-                ...(baseUrl ? { baseUrl } : {}),
+                ...(provider === "xiaomi" ? { baseUrl: "https://token-plan-sgp.xiaomimimo.com/v1" } : {}),
             };
         }
         else {
@@ -583,6 +633,244 @@ async function runLogin() {
         closeLogger();
     }
 }
+// ── Doctor ─────────────────────────────────────────────────
+async function runDoctor() {
+    process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    const os = await import("node:os");
+    const fsP = await import("node:fs/promises");
+    const dim = chalk.hex("#6b7280");
+    const primary = chalk.hex("#60a5fa");
+    const accent = chalk.hex("#a78bfa");
+    const good = chalk.hex("#4ade80");
+    const warn = chalk.hex("#fbbf24");
+    const bad = chalk.hex("#ef4444");
+    // ── Banner ──────────────────────────────────────────────────
+    const LOGO = LOGO_LINES;
+    const GAP = "   ";
+    console.log();
+    console.log(`  ${gradientLine(LOGO[0])}${GAP}` +
+        primary.bold("EZ Coder") +
+        dim(` v${CLI_VERSION}`));
+    console.log(`  ${gradientLine(LOGO[1])}${GAP}` + accent("Doctor"));
+    console.log(`  ${gradientLine(LOGO[2])}${GAP}` + dim("Diagnose & Fix"));
+    console.log();
+    const home = os.homedir();
+    const ggDir = path.join(home, ".ezcoder");
+    const authFile = path.join(ggDir, "auth.json");
+    const lockFile = authFile + ".lock";
+    const myUid = process.getuid();
+    let fixed = 0;
+    // ── Environment ─────────────────────────────────────────────
+    console.log(accent("  Environment\n"));
+    console.log(dim(`    Home:      ${home}`));
+    console.log(dim(`    $HOME:     ${process.env.HOME ?? "(not set)"}`));
+    console.log(dim(`    Node.js:   ${process.version}`));
+    console.log(dim(`    Platform:  ${process.platform} ${process.arch}`));
+    console.log(dim(`    UID:       ${myUid}  EUID: ${process.geteuid()}`));
+    if (process.env.HOME && process.env.HOME !== home) {
+        console.log(warn("\n    ⚠ $HOME differs from os.homedir() — this can cause auth mismatches"));
+    }
+    if (myUid !== process.geteuid()) {
+        console.log(warn("    ⚠ uid ≠ euid — running with elevated privileges (sudo?)"));
+        console.log(dim("      Running ezcoder with sudo can cause ownership issues."));
+        console.log(dim("      Use without sudo, or fix after: sudo chown -R $(whoami) ~/.gg"));
+    }
+    console.log();
+    // ── Config Directory ────────────────────────────────────────
+    console.log(accent("  Config Directory\n"));
+    try {
+        const stat = await fsP.stat(ggDir);
+        const mode = stat.mode & 0o777;
+        console.log(dim(`    Path:  ${ggDir}`));
+        console.log(dim(`    Mode:  0o${mode.toString(8)}  UID: ${stat.uid}`));
+        // Fix ownership
+        if (stat.uid !== myUid) {
+            console.log(warn(`    ⚠ Owned by uid ${stat.uid}, expected ${myUid}`));
+            try {
+                await fsP.chown(ggDir, myUid, process.getgid());
+                console.log(good("    ✓ Fixed directory ownership"));
+                fixed++;
+            }
+            catch {
+                console.log(bad(`    ✗ Cannot fix — try: sudo chown -R $(whoami) ${ggDir}`));
+            }
+        }
+        // Fix permissions (should be 0o700)
+        if (mode !== 0o700) {
+            try {
+                await fsP.chmod(ggDir, 0o700);
+                console.log(good("    ✓ Fixed directory permissions → 0o700"));
+                fixed++;
+            }
+            catch {
+                console.log(bad(`    ✗ Cannot fix — try: chmod 700 ${ggDir}`));
+            }
+        }
+    }
+    catch {
+        console.log(warn(`    ${ggDir} missing — creating...`));
+        try {
+            await fsP.mkdir(ggDir, { recursive: true, mode: 0o700 });
+            console.log(good(`    ✓ Created ${ggDir}`));
+            fixed++;
+        }
+        catch (mkErr) {
+            console.log(bad(`    ✗ Cannot create: ${mkErr instanceof Error ? mkErr.message : String(mkErr)}`));
+            console.log();
+            return;
+        }
+    }
+    console.log();
+    // ── Lock File ───────────────────────────────────────────────
+    try {
+        const lockStat = await fsP.stat(lockFile);
+        const ageMs = Date.now() - lockStat.mtimeMs;
+        console.log(accent("  Lock File\n"));
+        console.log(warn(`    ⚠ Stale lock found (age: ${Math.round(ageMs / 1000)}s)`));
+        await fsP.unlink(lockFile);
+        console.log(good("    ✓ Removed"));
+        fixed++;
+        console.log();
+    }
+    catch {
+        // No lock file — good, skip section entirely
+    }
+    // ── Auth File ───────────────────────────────────────────────
+    console.log(accent("  Auth File\n"));
+    let authData = null;
+    let authNeedsRewrite = false;
+    try {
+        const stat = await fsP.stat(authFile);
+        const mode = stat.mode & 0o777;
+        console.log(dim(`    Path:  ${authFile}`));
+        console.log(dim(`    Size:  ${stat.size} bytes  Mode: 0o${mode.toString(8)}  UID: ${stat.uid}`));
+        // Fix ownership
+        if (stat.uid !== myUid) {
+            console.log(warn(`    ⚠ Owned by uid ${stat.uid}, expected ${myUid}`));
+            try {
+                await fsP.chown(authFile, myUid, process.getgid());
+                console.log(good("    ✓ Fixed file ownership"));
+                fixed++;
+            }
+            catch {
+                console.log(bad(`    ✗ Cannot fix — try: sudo chown $(whoami) ${authFile}`));
+            }
+        }
+        // Fix permissions (should be 0o600)
+        if (mode !== 0o600) {
+            try {
+                await fsP.chmod(authFile, 0o600);
+                console.log(good("    ✓ Fixed file permissions → 0o600"));
+                fixed++;
+            }
+            catch {
+                console.log(bad(`    ✗ Cannot fix — try: chmod 600 ${authFile}`));
+            }
+        }
+        // Try to read and parse
+        try {
+            const content = await fsP.readFile(authFile, "utf-8");
+            try {
+                authData = JSON.parse(content);
+            }
+            catch {
+                console.log(bad("    ✗ Invalid JSON — backing up and resetting"));
+                const backupName = `auth.json.corrupt.${Date.now()}`;
+                await fsP.copyFile(authFile, path.join(ggDir, backupName));
+                await fsP.writeFile(authFile, "{}", { encoding: "utf-8", mode: 0o600 });
+                console.log(good(`    ✓ Corrupt file backed up as ${backupName}`));
+                console.log(dim('      Run "ezcoder login" to re-authenticate'));
+                authData = {};
+                fixed++;
+            }
+        }
+        catch (readErr) {
+            const code = readErr.code;
+            if (code === "EACCES") {
+                console.log(bad("    ✗ Permission denied reading auth.json"));
+                console.log(dim(`      Try: sudo chown $(whoami) ${authFile} && chmod 600 ${authFile}`));
+            }
+            else {
+                console.log(bad(`    ✗ Read error: ${readErr instanceof Error ? readErr.message : String(readErr)}`));
+            }
+        }
+    }
+    catch {
+        console.log(dim(`    Path:  ${authFile}`));
+        console.log(warn('    Not found — run "ezcoder login" to authenticate'));
+    }
+    console.log();
+    // ── Credentials ─────────────────────────────────────────────
+    if (authData && Object.keys(authData).length > 0) {
+        console.log(accent("  Credentials\n"));
+        for (const p of Object.keys(authData)) {
+            const cred = authData[p];
+            if (!cred || typeof cred !== "object") {
+                console.log(bad(`    ✗ ${p}: invalid entry — removing`));
+                delete authData[p];
+                authNeedsRewrite = true;
+                fixed++;
+                continue;
+            }
+            if (!cred.accessToken || typeof cred.accessToken !== "string") {
+                console.log(bad(`    ✗ ${p}: missing accessToken — removing`));
+                delete authData[p];
+                authNeedsRewrite = true;
+                fixed++;
+                continue;
+            }
+            const token = String(cred.accessToken);
+            const masked = token.slice(0, 8) + "..." + token.slice(-4);
+            const expires = typeof cred.expiresAt === "number" ? new Date(cred.expiresAt).toISOString() : "unknown";
+            const expired = typeof cred.expiresAt === "number" && Date.now() > cred.expiresAt;
+            if (expired) {
+                console.log(warn(`    ⚠ ${p}: ${masked}  expired ${expires}`));
+            }
+            else {
+                console.log(good(`    ✓ ${p}: ${masked}  expires ${expires}`));
+            }
+        }
+        if (authNeedsRewrite) {
+            try {
+                await fsP.writeFile(authFile, JSON.stringify(authData, null, 2), {
+                    encoding: "utf-8",
+                    mode: 0o600,
+                });
+                console.log(good("    ✓ Cleaned up auth.json"));
+            }
+            catch {
+                console.log(bad("    ✗ Failed to write cleaned auth.json"));
+            }
+        }
+        console.log();
+    }
+    // ── Temp Files ──────────────────────────────────────────────
+    try {
+        const entries = await fsP.readdir(ggDir);
+        const tmpFiles = entries.filter((e) => e.startsWith("auth.json.") && e.endsWith(".tmp"));
+        if (tmpFiles.length > 0) {
+            console.log(accent("  Temp Files\n"));
+            console.log(warn(`    ⚠ ${tmpFiles.length} orphaned temp file(s) from interrupted writes`));
+            for (const tmp of tmpFiles) {
+                await fsP.unlink(path.join(ggDir, tmp)).catch(() => { });
+            }
+            console.log(good(`    ✓ Removed ${tmpFiles.length} file(s)`));
+            fixed++;
+            console.log();
+        }
+    }
+    catch {
+        // Can't read directory — already flagged above
+    }
+    // ── Summary ─────────────────────────────────────────────────
+    if (fixed > 0) {
+        console.log(good(`  ✓ Fixed ${fixed} issue${fixed > 1 ? "s" : ""}.`));
+    }
+    else {
+        console.log(good("  ✓ Everything looks good."));
+    }
+    console.log();
+}
 // ── Logout ─────────────────────────────────────────────────
 async function runLogout() {
     const paths = await ensureAppDirs();
@@ -612,14 +900,14 @@ async function runSessions() {
     const provider = saved2.provider ?? "anthropic";
     function getDefault(p) {
         if (p === "openai")
-            return "gpt-5.4";
+            return "gpt-5.5";
         if (p === "glm")
             return "glm-5.1";
         if (p === "moonshot")
-            return "kimi-k2.5";
+            return "kimi-k2.6";
         if (p === "minimax")
             return "MiniMax-M2.7";
-        return "claude-opus-4-6";
+        return "claude-opus-4-7";
     }
     const model = saved2.model ?? getDefault(provider);
     const thinkingLevel = saved2.thinkingEnabled ? "medium" : undefined;
@@ -800,21 +1088,12 @@ async function runServe() {
         process.exit(1);
     }
     const saved3 = loadSavedSettings();
-    const provider = serveValues.provider ?? saved3.provider ?? "anthropic";
-    function getDefault(p) {
-        if (p === "openai")
-            return "gpt-5.4";
-        if (p === "glm")
-            return "glm-5.1";
-        if (p === "moonshot")
-            return "kimi-k2.5";
-        if (p === "minimax")
-            return "MiniMax-M2.7";
-        return "claude-opus-4-6";
-    }
-    const model = serveValues.model ?? saved3.model ?? getDefault(provider);
     const thinkingLevel = saved3.thinkingEnabled ? "medium" : undefined;
     const paths = await ensureAppDirs();
+    const authStorage = new AuthStorage(paths.authFile);
+    await authStorage.load();
+    const preferredProvider = serveValues.provider ?? saved3.provider ?? "anthropic";
+    const { provider, model } = await resolveActiveProvider(authStorage, preferredProvider, serveValues.model ?? saved3.model);
     initLogger(paths.logFile, {
         version: CLI_VERSION,
         provider,
@@ -830,7 +1109,176 @@ async function runServe() {
         telegram: { botToken, userId },
     });
 }
+async function loadAgentHomeConfig() {
+    try {
+        const raw = await fs.promises.readFile(getAppPaths().agentHomeFile, "utf-8");
+        const data = JSON.parse(raw);
+        if (data.token)
+            return data;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveAgentHomeConfig(config) {
+    const paths = await ensureAppDirs();
+    await fs.promises.writeFile(paths.agentHomeFile, JSON.stringify(config, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+async function runAgentHomeLogin() {
+    process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    const paths = await ensureAppDirs();
+    initLogger(paths.logFile, { version: CLI_VERSION });
+    log("INFO", "agent-home", "Agent Home login started");
+    const existing = await loadAgentHomeConfig();
+    // Banner
+    const LOGO = [
+        " \u2588\u2580\u2580\u2580 \u2580\u2580\u2580\u2588",
+        " \u2588\u2580\u2580   \u2584\u2580 ",
+        " \u2588\u2584\u2584\u2584 \u2588\u2584\u2584\u2584",
+    ];
+    function gradientTextLocal(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(`  ${gradientTextLocal(LOGO[0])}${GAP}` +
+        chalk.hex("#60a5fa").bold("EZ Coder") +
+        chalk.hex("#6b7280")(` v${CLI_VERSION}`) +
+        chalk.hex("#6b7280")(" \u00b7 By ") +
+        chalk.white.bold("Nolan Grout"));
+    console.log(`  ${gradientTextLocal(LOGO[1])}${GAP}` + chalk.hex("#a78bfa")("Agent Home Setup"));
+    console.log(`  ${gradientTextLocal(LOGO[2])}${GAP}` + chalk.hex("#6b7280")("Remote Control via iOS"));
+    console.log();
+    if (existing) {
+        console.log(chalk.hex("#6b7280")("  Current config:\n") +
+            chalk.hex("#6b7280")(`    Token:  ${existing.token.slice(0, 8)}...${existing.token.slice(-4)}\n`));
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log(chalk.hex("#a78bfa")("  Auth Token\n") +
+            chalk.hex("#6b7280")("    Open Agent Home iOS app \u2192 Settings \u2192 Generate SDK Token\n") +
+            chalk.hex("#6b7280")("    Copy the token\n"));
+        const tokenPrompt = existing
+            ? chalk.hex("#60a5fa")("  Auth token (enter to keep current): ")
+            : chalk.hex("#60a5fa")("  Auth token: ");
+        const tokenInput = await rl.question(tokenPrompt);
+        const token = tokenInput.trim() || existing?.token;
+        if (!token) {
+            console.log(chalk.hex("#ef4444")("\n  No token provided. Setup cancelled."));
+            return;
+        }
+        // Save config
+        await saveAgentHomeConfig({ token });
+        log("INFO", "agent-home", `Agent Home setup complete`);
+        console.log(chalk.hex("#4ade80")(`\n  \u2713 Token saved`) +
+            "\n" +
+            chalk.hex("#4ade80")(`  \u2713 Config saved to ${paths.agentHomeFile}`) +
+            "\n\n" +
+            chalk.hex("#60a5fa")("  To start:\n") +
+            chalk.hex("#6b7280")("    cd your-project && ezcoder agent-home\n"));
+    }
+    finally {
+        rl.close();
+        closeLogger();
+    }
+}
+// ── Agent Home (Run) ────────────────────────────────────
+async function runAgentHome() {
+    const { values: ahValues } = parseArgs({
+        options: {
+            token: { type: "string" },
+            provider: { type: "string" },
+            model: { type: "string" },
+        },
+        strict: true,
+    });
+    // Priority: CLI flags > saved config
+    const saved = await loadAgentHomeConfig();
+    const token = ahValues.token ?? saved?.token;
+    if (!token) {
+        console.error(chalk.hex("#ef4444")("Agent Home not configured.\n\n") +
+            "Run " +
+            chalk.hex("#60a5fa").bold("ezcoder agent-home-login") +
+            " to set up your token.\n\n" +
+            chalk.hex("#6b7280")("Or provide manually:\n") +
+            chalk.hex("#6b7280")("  ezcoder agent-home --token TOKEN"));
+        process.exit(1);
+    }
+    const saved4 = loadSavedSettings();
+    const thinkingLevel = saved4.thinkingEnabled ? "medium" : undefined;
+    const paths = await ensureAppDirs();
+    const authStorage = new AuthStorage(paths.authFile);
+    await authStorage.load();
+    const preferredProvider = ahValues.provider ?? saved4.provider ?? "anthropic";
+    const { provider, model } = await resolveActiveProvider(authStorage, preferredProvider, ahValues.model ?? saved4.model);
+    initLogger(paths.logFile, {
+        version: CLI_VERSION,
+        provider,
+        model,
+    });
+    setEstimatorModel(model);
+    await runAgentHomeMode({
+        provider,
+        model,
+        cwd: process.cwd(),
+        version: CLI_VERSION,
+        thinkingLevel,
+        agentHome: { token },
+    });
+}
 // ── Helpers ────────────────────────────────────────────────
+/**
+ * Resolve the provider and model to start with. If the preferred provider isn't
+ * one the user is logged into, fall back to the first provider they ARE
+ * logged into (in `allProviders` order). Throws if nothing is logged in.
+ *
+ * This prevents the CLI from crashing with "Not logged in" on startup just
+ * because settings.json remembers a provider the user later logged out of.
+ */
+async function resolveActiveProvider(authStorage, preferred, savedModel) {
+    const allProviders = [
+        "anthropic",
+        "xiaomi",
+        "openai",
+        "glm",
+        "moonshot",
+        "minimax",
+        "openrouter",
+    ];
+    const loggedInProviders = [];
+    for (const p of allProviders) {
+        if (await authStorage.getCredentials(p))
+            loggedInProviders.push(p);
+    }
+    if (loggedInProviders.length === 0) {
+        throw new Error('Not logged in to any provider. Run "ezcoder login" to authenticate.');
+    }
+    if (loggedInProviders.includes(preferred)) {
+        return {
+            provider: preferred,
+            model: savedModel ?? getDefaultModel(preferred).id,
+            loggedInProviders,
+        };
+    }
+    // Preferred provider isn't authenticated — fall back to the first one
+    // that is, and use that provider's default model (the saved model
+    // belonged to a provider the user can no longer reach).
+    const provider = loggedInProviders[0];
+    return { provider, model: getDefaultModel(provider).id, loggedInProviders };
+}
 function displayName(provider) {
     if (provider === "anthropic")
         return "Anthropic";
@@ -842,6 +1290,8 @@ function displayName(provider) {
         return "Moonshot";
     if (provider === "minimax")
         return "MiniMax";
+    if (provider === "openrouter")
+        return "OpenRouter";
     return "OpenAI";
 }
 function extractText(content) {
@@ -860,8 +1310,13 @@ function messagesToHistoryItems(msgs) {
     for (const msg of msgs) {
         if (msg.role === "tool") {
             for (const tr of msg.content) {
+                const text = typeof tr.content === "string"
+                    ? tr.content
+                    : tr.content
+                        .map((b) => (b.type === "text" ? b.text : `[image ${b.mediaType}]`))
+                        .join("\n");
                 toolResults.set(tr.toolCallId, {
-                    content: tr.content,
+                    content: text,
                     isError: tr.isError ?? false,
                 });
             }