@kenkaiiii/ggcoder 4.11.2 → 4.12.1

package/dist/app-sidecar.js

@@ -38,8 +38,10 @@ import { loadTasksSync, saveTasksSync, getNextPendingTask, markTaskInProgress, }
 import { initLogger, log } from "./core/logger.js";
 import { RADIO_STATIONS, getCurrentStation, playRadio, stopRadio } from "./core/radio.js";
 import { enrichProcessPath } from "./core/shell-path.js";
+import { downscaleForPreview } from "./utils/image.js";
 import { startServeMode } from "./modes/serve-mode.js";
 import { loadTelegramConfig, saveTelegramConfig, verifyBotToken } from "./core/telegram-config.js";
+import { loadServers, addServer, removeServer, getServer, parseMcpAddCommand, MCPClientManager, McpOAuthStore, } from "./core/mcp/index.js";
 const ALL_PROVIDERS = [
     "anthropic",
     "xiaomi",
@@ -57,6 +59,11 @@ function appSettingsFile() {
 function defaultProjectsRoot() {
     return path.join(os.homedir(), "gg-projects");
 }
+/** Normalize a project cwd to a stable settings key so trailing slashes /
+ *  relative segments collapse — the same project always maps to one entry. */
+function projectModelKey(cwd) {
+    return path.resolve(cwd);
+}
 async function loadAppSettings() {
     try {
         const raw = JSON.parse(await fs.readFile(appSettingsFile(), "utf-8"));
@@ -64,6 +71,9 @@ async function loadAppSettings() {
             projectsRoot: typeof raw.projectsRoot === "string" && raw.projectsRoot.trim()
                 ? raw.projectsRoot
                 : defaultProjectsRoot(),
+            // Preserve the per-project map verbatim (validated + written by the
+            // model/thinking handlers below).
+            projectModels: raw.projectModels && typeof raw.projectModels === "object" ? raw.projectModels : undefined,
         };
     }
     catch {
@@ -74,6 +84,19 @@ async function saveAppSettings(settings) {
     await fs.mkdir(path.dirname(appSettingsFile()), { recursive: true });
     await fs.writeFile(appSettingsFile(), JSON.stringify(settings, null, 2), "utf-8");
 }
+/** Read this project's persisted model/thinking prefs, if any. */
+async function loadProjectModelPrefs(cwd) {
+    const s = await loadAppSettings();
+    return s.projectModels?.[projectModelKey(cwd)];
+}
+/** Persist this project's model/thinking prefs via read-modify-write so the rest
+ *  of the settings file (projectsRoot, other projects' entries) is preserved. */
+async function saveProjectModelPrefs(cwd, prefs) {
+    const s = await loadAppSettings();
+    const key = projectModelKey(cwd);
+    s.projectModels = { ...(s.projectModels ?? {}), [key]: prefs };
+    await saveAppSettings(s);
+}
 /**
  * Persist the active model selection to ~/.gg/settings.json so it survives app
  * restarts. Mirrors the CLI's handleModelSelect persistence (App.tsx).
@@ -247,6 +270,58 @@ function detectPromptCommand(text, candidates) {
     }
     return null;
 }
+/** A short transport summary for display (URL for http/sse, command+args for stdio). */
+function mcpRowSummary(config) {
+    if (config.url)
+        return config.url;
+    return [config.command, ...(config.args ?? [])].filter(Boolean).join(" ");
+}
+/** Load + connect every server, returning one wire row per server. Mirrors the
+ *  CLI dashboard's buildRows (connectAllDetailed, then dispose). Empty list
+ *  short-circuits before spawning any stdio process / opening any HTTP conn. */
+async function buildMcpRows(cwd) {
+    const scoped = await loadServers(cwd);
+    if (scoped.length === 0)
+        return [];
+    const manager = new MCPClientManager();
+    try {
+        const results = await manager.connectAllDetailed(scoped.map((s) => s.config));
+        return scoped.map((s) => {
+            const result = results.find((r) => r.name === s.config.name);
+            return {
+                name: s.config.name,
+                scope: s.scope,
+                ok: result?.ok ?? false,
+                toolCount: result?.toolCount ?? 0,
+                error: result?.error,
+                kind: s.config.url ? "http" : "stdio",
+                summary: mcpRowSummary(s.config),
+                requiresAuth: result?.requiresAuth,
+            };
+        });
+    }
+    finally {
+        await manager.dispose();
+    }
+}
+/** Probe a single server's connection before persisting it. Never throws — a
+ *  failed probe returns ok:false with a human-readable error so the config can
+ *  still be saved. Mirrors the CLI's probeServer. */
+async function probeMcp(config) {
+    const manager = new MCPClientManager();
+    try {
+        const result = await manager.probe(config);
+        return {
+            ok: result.ok,
+            toolCount: result.toolCount,
+            error: result.error,
+            requiresAuth: result.requiresAuth,
+        };
+    }
+    finally {
+        await manager.dispose();
+    }
+}
 /**
  * Sub-agents spawn the ggcoder CLI in JSON mode to run a delegated task. In the
  * packaged desktop app the only runnable entry is THIS bundle (there's no
@@ -302,6 +377,25 @@ async function main() {
     // ~/.gg/debug.log (initLogger truncates on each start).
     const sidecarLog = path.join(paths.agentDir, "gg-app-sidecar.log");
     initLogger(sidecarLog);
+    // Global last-resort guards, installed as early as the logger allows so they
+    // cover the WHOLE lifecycle — including startup/initialize, the phase the
+    // "sidecar did not start in time" bug lives in. The sidecar is a long-lived
+    // HTTP server the Rust shell can respawn: a stray rejection or thrown error
+    // from one request (e.g. an MCP probe spawning a misbehaving child) must not
+    // tear down the whole process and strand the window on its next call. Log and
+    // keep serving (mirrors astro/vscode/gstack long-lived-server handlers).
+    process.on("unhandledRejection", (reason) => {
+        log("ERROR", "app-sidecar", "unhandledRejection", {
+            message: reason instanceof Error ? reason.message : String(reason),
+            stack: reason instanceof Error ? reason.stack : undefined,
+        });
+    });
+    process.on("uncaughtException", (err) => {
+        log("ERROR", "app-sidecar", "uncaughtException", {
+            message: err.message,
+            stack: err.stack,
+        });
+    });
     // The packaged desktop app launches from Finder/Dock with a minimal PATH that
     // omits Homebrew/Cargo/version-manager dirs, so the agent can't find node,
     // git, python, rg, etc. Enrich process.env.PATH from the login shell once,
@@ -311,19 +405,27 @@ async function main() {
     const auth = new AuthStorage(paths.authFile);
     await auth.load();
     const saved = loadSavedSettings(paths.settingsFile);
-    const preferred = saved.provider ?? "anthropic";
+    // Per-project model/thinking prefs win over the shared global settings.json:
+    // each window (one project cwd) restores its own selection instead of every
+    // window reading the same single global slot that the last writer clobbered
+    // (the old bug — switching models in one window reset every other window).
+    const projectPrefs = await loadProjectModelPrefs(cwd);
+    const preferred = projectPrefs?.provider ?? saved.provider ?? "anthropic";
+    const savedModel = projectPrefs?.model ?? saved.model;
     // Boot-tolerant: when no provider is configured this returns a logged-out
     // fallback instead of throwing, so the sidecar still listens and the login
     // endpoints are reachable for a fresh user (throwing here used to kill the
     // sidecar before server.listen, making first-time login impossible).
-    const { provider, model, loggedIn } = await resolveStartOrFallback(auth, ALL_PROVIDERS, preferred, saved.model);
+    const { provider, model, loggedIn } = await resolveStartOrFallback(auth, ALL_PROVIDERS, preferred, savedModel);
     if (!loggedIn) {
         log("WARN", "app-sidecar", "no provider configured — booting logged-out for login", {
             fallbackProvider: provider,
         });
     }
-    const thinkingLevel = saved.thinkingEnabled
-        ? (saved.thinkingLevel ?? getMaxThinkingLevel(model))
+    // Per-project thinking prefs win over the global settings.json fallback.
+    const thinkEnabled = projectPrefs?.thinkingEnabled ?? saved.thinkingEnabled;
+    const thinkingLevel = thinkEnabled
+        ? (projectPrefs?.thinkingLevel ?? saved.thinkingLevel ?? getMaxThinkingLevel(model))
         : undefined;
     // ── SSE fan-out (declared before the session so plan callbacks can use it) ─
     const clients = new Set();
@@ -344,6 +446,12 @@ async function main() {
         thinkingLevel,
         sessionId: resumeSessionPath,
         signal: abort.signal,
+        // The shell gates window readiness on the GG_APP_LISTENING handshake, which
+        // can't fire until initialize() resolves. Connect MCP in the background so a
+        // slow or hanging stdio server (e.g. a first-run `npx -y @playwright/mcp`
+        // download) can't delay the sidecar past the webview's startup timeout
+        // ("sidecar did not start in time"). Tools attach when the servers come up.
+        backgroundMcpConnect: true,
         // Plan mode: the agent's enter_plan/exit_plan tools drive these. We flip
         // session plan state (rebuilds the system prompt + enforces read-only
         // tools) and surface the transition to the webview.
@@ -393,6 +501,11 @@ async function main() {
     session.eventBus.on("tool_call_start", (d) => broadcast("tool_call_start", d));
     session.eventBus.on("tool_call_update", (d) => broadcast("tool_call_update", d));
     session.eventBus.on("tool_call_end", (d) => broadcast("tool_call_end", d));
+    // Native server tools (e.g. Anthropic web_search) do NOT end the turn — text
+    // streams before and after them in the SAME turn. The webview must reset its
+    // streaming bubble here, or the two text blocks concatenate with no separator
+    // ("…command.Let me pull…"). Mirrors the TUI's server_tool_call handling.
+    session.eventBus.on("server_tool_call", (d) => broadcast("server_tool_call", d));
     session.eventBus.on("turn_end", (d) => broadcast("turn_end", d));
     session.eventBus.on("agent_done", (d) => broadcast("agent_done", d));
     session.eventBus.on("error", (d) => broadcast("error", { message: d.error instanceof Error ? d.error.message : String(d.error) }));
@@ -584,6 +697,7 @@ async function main() {
                 ready: true,
                 thinkingLevel: session.getThinkingLevel() ?? null,
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
+                supportsVideo: getModel(st.model)?.supportsVideo ?? false,
                 ...footerExtras(),
             });
             return;
@@ -606,6 +720,7 @@ async function main() {
                     running,
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
+                    supportsVideo: getModel(st.model)?.supportsVideo ?? false,
                     ...footerExtras(),
                 },
             })}\n\n`);
@@ -630,7 +745,9 @@ async function main() {
                 catch {
                     configured = false;
                 }
-                json(res, 200, { ...s, configured });
+                // Only projectsRoot + configured flag are webview-facing; the
+                // per-project model map is internal persistence, never shipped out.
+                json(res, 200, { projectsRoot: s.projectsRoot, configured });
             })();
             return;
         }
@@ -648,7 +765,11 @@ async function main() {
                     json(res, 400, { error: "projectsRoot is required" });
                     return;
                 }
-                await saveAppSettings({ projectsRoot });
+                // Read-modify-write so the per-project model map survives a projectsRoot
+                // change (a naive overwrite would drop every window's saved model).
+                const s = await loadAppSettings();
+                s.projectsRoot = projectsRoot;
+                await saveAppSettings(s);
                 json(res, 200, { projectsRoot });
             });
             return;
@@ -727,60 +848,126 @@ async function main() {
             return;
         }
         if (method === "GET" && url === "/history") {
-            // Flatten the resumed conversation into the webview's transcript shape:
-            // user + assistant TEXT only (tools live in the live panel, never the
-            // transcript; system + tool-result messages are omitted). Self-correction
-            // hook prompts (injected as user messages) are tagged with their `hook`
-            // kind so the webview renders the short "Hook engaged" line, not the raw
-            // prompt body — matching how they appear live.
+            // Reconstruct the transcript from persisted messages so resume is 1:1 with
+            // the live SSE stream. Walks ALL message types (not just user/assistant):
+            // tool result messages carry ImageContent blocks (screenshots,
+            // generate_image) that must re-render inline, and assistant tool_call
+            // blocks carry sub-agent delegations that must re-appear as group items.
             //
-            // Prompt-template commands persist their FULL expanded body as the user
-            // message, so on resume we reverse the expansion (built-in + custom
-            // candidates) back to the short `/name [args]` chip the user saw live.
+            // The `details` object (imagePreviews with path + downscaled preview) is
+            // event-only and never persisted — we reconstruct from the raw
+            // ImageContent in the tool result, downsampling on the sidecar side and
+            // extracting the path from the text block ("Generated image → /path").
             void (async () => {
                 const commandCandidates = [...PROMPT_COMMANDS, ...(await loadCustomCommands(cwd))];
-                const history = session
-                    .getMessages()
-                    .filter((m) => m.role === "user" || m.role === "assistant")
-                    .map((m) => {
-                    // `m.content` is a union of differently-typed arrays (user vs
-                    // assistant parts), so a type-predicate filter won't narrow cleanly.
-                    // A structural `"text" in c` check extracts text from any text-bearing
-                    // part regardless of the surrounding union.
-                    const text = typeof m.content === "string"
-                        ? m.content
-                        : m.content
+                const messages = session.getMessages();
+                // Pre-index tool results by toolCallId so we can pair tool calls with
+                // their results (for sub-agent status + image extraction).
+                const toolResultMap = new Map();
+                for (const msg of messages) {
+                    if (msg.role !== "tool")
+                        continue;
+                    for (const tr of msg.content) {
+                        toolResultMap.set(tr.toolCallId, {
+                            content: tr.content,
+                            isError: tr.isError ?? false,
+                        });
+                    }
+                }
+                const history = [];
+                for (const msg of messages) {
+                    if (msg.role === "system")
+                        continue;
+                    if (msg.role === "tool") {
+                        // Tool result messages: check for ImageContent blocks (screenshots,
+                        // generated images) and emit a toolImages entry.
+                        for (const tr of msg.content) {
+                            if (typeof tr.content === "string")
+                                continue;
+                            const imageBlocks = tr.content.filter((c) => c.type === "image");
+                            if (imageBlocks.length === 0)
+                                continue;
+                            // Extract the path from the text block (e.g. "Generated image → /path").
+                            const textBlock = tr.content.find((c) => c.type === "text" && "text" in c && typeof c.text === "string");
+                            const textContent = textBlock && textBlock.type === "text" ? textBlock.text : "";
+                            const pathMatch = textContent.match(/→\s*(\S+)/);
+                            const imgPath = pathMatch?.[1];
+                            // Downscale each image for the webview preview.
+                            const toolImages = [];
+                            for (const block of imageBlocks) {
+                                if (block.type !== "image")
+                                    continue;
+                                try {
+                                    const rawBuf = Buffer.from(block.data, "base64");
+                                    const previewBuf = await downscaleForPreview(rawBuf);
+                                    toolImages.push({
+                                        src: `data:${block.mediaType};base64,${previewBuf.toString("base64")}`,
+                                        path: imgPath,
+                                    });
+                                }
+                                catch {
+                                    // Downscale failed — use the raw data.
+                                    toolImages.push({
+                                        src: `data:${block.mediaType};base64,${block.data}`,
+                                        path: imgPath,
+                                    });
+                                }
+                            }
+                            if (toolImages.length > 0) {
+                                history.push({
+                                    role: "assistant",
+                                    text: "",
+                                    toolImages,
+                                });
+                            }
+                        }
+                        continue;
+                    }
+                    // User or assistant message — existing text/hook/command/compacted
+                    // extraction, plus sub-agent group detection for assistant tool_calls.
+                    const text = typeof msg.content === "string"
+                        ? msg.content
+                        : msg.content
                             .map((c) => c.type === "text" && "text" in c && typeof c.text === "string" ? c.text : "")
                             .join("");
-                    // Reconstruct image attachments as data URLs so they re-render on
-                    // resume — the webview only ever saw the live SSE stream, and the
-                    // persisted message holds the base64 bytes. Without this, attached
-                    // images vanish when returning to a session.
-                    const images = typeof m.content === "string"
+                    const images = typeof msg.content === "string"
                         ? []
-                        : m.content.flatMap((c) => c.type === "image" ? [`data:${c.mediaType};base64,${c.data}`] : []);
-                    const hook = m.role === "user" ? detectHookKind(text) : null;
-                    // A compacted session persists its summary as a user message prefixed
-                    // with this marker. Tag it so the webview renders the quiet "Compacted
-                    // context" notice instead of dumping the full summary body.
-                    const compacted = m.role === "user" && !hook && text.startsWith("[Previous conversation summary]");
-                    // Recover a `/name [args]` command invocation from its expanded body
-                    // (skip messages already claimed as hooks or compaction summaries).
-                    const command = m.role === "user" && !hook && !compacted
+                        : msg.content.flatMap((c) => c.type === "image" ? [`data:${c.mediaType};base64,${c.data}`] : []);
+                    const hook = msg.role === "user" ? detectHookKind(text) : null;
+                    const compacted = msg.role === "user" && !hook && text.startsWith("[Previous conversation summary]");
+                    const command = msg.role === "user" && !hook && !compacted
                         ? detectPromptCommand(text, commandCandidates)
                         : null;
-                    return {
-                        role: m.role,
-                        text: command ?? text,
-                        images,
-                        hook,
-                        command: command !== null,
-                        compacted,
-                    };
-                })
-                    // Keep messages with text OR images — an image-only user turn has empty
-                    // text but must still appear.
-                    .filter((m) => m.text.trim().length > 0 || m.images.length > 0);
+                    if (text.trim() || images.length > 0) {
+                        history.push({
+                            role: msg.role,
+                            text: command ?? text,
+                            images,
+                            hook,
+                            command: command !== null,
+                            compacted,
+                        });
+                    }
+                    // Assistant tool_call blocks: detect sub-agent delegations.
+                    if (msg.role === "assistant" && typeof msg.content !== "string") {
+                        const subagentCalls = msg.content.filter((c) => c.type === "tool_call" && c.name === "subagent");
+                        if (subagentCalls.length > 0) {
+                            const agents = subagentCalls.map((c) => {
+                                const result = toolResultMap.get(c.id);
+                                return {
+                                    agentName: typeof c.args?.agent === "string" ? c.args.agent : undefined,
+                                    status: result?.isError ? "error" : "done",
+                                    toolUseCount: 0,
+                                };
+                            });
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                subagentGroup: agents,
+                            });
+                        }
+                    }
+                }
                 json(res, 200, { history });
             })();
             return;
@@ -827,13 +1014,11 @@ async function main() {
                     return;
                 }
                 if (running) {
-                    // Queue text prompts as mid-run steering (mirrors the CLI). Attachments
-                    // aren't supported mid-run — reject those so the user resends after.
-                    if (attachments.length > 0) {
-                        json(res, 409, { error: "cannot attach files while the agent is running" });
-                        return;
-                    }
-                    const count = session.queueMessage(text);
+                    // Queue prompts as mid-run steering (mirrors the CLI). Attachments are
+                    // persisted to .gg/uploads first so the queued media rides the same
+                    // native-block path as a non-queued attachment prompt when it drains.
+                    const prepared = attachments.length > 0 ? await prepareAttachments(cwd, attachments) : [];
+                    const count = session.queueMessage(text, prepared);
                     broadcast("queued", { count });
                     json(res, 202, { queued: true, count });
                     return;
@@ -979,7 +1164,16 @@ async function main() {
                 if (prevLevel && !isThinkingLevelSupported(target.provider, target.id, prevLevel)) {
                     session.setThinkingLevel(getNextThinkingLevel(target.provider, target.id, undefined));
                 }
-                // Persist so the selection (and clamped thinking level) survives restarts.
+                // Persist per-project so THIS window/project restores its own model on
+                // restart (not the single global slot every window shares). Keep the
+                // global write too as a "last used" fallback for never-opened projects
+                // and so the CLI stays in sync.
+                await saveProjectModelPrefs(cwd, {
+                    provider: target.provider,
+                    model: target.id,
+                    thinkingEnabled: !!session.getThinkingLevel(),
+                    thinkingLevel: session.getThinkingLevel() ?? undefined,
+                });
                 await persistModelSelection(paths.settingsFile, target.provider, target.id);
                 await persistThinkingLevel(paths.settingsFile, session.getThinkingLevel());
                 const payload = {
@@ -1021,8 +1215,14 @@ async function main() {
             const st = session.getState();
             const next = getNextThinkingLevel(st.provider, st.model, session.getThinkingLevel());
             session.setThinkingLevel(next);
-            // Persist so the thinking level survives app restarts (mirrors the CLI).
-            void persistThinkingLevel(paths.settingsFile, next);
+            // Persist per-project so THIS window restores its thinking state on
+            // restart; keep the global write as a fallback (mirrors the CLI).
+            void saveProjectModelPrefs(cwd, {
+                provider: st.provider,
+                model: st.model,
+                thinkingEnabled: !!next,
+                thinkingLevel: next ?? undefined,
+            }).then(() => persistThinkingLevel(paths.settingsFile, next));
             const payload = {
                 thinkingLevel: next ?? null,
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
@@ -1321,6 +1521,171 @@ async function main() {
             })();
             return;
         }
+        // ── MCP server management (mirrors `ggcoder mcp`) ──────────────────
+        // `targetCwd` (project scope) overrides the window cwd so a server can be
+        // added/removed for ANY discovered project, not just this window's. Global
+        // scope ignores it (always ~/.gg/mcp.json).
+        if (method === "GET" && (url === "/mcp" || url.startsWith("/mcp?"))) {
+            const targetCwd = new URL(url, `http://${host}`).searchParams.get("cwd") ?? cwd;
+            void buildMcpRows(targetCwd)
+                .then((servers) => json(res, 200, { servers }))
+                .catch((err) => {
+                log("ERROR", "app-sidecar", "buildMcpRows failed", {
+                    message: err instanceof Error ? err.message : String(err),
+                });
+                json(res, 200, { servers: [] });
+            });
+            return;
+        }
+        if (method === "POST" && url === "/mcp/add") {
+            void readBody(req).then(async (raw) => {
+                let line;
+                let scopeValue;
+                let bodyCwd;
+                try {
+                    const body = JSON.parse(raw);
+                    line = body.line ?? "";
+                    scopeValue = body.scope ?? "global";
+                    bodyCwd = body.cwd;
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                const scope = scopeValue === "project" ? "project" : "global";
+                if (scope === "project" && !bodyCwd) {
+                    json(res, 400, { error: "project scope requires a project (cwd)." });
+                    return;
+                }
+                const targetCwd = bodyCwd ?? cwd;
+                const parsed = parseMcpAddCommand(line);
+                if (!parsed.ok) {
+                    json(res, 400, { error: parsed.error });
+                    return;
+                }
+                const config = parsed.value.config;
+                try {
+                    // Best-effort probe — never blocks the save. A failed connect is
+                    // surfaced to the UI but the config is still persisted (mirrors the
+                    // CLI). probeMcp swallows connect errors; the try/catch guards the
+                    // persist step so a write failure returns a 500 instead of becoming
+                    // an unhandled rejection that would crash the sidecar.
+                    const probe = await probeMcp(config);
+                    const saved = await addServer(config, scope, targetCwd, true);
+                    if (!saved.ok) {
+                        json(res, 400, { error: saved.error });
+                        return;
+                    }
+                    json(res, 200, {
+                        ok: true,
+                        name: config.name,
+                        connected: probe.ok,
+                        toolCount: probe.toolCount,
+                        error: probe.error,
+                        requiresAuth: probe.requiresAuth,
+                    });
+                }
+                catch (err) {
+                    json(res, 500, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            });
+            return;
+        }
+        if (method === "POST" && url === "/mcp/remove") {
+            void readBody(req).then(async (raw) => {
+                let name;
+                let scopeValue;
+                let bodyCwd;
+                try {
+                    const body = JSON.parse(raw);
+                    name = body.name ?? "";
+                    scopeValue = body.scope ?? "global";
+                    bodyCwd = body.cwd;
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!name.trim()) {
+                    json(res, 400, { error: "missing server name" });
+                    return;
+                }
+                const scope = scopeValue === "project" ? "project" : "global";
+                if (scope === "project" && !bodyCwd) {
+                    json(res, 400, { error: "project scope requires a project (cwd)." });
+                    return;
+                }
+                const targetCwd = bodyCwd ?? cwd;
+                const removed = await removeServer(name, scope, targetCwd);
+                // Drop any saved OAuth tokens for this server so a re-add starts clean.
+                await new McpOAuthStore().clear(name).catch(() => { });
+                json(res, 200, { removed });
+            });
+            return;
+        }
+        // Interactive OAuth login for a remote (HTTP) MCP server. The browser is
+        // opened by the webview in response to the broadcast `mcp_auth_url` event;
+        // progress + outcome stream via `mcp_auth_status` / `mcp_auth_done` /
+        // `mcp_auth_error`. Responds 202 immediately and runs the flow in the
+        // background (the browser round-trip can take a while).
+        if (method === "POST" && url === "/mcp/login") {
+            void readBody(req).then(async (raw) => {
+                let name;
+                let scopeValue;
+                let bodyCwd;
+                try {
+                    const body = JSON.parse(raw);
+                    name = body.name ?? "";
+                    scopeValue = body.scope ?? "global";
+                    bodyCwd = body.cwd;
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!name.trim()) {
+                    json(res, 400, { error: "missing server name" });
+                    return;
+                }
+                const scope = scopeValue === "project" ? "project" : "global";
+                const targetCwd = bodyCwd ?? cwd;
+                const scoped = await getServer(name, targetCwd);
+                if (!scoped || scoped.scope !== scope) {
+                    json(res, 404, { error: `No "${name}" server found.` });
+                    return;
+                }
+                if (!scoped.config.url) {
+                    json(res, 400, { error: "Login is only supported for HTTP MCP servers." });
+                    return;
+                }
+                json(res, 202, { accepted: true });
+                broadcast("mcp_auth_status", { name, message: "Starting login\u2026" });
+                const manager = new MCPClientManager();
+                try {
+                    const result = await manager.login(scoped.config, (authUrl) => {
+                        broadcast("mcp_auth_url", { name, url: authUrl });
+                    });
+                    if (result.ok) {
+                        broadcast("mcp_auth_done", { name, toolCount: result.toolCount });
+                    }
+                    else {
+                        broadcast("mcp_auth_error", { name, message: result.error ?? "Login failed." });
+                    }
+                }
+                catch (err) {
+                    broadcast("mcp_auth_error", {
+                        name,
+                        message: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                finally {
+                    await manager.dispose().catch(() => { });
+                }
+            });
+            return;
+        }
         json(res, 404, { error: "not found" });
     });
     server.listen(port, host, () => {