@akira-tl/forgerelay 1.1.0 → 1.1.1

package/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [1.1.1] - 2026-09-10
+
+### Added
+
+- Added standalone global and Project External MCP registries in `mcp.json` with hot reload, Project-over-global precedence, explicit `disabled` masking, whole-source last-known-good behavior, and permanent discovery of the existing `mcp.external` Capability even when the registry starts empty.
+- Added human-operated External MCP OAuth through `forgerelay mcp auth/logout`, including machine-private Project-scoped credentials, desktop loopback and masked headless callback flows, silent refresh with cross-process rotation protection, scope step-up, DCR compatibility, and optional CIMD client metadata for authorization servers that require it.
+- Added `forgerelay mcp list/test` and passive External MCP `doctor` diagnostics for resolved source, authentication state, configuration health, negotiated MCP protocol, tool discovery, and actionable failure reporting.
+
+### Changed
+
+- Migrated ForgeRelay's MCP runtime to the split MCP SDK v2 and Apps SDK v2, supporting MCP 2026-07-28 modern stateless HTTP alongside the existing legacy sessionful Host path while preserving legacy External MCP and Workspace Relay interoperability.
+- Modern stateless Host Turns now use stable Host conversation metadata when supplied and otherwise remain request-scoped instead of inferring conversation identity from transport or process lifetime. Legacy compatibility retains its bounded transport/session fallback behavior.
+- `config.json.mcpServers` remains a deprecated compatibility source; new External MCP configuration uses `mcp.json`, and relayed External MCP configuration, credentials, refresh, process launch, and upstream calls remain owned by the Execution ForgeRelay.
+
+### Security
+
+- External MCP OAuth credentials stay in private `mcp-auth.json` state rather than Project files, are bound to their Project/global identity plus resource/issuer state, and are never exposed through normal diagnostics. Interactive authorization remains human-only; runtime refresh cannot open a browser, and headless callback input is masked.
+- Project-defined stdio MCP servers are explicitly documented as executable project configuration, while static header/env secrets remain user-managed and External MCP paths, URLs, and resource references continue to be pass-through unless the Agent or an explicit Transform Hook acts on them.
+
 ## [1.1.0] - 2026-09-09
 
 ### Added

package/README.md

@@ -108,7 +108,7 @@ ForgeRelay 不会默认为每个任务创建 worktree。只有你明确要求隔
 - 项目里的 `AGENTS.md`、`CLAUDE.md` 和 Agent Skills 按需加载，不会每次都把整套说明重新塞进上下文。
 - 需要并行开发时可以创建真实 Git worktree；集成回主分支时只接受安全的 fast-forward，不自动制造 merge conflict。
 - Workspace Relay 可以把执行放到另一台 ForgeRelay；Composite Workspace 可以同时协调几个独立环境。
-- `read` 可以直接把 PNG、JPEG、WebP 和 GIF 作为临时 MCP Media content 返回；配置好的外部 MCP 也通过 `mcp.external` Capability 转发图片，而不会自动打开它返回的路径或 URL。
+- `read` 可以直接把 PNG、JPEG、WebP 和 GIF 作为临时 MCP Media content 返回；外部 MCP 通过独立的 global/Project `mcp.json` 热加载到 `mcp.external` Capability，并支持人工 OAuth 认证，而不会自动打开它返回的路径或 URL。
 
 Lifecycle Hooks、Workspace Tasks、本地 Subagent、Activity/Audit、Checkpoint 和 Recovery 也已经包含在项目里，但第一次安装时不需要先学这些。需要哪个，再去 [Wiki](https://github.com/Akira-TL/forgerelay/wiki) 查哪个。
 
@@ -128,6 +128,7 @@ ForgeRelay 默认拒绝 elevated / administrator 启动。只有你显式选择
 
 - [快速开始](https://github.com/Akira-TL/forgerelay/wiki/Getting-Started)
 - [配置](https://github.com/Akira-TL/forgerelay/wiki/Configuration)
+- [External MCP](https://github.com/Akira-TL/forgerelay/wiki/External-MCP)
 - [安全模型](https://github.com/Akira-TL/forgerelay/wiki/Security)
 - [故障排查](https://github.com/Akira-TL/forgerelay/wiki/Troubleshooting)
 - [完整 Wiki](https://github.com/Akira-TL/forgerelay/wiki)
@@ -221,7 +222,7 @@ Long commands do not require tight polling either. Once the current wait window
 - `AGENTS.md`, `CLAUDE.md`, and Agent Skills are loaded as needed instead of being resent in full on every open.
 - Managed worktrees provide real Git isolation when you ask for parallel work, with fast-forward-only finalization.
 - Workspace Relay runs work on another ForgeRelay instance; Composite Workspaces coordinate several independent environments from one Host.
-- `read` can return PNG, JPEG, WebP, and GIF directly as transient MCP Media content; configured external MCP servers can forward images through the `mcp.external` Capability without ForgeRelay automatically opening returned paths or URLs.
+- `read` can return PNG, JPEG, WebP, and GIF directly as transient MCP Media content; external MCP servers hot-reload from standalone global/Project `mcp.json` files into the `mcp.external` Capability, with explicit human OAuth when needed and no automatic dereferencing of returned paths or URLs.
 
 Lifecycle Hooks, Workspace Tasks, local Subagents, Activity/Audit, checkpoints, and recovery are included too. They are optional parts of the workflow; the [Wiki](https://github.com/Akira-TL/forgerelay/wiki) documents them when you need them.
 
@@ -241,6 +242,7 @@ See the [Security model](https://github.com/Akira-TL/forgerelay/wiki/Security) f
 
 - [Getting Started](https://github.com/Akira-TL/forgerelay/wiki/Getting-Started)
 - [Configuration](https://github.com/Akira-TL/forgerelay/wiki/Configuration)
+- [External MCP](https://github.com/Akira-TL/forgerelay/wiki/External-MCP)
 - [Security model](https://github.com/Akira-TL/forgerelay/wiki/Security)
 - [Troubleshooting](https://github.com/Akira-TL/forgerelay/wiki/Troubleshooting)
 - [Full Wiki](https://github.com/Akira-TL/forgerelay/wiki)

package/dist/activity/runtime/mcp-query-tools.js

@@ -1,5 +1,6 @@
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import * as z from "zod/v4";
+import { mcpHandlerRequestContext } from "../../mcp/request-context.js";
 import { logEvent, transportSessionIdPrefix } from "../../runtime/logging/logger.js";
 import { hostConversationScopeId } from "../../mcp/request-meta.js";
 import { ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY, ACTIVITY_PANEL_WORKSPACE_META_KEY, } from "../ui/contract.js";
@@ -68,11 +69,12 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
             idempotentHint: false,
         },
     }, async ({ workspaceId }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         const workspace = workspacePanelState?.(workspaceId);
         if (!workspace) {
             throw new Error(`No Workspace presentation is available for ${workspaceId}. Call open_workspace for that workspace before activity_panel.`);
         }
-        const conversationScopeId = hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId);
+        const conversationScopeId = hostConversationScopeId(requestContext, connectionScopeId);
         const relayed = await relay?.panel(workspaceId, conversationScopeId);
         if (relayed) {
             return {
@@ -91,7 +93,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                 revision: snapshot.revision,
                 state: snapshot.state,
                 workspaceId,
-                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+                transportSessionIdPrefix: transportSessionIdPrefix(requestContext.transportSessionId),
             });
         }
         return {
@@ -118,7 +120,8 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
     }, async ({ turnId, workspaceId, knownRevision }, extra) => {
-        const conversationScopeId = hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId);
+        const requestContext = mcpHandlerRequestContext(extra);
+        const conversationScopeId = hostConversationScopeId(requestContext, connectionScopeId);
         const relayed = await relay?.snapshot({ turnId, workspaceId, knownRevision }, conversationScopeId);
         if (relayed) {
             const workspace = workspaceId ? workspacePanelState?.(workspaceId) : undefined;
@@ -149,7 +152,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                 revision: snapshot.revision,
                 changed: snapshot.changed,
                 state: snapshot.state,
-                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+                transportSessionIdPrefix: transportSessionIdPrefix(requestContext.transportSessionId),
             });
         }
         const workspace = workspaceId ? workspacePanelState?.(workspaceId) : undefined;
@@ -176,7 +179,8 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
     }, async ({ turnId, knownRevision }, extra) => {
-        const conversationScopeId = hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId);
+        const requestContext = mcpHandlerRequestContext(extra);
+        const conversationScopeId = hostConversationScopeId(requestContext, connectionScopeId);
         const relayed = await relay?.index(turnId, knownRevision, conversationScopeId);
         if (relayed)
             return relayed;
@@ -189,7 +193,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                 changed: index.changed,
                 state: index.state,
                 activities: index.activities.length,
-                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+                transportSessionIdPrefix: transportSessionIdPrefix(requestContext.transportSessionId),
             });
         }
         return {
@@ -213,7 +217,8 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
     }, async ({ turnId, activityId }, extra) => {
-        const conversationScopeId = hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId);
+        const requestContext = mcpHandlerRequestContext(extra);
+        const conversationScopeId = hostConversationScopeId(requestContext, connectionScopeId);
         const relayed = await relay?.detail(turnId, activityId, conversationScopeId);
         if (relayed)
             return relayed;
@@ -225,7 +230,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                 tool: detail.activity.tool,
                 kind: detail.activity.kind,
                 state: detail.activity.state,
-                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+                transportSessionIdPrefix: transportSessionIdPrefix(requestContext.transportSessionId),
             });
         }
         return {
@@ -258,7 +263,8 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
     }, async ({ turnId, outputId, cursor }, extra) => {
-        const conversationScopeId = hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId);
+        const requestContext = mcpHandlerRequestContext(extra);
+        const conversationScopeId = hostConversationScopeId(requestContext, connectionScopeId);
         const relayed = await relay?.output(turnId, outputId, conversationScopeId, cursor);
         if (relayed)
             return relayed;
@@ -273,7 +279,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                 processId: output.processId,
                 status: output.status,
                 outputBytes: Buffer.byteLength(output.output),
-                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+                transportSessionIdPrefix: transportSessionIdPrefix(requestContext.transportSessionId),
             });
         }
         return {

package/dist/cli/mcp/external-mcp.js

@@ -0,0 +1,481 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { stdin as input, stdout as output } from "node:process";
+import * as prompts from "@clack/prompts";
+import { computeScopeUnion, selectClientAuthMethod, } from "@modelcontextprotocol/client";
+import { externalMcpCredentialIdentity, } from "../../runtime/config/external-mcp-auth-store.js";
+import { ExternalMcpInteractiveOAuthProvider, beginExternalMcpInteractiveOAuth, finishExternalMcpInteractiveOAuth, } from "../../mcp/operations/external-mcp/external-mcp-oauth.js";
+import { ExternalMcpError, ExternalMcpGateway, } from "../../mcp/operations/external-mcp/external-mcp.js";
+import { findExternalMcpServerStatus, formatAuth, formatExternalMcpList, inspectExternalMcpStatus, resolveExternalMcpScope, } from "./status.js";
+const CALLBACK_TIMEOUT_MS = 5 * 60 * 1_000;
+export async function runExternalMcpCommand(args, dependencies = {}) {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case "list":
+        case "ls":
+            await runExternalMcpList(parseMcpScopeArgs("list", rest), dependencies);
+            return;
+        case "test":
+            await runExternalMcpTest(parseMcpTargetArgs("test", rest), dependencies);
+            return;
+        case "auth":
+            await runExternalMcpAuth(parseMcpTargetArgs("auth", rest), dependencies);
+            return;
+        case "logout":
+            await runExternalMcpLogout(parseMcpTargetArgs("logout", rest), dependencies);
+            return;
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            printMcpHelp();
+            return;
+        default:
+            throw new Error(`Unknown mcp command: ${subcommand}`);
+    }
+}
+function parseMcpScopeArgs(command, args) {
+    let projectRoot;
+    let global = false;
+    const rest = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--project") {
+            projectRoot = args[++index];
+            if (!projectRoot)
+                throw new Error("Missing value for --project.");
+            continue;
+        }
+        if (arg === "--global") {
+            global = true;
+            continue;
+        }
+        if (arg.startsWith("-"))
+            throw new Error(`Unknown mcp ${command} option: ${arg}`);
+        rest.push(arg);
+    }
+    if (global && projectRoot)
+        throw new Error("--global and --project cannot be used together.");
+    return {
+        ...(projectRoot ? { projectRoot } : {}),
+        ...(global ? { global: true } : {}),
+        rest,
+    };
+}
+function parseMcpTargetArgs(command, args) {
+    const parsed = parseMcpScopeArgs(command, args);
+    if (parsed.rest.length !== 1) {
+        throw new Error(`Usage: forgerelay mcp ${command} <server> [--project <path>|--global]`);
+    }
+    return {
+        server: parsed.rest[0],
+        ...(parsed.projectRoot ? { projectRoot: parsed.projectRoot } : {}),
+        ...(parsed.global ? { global: true } : {}),
+    };
+}
+async function runExternalMcpList(options, dependencies) {
+    if (options.rest.length > 0) {
+        throw new Error("Usage: forgerelay mcp list [--project <path>|--global]");
+    }
+    const scope = resolveExternalMcpScope(options, dependencies);
+    const status = inspectExternalMcpStatus(scope);
+    console.log(formatExternalMcpList(status));
+    if (status.configIssues > 0) {
+        throw new Error("External MCP configuration or credential status contains issues.");
+    }
+}
+async function runExternalMcpTest(options, dependencies) {
+    const scope = resolveExternalMcpScope(options, dependencies);
+    const initialStatus = inspectExternalMcpStatus(scope);
+    const serverStatus = findExternalMcpServerStatus(initialStatus, options.server);
+    if (!serverStatus)
+        throw new Error(`Unknown configured External MCP server: ${options.server}.`);
+    if (!serverStatus.enabled) {
+        throw new Error(`External MCP ${options.server} is disabled by ${serverStatus.source} configuration.`);
+    }
+    const config = scope.snapshot.servers[options.server];
+    if (!config)
+        throw new Error(`Unknown configured External MCP server: ${options.server}.`);
+    printTestTarget(scope, serverStatus);
+    const gateway = new ExternalMcpGateway(scope.config.mediaMaxBytes, scope.store);
+    try {
+        const probe = await gateway.probe(scope.snapshot.servers, options.server, undefined, { workspaceRoot: scope.projectRoot, origins: scope.snapshot.origins });
+        console.log("Connection: ok");
+        console.log(`Protocol: ${probe.protocolEra}` +
+            (probe.protocolVersion ? ` · ${probe.protocolVersion}` : ""));
+        console.log(`Tools: ${probe.toolCount}${probe.truncated ? "+ · truncated" : ""}`);
+        console.log(`${options.server} is ready.`);
+    }
+    catch (error) {
+        if (!(error instanceof ExternalMcpError))
+            throw error;
+        const latestStatus = inspectExternalMcpStatus(scope);
+        const latestServer = findExternalMcpServerStatus(latestStatus, options.server) ?? serverStatus;
+        if (error.code === "auth_required" || error.code === "reauthorization_required") {
+            console.log(`Auth: ${formatAuth(latestServer)}`);
+            console.log("Connection: blocked by authentication");
+            console.log(`Reason: ${error.message}`);
+            console.log(`Next: ${externalMcpAuthCommand(scope, options.server)}`);
+        }
+        else if (error.code === "tool_discovery_failed") {
+            console.log("Connection: ok");
+            console.log("Tools: failed");
+            console.log(`Reason: ${error.detail ?? "MCP tools/list failed."}`);
+            console.log("Next: check the MCP server logs and retry this test.");
+        }
+        else {
+            console.log("Connection: failed");
+            console.log(`Reason: ${error.detail ?? "MCP connection or protocol handshake failed."}`);
+            console.log("Next: check the server configuration, process/network reachability, and retry this test.");
+        }
+        throw new Error(`External MCP ${options.server} test failed.`);
+    }
+}
+function printTestTarget(scope, server) {
+    console.log(`Testing External MCP ${server.name}`);
+    if (scope.mode === "project")
+        console.log(`Project: ${scope.projectRoot}`);
+    console.log(`Source: ${server.source}`);
+    console.log(`Transport: ${server.transport}`);
+    console.log(`Auth: ${formatAuth(server)}`);
+}
+function externalMcpAuthCommand(scope, server) {
+    return scope.mode === "global"
+        ? `forgerelay mcp auth ${cliArgument(server)} --global`
+        : `forgerelay mcp auth ${cliArgument(server)} --project ${cliArgument(scope.projectRoot)}`;
+}
+function cliArgument(value) {
+    return /^[A-Za-z0-9_./:\\-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function formatCredentialScope(source, projectRoot) {
+    return source === "project" ? `project · ${projectRoot}` : "global";
+}
+async function runExternalMcpAuth(options, dependencies) {
+    assertInteractive(dependencies);
+    const target = resolveExternalMcpCliTarget(options, dependencies);
+    if (hasStaticAuthorizationHeader(target.serverConfig.headers)) {
+        throw new Error(`External MCP ${target.server} uses a static Authorization header; remove that header before using OAuth authentication.`);
+    }
+    console.log(`Authenticating External MCP ${target.server}`);
+    console.log(`Source: ${target.source}`);
+    console.log(`Transport: ${target.serverConfig.transport}`);
+    console.log(`Credential scope: ${formatCredentialScope(target.source, target.projectRoot)}`);
+    const identity = externalMcpCredentialIdentity(target.source, target.server, target.projectRoot);
+    const existing = target.store.read(identity);
+    const receiver = await (dependencies.createLoopbackReceiver ?? createLoopbackReceiver)(target.serverConfig.oauth?.callbackPort);
+    let authorizationUrl;
+    let authorizationServerPrinted = false;
+    let needsPaste = dependencies.headless ?? isHeadlessEnvironment(dependencies.env ?? process.env);
+    try {
+        const provider = new ExternalMcpInteractiveOAuthProvider({
+            serverUrl: target.serverConfig.url,
+            redirectUrl: receiver.redirectUrl,
+            ...(target.serverConfig.oauth?.clientMetadataUrl
+                ? { clientMetadataUrl: target.serverConfig.oauth.clientMetadataUrl }
+                : {}),
+            existing,
+            onAuthorizationUrl: async (url) => {
+                authorizationUrl = new URL(url);
+                await dependencies.observeAuthorizationUrl?.(url);
+                const authorizationServer = provider.authorizationServerUrl();
+                if (authorizationServer && !authorizationServerPrinted) {
+                    authorizationServerPrinted = true;
+                    console.log(`Authorization server: ${authorizationServer}`);
+                }
+                console.log(`Authorization URL: ${url.toString()}`);
+                if (needsPaste)
+                    return;
+                const opened = await (dependencies.openBrowser ?? openBrowser)(url);
+                if (opened) {
+                    console.log("Opened the authorization URL in your browser.");
+                }
+                else {
+                    needsPaste = true;
+                    console.log("Could not open a browser automatically; open the authorization URL manually.");
+                }
+            },
+        });
+        await beginExternalMcpInteractiveOAuth(provider, target.serverConfig.url, computeScopeUnion(existing?.tokens?.scope, existing?.reauthorization?.scope));
+        if (!authorizationUrl)
+            throw new Error("External MCP OAuth did not provide an authorization URL.");
+        let callbackUrl;
+        if (needsPaste) {
+            console.log("After authorization, paste the final callback URL below.");
+            callbackUrl = parseCallbackUrl(await promptMaskedCallback(dependencies));
+        }
+        else {
+            try {
+                console.log("Waiting for the browser callback...");
+                callbackUrl = await receiver.waitForCallback(CALLBACK_TIMEOUT_MS);
+            }
+            catch {
+                console.log("Browser callback was not received. Paste the final callback URL below.");
+                callbackUrl = parseCallbackUrl(await promptMaskedCallback(dependencies));
+            }
+        }
+        const staged = await finishExternalMcpInteractiveOAuth(provider, target.serverConfig.url, callbackUrl);
+        await target.store.withIdentityLock(identity, () => target.store.replace(identity, target.serverConfig.url, staged));
+        console.log(`Granted scopes: ${staged.tokens?.scope?.trim() || "not reported"}`);
+        console.log(`Authenticated External MCP ${target.server} (${target.source}).`);
+        console.log(`Credential store: ${target.store.filePath}`);
+    }
+    finally {
+        await receiver.close().catch(() => undefined);
+    }
+}
+async function runExternalMcpLogout(options, dependencies) {
+    const target = resolveExternalMcpCliTarget(options, dependencies);
+    console.log(`Logging out External MCP ${target.server}`);
+    console.log(`Source: ${target.source}`);
+    console.log(`Credential scope: ${formatCredentialScope(target.source, target.projectRoot)}`);
+    const identity = externalMcpCredentialIdentity(target.source, target.server, target.projectRoot);
+    let existing;
+    await target.store.withIdentityLock(identity, async () => {
+        existing = target.store.read(identity);
+        if (existing)
+            await target.store.remove(identity);
+    });
+    if (!existing) {
+        console.log(`No stored OAuth credential for External MCP ${target.server} (${target.source}).`);
+        return;
+    }
+    let revocation = "unsupported";
+    try {
+        revocation = await revokeCredential(existing);
+    }
+    catch {
+        revocation = "failed";
+    }
+    console.log(`Removed local OAuth credential for External MCP ${target.server} (${target.source}).`);
+    if (revocation === "revoked")
+        console.log("Remote revocation: succeeded.");
+    else if (revocation === "unsupported")
+        console.log("Remote revocation: not advertised by the authorization server.");
+    else
+        console.log("Remote revocation: failed; the local credential was still removed.");
+}
+function resolveExternalMcpCliTarget(options, dependencies) {
+    const scope = resolveExternalMcpScope(options, dependencies);
+    const serverConfig = scope.snapshot.servers[options.server];
+    const source = scope.snapshot.origins[options.server];
+    if (!serverConfig || !source) {
+        const maskedBy = scope.snapshot.masked[options.server];
+        if (maskedBy) {
+            throw new Error(`External MCP ${options.server} is disabled by ${maskedBy} configuration.`);
+        }
+        throw new Error(`Unknown configured External MCP server: ${options.server}.`);
+    }
+    if (serverConfig.transport !== "streamable-http") {
+        throw new Error(`External MCP ${options.server} uses stdio; interactive OAuth is only available for streamable-http servers.`);
+    }
+    return {
+        store: scope.store,
+        projectRoot: scope.projectRoot,
+        server: options.server,
+        source,
+        serverConfig,
+    };
+}
+async function revokeCredential(record) {
+    const metadata = record.discoveryState?.authorizationServerMetadata;
+    if (!metadata || !("revocation_endpoint" in metadata) || typeof metadata.revocation_endpoint !== "string") {
+        return "unsupported";
+    }
+    const endpoint = metadata.revocation_endpoint;
+    const token = record.tokens?.refresh_token ?? record.tokens?.access_token;
+    if (!token || !record.clientInformation)
+        return "unsupported";
+    const url = new URL(endpoint);
+    assertSecureOAuthEndpoint(url);
+    const params = new URLSearchParams({
+        token,
+        token_type_hint: record.tokens?.refresh_token ? "refresh_token" : "access_token",
+    });
+    const headers = new Headers({
+        "content-type": "application/x-www-form-urlencoded",
+        accept: "application/json",
+    });
+    applyClientAuthentication(record.clientInformation, metadata, headers, params);
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: params,
+        signal: AbortSignal.timeout(15_000),
+    });
+    await response.text().catch(() => "");
+    if (!response.ok)
+        throw new Error(`OAuth revocation failed with HTTP ${response.status}.`);
+    return "revoked";
+}
+function applyClientAuthentication(client, metadata, headers, params) {
+    const supported = metadata
+        && "revocation_endpoint_auth_methods_supported" in metadata
+        && Array.isArray(metadata.revocation_endpoint_auth_methods_supported)
+        ? metadata.revocation_endpoint_auth_methods_supported
+        : metadata?.token_endpoint_auth_methods_supported ?? [];
+    const method = selectClientAuthMethod(client, supported);
+    if (method === "client_secret_basic") {
+        if (!client.client_secret)
+            throw new Error("OAuth revocation requires a client secret.");
+        headers.set("authorization", `Basic ${Buffer.from(`${client.client_id}:${client.client_secret}`, "utf8").toString("base64")}`);
+        return;
+    }
+    params.set("client_id", client.client_id);
+    if (method === "client_secret_post" && client.client_secret)
+        params.set("client_secret", client.client_secret);
+}
+function assertSecureOAuthEndpoint(url) {
+    const loopback = ["localhost", "127.0.0.1", "::1", "[::1]"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+        throw new Error("Refusing OAuth revocation over an insecure non-loopback endpoint.");
+    }
+}
+function hasStaticAuthorizationHeader(headers) {
+    return Object.keys(headers ?? {}).some((name) => name.toLowerCase() === "authorization");
+}
+function assertInteractive(dependencies) {
+    const interactive = dependencies.isInteractive ?? (Boolean(input.isTTY) && Boolean(output.isTTY));
+    if (!interactive) {
+        throw new Error("forgerelay mcp auth requires an interactive terminal for browser/callback authorization.");
+    }
+}
+async function promptMaskedCallback(dependencies) {
+    if (dependencies.promptCallbackUrl)
+        return dependencies.promptCallbackUrl();
+    const result = await prompts.password({
+        message: "Final OAuth callback URL",
+        mask: "*",
+        validate: (value) => value?.trim() ? undefined : "Paste the final callback URL.",
+    });
+    if (prompts.isCancel(result))
+        throw new Error("External MCP authentication cancelled.");
+    return String(result);
+}
+function parseCallbackUrl(value) {
+    try {
+        return new URL(value.trim());
+    }
+    catch {
+        throw new Error("The pasted OAuth callback URL is not a valid URL.");
+    }
+}
+async function createLoopbackReceiver(port = 0) {
+    let resolveCallback;
+    let rejectCallback;
+    let settled = false;
+    let timer;
+    const callbackPromise = new Promise((resolvePromise, rejectPromise) => {
+        resolveCallback = resolvePromise;
+        rejectCallback = rejectPromise;
+    });
+    const server = createServer((request, response) => {
+        if (!request.url || request.method !== "GET") {
+            response.writeHead(405, { "content-type": "text/plain; charset=utf-8" });
+            response.end("Method not allowed.\n");
+            return;
+        }
+        const address = server.address();
+        const url = new URL(request.url, `http://127.0.0.1:${address?.port ?? 0}`);
+        if (url.pathname !== "/callback") {
+            response.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+            response.end("Not found.\n");
+            return;
+        }
+        response.writeHead(200, {
+            "content-type": "text/plain; charset=utf-8",
+            "cache-control": "no-store",
+        });
+        response.end("ForgeRelay received the authorization response. You can return to the terminal.\n");
+        if (!settled) {
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolveCallback(url);
+        }
+    });
+    server.on("error", (error) => {
+        if (!settled) {
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            rejectCallback(error);
+        }
+    });
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        server.listen(port, "127.0.0.1", () => {
+            server.off("error", rejectListen);
+            resolveListen();
+        });
+    });
+    const listeningPort = server.address().port;
+    return {
+        redirectUrl: new URL(`http://127.0.0.1:${listeningPort}/callback`),
+        waitForCallback(timeoutMs = CALLBACK_TIMEOUT_MS) {
+            if (!settled && !timer) {
+                timer = setTimeout(() => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    rejectCallback(new Error("Timed out waiting for OAuth callback."));
+                }, timeoutMs);
+                timer.unref?.();
+            }
+            return callbackPromise;
+        },
+        async close() {
+            if (timer)
+                clearTimeout(timer);
+            if (!server.listening)
+                return;
+            await new Promise((resolveClose) => server.close(() => resolveClose()));
+        },
+    };
+}
+async function openBrowser(url) {
+    const command = browserCommand(url.toString());
+    if (!command)
+        return false;
+    return new Promise((resolveOpen) => {
+        const child = spawn(command.file, command.args, {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        let resolved = false;
+        child.once("spawn", () => {
+            resolved = true;
+            child.unref();
+            resolveOpen(true);
+        });
+        child.once("error", () => {
+            if (!resolved)
+                resolveOpen(false);
+        });
+    });
+}
+function browserCommand(url) {
+    if (process.platform === "darwin")
+        return { file: "open", args: [url] };
+    if (process.platform === "win32")
+        return { file: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url] };
+    return { file: "xdg-open", args: [url] };
+}
+function isHeadlessEnvironment(env) {
+    if (env.SSH_CONNECTION || env.SSH_TTY)
+        return true;
+    if (process.platform !== "linux")
+        return false;
+    return !env.DISPLAY && !env.WAYLAND_DISPLAY;
+}
+function printMcpHelp() {
+    console.log([
+        "ForgeRelay mcp",
+        "",
+        "Usage:",
+        "  forgerelay mcp list [--project <path>|--global]",
+        "  forgerelay mcp test <server> [--project <path>|--global]",
+        "  forgerelay mcp auth <server> [--project <path>|--global]",
+        "  forgerelay mcp logout <server> [--project <path>|--global]",
+    ].join("\n"));
+}