@akira-tl/forgerelay 1.0.1 → 1.1.1

package/dist/mcp/server/workspace/runtime/workspace-open.js

@@ -1,5 +1,5 @@
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
-import { openAiConversationScopeId } from "../../../request-meta.js";
+import { mcpHandlerRequestContext } from "../../../request-context.js";
 import { formatPathForPrompt } from "../../../../workspaces/resources/skills.js";
 import { compositeCapabilityContext } from "../../core/capability-support.js";
 import { compositeWorkspaceLogContext, logToolCall, textBlock } from "../../core/tool-support.js";
@@ -7,14 +7,13 @@ import { openWorkspaceToolDefinition } from "./workspace-open-schema.js";
 import { presentLocalWorkspaceOpen, workspaceTaskUsageInstruction, } from "./workspace-open-presentation.js";
 export function registerOpenWorkspaceTool(options) {
     const { server } = options;
-    registerAppTool(server, "open_workspace", openWorkspaceToolDefinition, (args, extra) => handleOpenWorkspace(options, args, extra));
+    registerAppTool(server, "open_workspace", openWorkspaceToolDefinition, (args, extra) => handleOpenWorkspace(options, args, mcpHandlerRequestContext(extra)));
 }
-async function handleOpenWorkspace(options, input, extra) {
-    const { config, workspaces, remoteWorkspaces, compositeWorkspaces, workspaceTasks, processSessions, capabilityRegistry, compositeTaskGuides, loadCompositeMemberContext, rememberWorkspacePanelState, hostScopeIdFor, presentation, } = options;
+async function handleOpenWorkspace(options, input, requestContext) {
+    const { config, workspaces, remoteWorkspaces, compositeWorkspaces, workspaceTasks, processSessions, capabilityRegistry, compositeTaskGuides, loadCompositeMemberContext, rememberWorkspacePanelState, hostScopeIdFor, contextDeliveryScopeIdFor, presentation, } = options;
     const { action = "open", memberAction, member, kind, name, memberName, path, relay, workspaceId, mode, baseRef, newWorktree, newWorkspace, context, root, status, state, staleOnly, offset, limit, } = input;
-    const { _meta, sessionId } = extra;
     const startedAt = performance.now();
-    const conversationScopeId = openAiConversationScopeId(_meta);
+    const conversationScopeId = contextDeliveryScopeIdFor(requestContext);
     const protectedWorkspaceIds = processSessions.activeWorkspaceIds();
     const inspectTaskSummary = (targetWorkspaceId) => {
         try {
@@ -469,7 +468,7 @@ async function handleOpenWorkspace(options, input, extra) {
             newWorktree !== undefined || newWorkspace !== undefined) {
             throw new Error("Resuming a relayed Workspace by workspaceId accepts context only.");
         }
-        const resumed = await remoteWorkspaces.resumeWorkspace(workspaceId, context ?? "auto", hostScopeIdFor(_meta, sessionId));
+        const resumed = await remoteWorkspaces.resumeWorkspace(workspaceId, context ?? "auto", hostScopeIdFor(requestContext));
         rememberWorkspacePanelState(workspaceId, resumed);
         return resumed;
     }
@@ -483,7 +482,7 @@ async function handleOpenWorkspace(options, input, extra) {
             newWorktree,
             newWorkspace,
             context,
-        }, hostScopeIdFor(_meta, sessionId));
+        }, hostScopeIdFor(requestContext));
         const relayedSkills = Array.isArray(opened.skills)
             ? opened.skills
             : [];
@@ -568,5 +567,10 @@ async function handleOpenWorkspace(options, input, extra) {
         rememberWorkspacePanelState(opened.workspaceId, response);
         return response;
     }
-    return presentLocalWorkspaceOpen(presentation, input, { conversationScopeId, protectedWorkspaceIds, startedAt, sessionId });
+    return presentLocalWorkspaceOpen(presentation, input, {
+        conversationScopeId,
+        protectedWorkspaceIds,
+        startedAt,
+        sessionId: requestContext.transportSessionId,
+    });
 }

package/dist/mcp/server/workspace/runtime/workspace-tools.js

@@ -1,5 +1,6 @@
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import * as z from "zod/v4";
+import { mcpHandlerRequestContext } from "../../../request-context.js";
 import { CapabilityError } from "../../core/capability-registry.js";
 import { attachHookReports, runToolWithHooks } from "../../../hooks/hooks.js";
 import { toolNames } from "../../../server-instructions.js";
@@ -36,8 +37,9 @@ export function registerWorkspaceAuxiliaryTools(options) {
             openWorldHint: false,
         },
     }, async ({ workspaceId, path }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         if (remoteWorkspaces.has(workspaceId)) {
-            return remoteWorkspaces.workspaceInstruction(workspaceId, path, hostScopeIdFor(extra._meta, extra.sessionId));
+            return remoteWorkspaces.workspaceInstruction(workspaceId, path, hostScopeIdFor(requestContext));
         }
         if (compositeWorkspaces.has(workspaceId)) {
             throw new Error("Composite Workspace instructions belong to a selected member; open that member context before viewing its instruction files.");
@@ -91,6 +93,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
             openWorldHint: true,
         },
     }, async ({ workspaceId, member, name, action, arguments: capabilityArguments, file }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         if (name === "workspace.tasks" && compositeWorkspaces.has(workspaceId)) {
             if (member !== undefined) {
                 throw new Error(`workspace.tasks belongs to Composite Workspace ${workspaceId} itself and does not accept member.`);
@@ -105,9 +108,9 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 if (action === "run") {
                     const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, context, {
                         nativeFile: file,
-                        signal: extra.signal,
-                        requestMeta: extra._meta,
-                        sessionId: extra.sessionId,
+                        signal: requestContext.signal,
+                        requestMeta: requestContext.requestMeta,
+                        sessionId: requestContext.transportSessionId,
                     });
                     const result = {
                         content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
@@ -146,7 +149,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 return result;
             }
             catch (error) {
-                if (extra.signal.aborted)
+                if (requestContext.signal.aborted)
                     throw error;
                 const capabilityError = error instanceof CapabilityError
                     ? error
@@ -171,16 +174,16 @@ export function registerWorkspaceAuxiliaryTools(options) {
         }
         const target = resolveExecutionTarget(workspaceId, member);
         const executionWorkspaceId = target.executionWorkspaceId;
-        const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+        const executionContext = await prepareExecutionContext(target, requestContext);
         if (remoteWorkspaces.has(executionWorkspaceId)) {
             const response = await remoteWorkspaces.capability(executionWorkspaceId, {
                 name,
                 action,
                 ...(capabilityArguments !== undefined ? { arguments: capabilityArguments } : {}),
                 ...(file !== undefined ? { file } : {}),
-            }, hostScopeIdFor(extra._meta, extra.sessionId));
+            }, hostScopeIdFor(requestContext));
             return action === "run" && name !== "workspace.tasks"
-                ? presentSemanticWorkResult(response, target, hostScopeIdFor(extra._meta, extra.sessionId))
+                ? presentSemanticWorkResult(response, target, hostScopeIdFor(requestContext))
                 : presentExecutionResult(response, target);
         }
         if (action === "run" && name === "batch.execute") {
@@ -189,9 +192,9 @@ export function registerWorkspaceAuxiliaryTools(options) {
             try {
                 const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, capabilityContextFor(workspace), {
                     nativeFile: file,
-                    signal: extra.signal,
-                    requestMeta: extra._meta,
-                    sessionId: extra.sessionId,
+                    signal: requestContext.signal,
+                    requestMeta: requestContext.requestMeta,
+                    sessionId: requestContext.transportSessionId,
                 });
                 const result = {
                     content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
@@ -199,16 +202,16 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 };
                 logToolCall(config, {
                     tool: toolNames.capability,
-                    ...workspaceLogContext(workspace, extra.sessionId),
+                    ...workspaceLogContext(workspace, requestContext.transportSessionId),
                     capability: name,
                     action,
                     success: true,
                     durationMs: Math.round(performance.now() - startedAt),
                 });
-                return presentSemanticWorkResult(result, target, hostScopeIdFor(extra._meta, extra.sessionId));
+                return presentSemanticWorkResult(result, target, hostScopeIdFor(requestContext));
             }
             catch (error) {
-                if (extra.signal.aborted)
+                if (requestContext.signal.aborted)
                     throw error;
                 const capabilityError = error instanceof CapabilityError
                     ? error
@@ -224,7 +227,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 };
                 logFailedToolResponse(config, {
                     tool: toolNames.capability,
-                    ...workspaceLogContext(workspace, extra.sessionId),
+                    ...workspaceLogContext(workspace, requestContext.transportSessionId),
                     capability: name,
                     action,
                 }, result.content, startedAt);
@@ -235,11 +238,11 @@ export function registerWorkspaceAuxiliaryTools(options) {
             const response = await coreOperations.capabilityRun({ workspaceId: executionWorkspaceId, name, arguments: capabilityArguments, file }, executionContext);
             return name === "workspace.tasks"
                 ? presentExecutionResult(response, target)
-                : presentSemanticWorkResult(response, target, hostScopeIdFor(extra._meta, extra.sessionId));
+                : presentSemanticWorkResult(response, target, hostScopeIdFor(requestContext));
         }
         const workspace = workspaces.getWorkspace(executionWorkspaceId);
-        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), activityRequestFor({ workspaceId: executionWorkspaceId, name, action, arguments: capabilityArguments, file }, executionContext), {
-            signal: extra.signal,
+        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(requestContext), activityRequestFor({ workspaceId: executionWorkspaceId, name, action, arguments: capabilityArguments, file }, executionContext), {
+            signal: requestContext.signal,
             tool: toolNames.capability,
             invocation: workspaceHookInvocation(workspace),
             payload: { name, action },
@@ -332,6 +335,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
         _meta: {},
         annotations: WRITE_TOOL_ANNOTATIONS,
     }, async ({ workspaceId, action = "close", commitMessage }, extra) => {
+        const requestContext = mcpHandlerRequestContext(extra);
         if (compositeWorkspaces.has(workspaceId)) {
             const startedAt = performance.now();
             if (commitMessage !== undefined) {
@@ -392,7 +396,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
             };
         }
         if (remoteWorkspaces.has(workspaceId)) {
-            const response = await remoteWorkspaces.closeWorkspace(workspaceId, { action, ...(commitMessage !== undefined ? { commitMessage } : {}) }, hostScopeIdFor(extra._meta, extra.sessionId));
+            const response = await remoteWorkspaces.closeWorkspace(workspaceId, { action, ...(commitMessage !== undefined ? { commitMessage } : {}) }, hostScopeIdFor(requestContext));
             if (action === "delete") {
                 activityQueries.deleteWorkspaceHistory(config.stateDir, workspaceId);
             }
@@ -409,7 +413,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 throw new Error(`Workspace ${session.id} still owns a running process. Poll, interrupt, or wait for it before deleting this Workspace.`);
             }
             const response = await runToolWithHooks(hooks, {
-                signal: extra.signal,
+                signal: requestContext.signal,
                 tool: toolNames.closeWorkspace,
                 invocation: {
                     workspaceId: session.id,
@@ -428,7 +432,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                     const result = `Deleted ForgeRelay Workspace ${session.id}. Physical project files were not removed.`;
                     logToolCall(config, {
                         tool: toolNames.closeWorkspace,
-                        ...workspaceLogContext(session, extra.sessionId),
+                        ...workspaceLogContext(session, requestContext.transportSessionId),
                         action: "delete",
                         path: session.root,
                         success: true,
@@ -463,7 +467,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
             }
             const hookRoot = session.sourceRoot ?? session.root;
             const response = await runToolWithHooks(hooks, {
-                signal: extra.signal,
+                signal: requestContext.signal,
                 tool: toolNames.closeWorkspace,
                 invocation: {
                     workspaceId: session.id,
@@ -509,7 +513,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
         }
         const workspace = workspaces.getWorkspace(session.id);
         const response = await runToolWithHooks(hooks, {
-            signal: extra.signal,
+            signal: requestContext.signal,
             tool: toolNames.closeWorkspace,
             invocation: workspaceHookInvocation(workspace),
             payload: { workspaceId: workspace.id, action, commitMessage, mode: workspace.mode },
@@ -558,7 +562,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                     ].join("\n");
                     logToolCall(config, {
                         tool: toolNames.closeWorkspace,
-                        ...workspaceLogContext(workspace, extra.sessionId),
+                        ...workspaceLogContext(workspace, requestContext.transportSessionId),
                         action,
                         path: closed.sourceRoot,
                         success: true,
@@ -610,7 +614,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 const result = `Closed checkout-backed Workspace ${checkoutWorkspaceId}; its ForgeRelay identity was preserved for later reopen. Physical project files were not removed.`;
                 logToolCall(config, {
                     tool: toolNames.closeWorkspace,
-                    ...workspaceLogContext(workspace, extra.sessionId),
+                    ...workspaceLogContext(workspace, requestContext.transportSessionId),
                     action: "close",
                     path: workspace.root,
                     success: true,

package/dist/runtime/config/config.js

@@ -4,6 +4,8 @@ import { join, resolve } from "node:path";
 import { expandHomePath } from "../../mcp/filesystem/roots.js";
 import { mergeHookConfigs, parseHookConfig } from "../../mcp/hooks/hooks.js";
 import { forgerelayAgentsDir, forgerelaySkillsDir, generateInstanceId, loadForgeRelayFiles, } from "./user-config.js";
+import { parseExternalMcpServers, } from "./external-mcp-config.js";
+import { DEFAULT_MEDIA_MAX_BYTES } from "../../mcp/operations/media-content.js";
 import { shellInstructionPath } from "../instructions/shell-instructions.js";
 import { resolveConfiguredCommandShellRuntime, } from "../shell/command-shell-runtime.js";
 const DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
@@ -303,6 +305,7 @@ export function loadConfig(env = process.env) {
             ? files.config.artifactsEnabled === true
             : parseBoolean(productEnv(env, "ARTIFACTS")),
         artifactMaxFileBytes: parsePositiveInteger(productEnv(env, "ARTIFACT_MAX_FILE_BYTES") ?? numberConfigValue(files.config.artifactMaxFileBytes), DEFAULT_ARTIFACT_MAX_FILE_BYTES, "FORGERELAY_ARTIFACT_MAX_FILE_BYTES"),
+        mediaMaxBytes: parsePositiveInteger(productEnv(env, "MEDIA_MAX_BYTES") ?? numberConfigValue(files.config.mediaMaxBytes), DEFAULT_MEDIA_MAX_BYTES, "FORGERELAY_MEDIA_MAX_BYTES"),
         taskReminderInterval: parseNonNegativeInteger(productEnv(env, "TASK_REMINDER_INTERVAL") ?? numberConfigValue(files.config.taskReminderInterval), DEFAULT_TASK_REMINDER_INTERVAL, "FORGERELAY_TASK_REMINDER_INTERVAL"),
         skillsEnabled: productEnv(env, "SKILLS") === undefined ? true : parseBoolean(productEnv(env, "SKILLS")),
         skillPaths: parsePathList(productEnv(env, "SKILL_PATHS")),
@@ -313,6 +316,7 @@ export function loadConfig(env = process.env) {
             : parseBoolean(productEnv(env, "SUBAGENTS")),
         languageServers: files.config.languageServers ?? {},
         allowAgentLanguageServerInstall: files.config.allowAgentLanguageServerInstall === true,
+        mcpServers: parseExternalMcpServers(files.config.mcpServers),
         agentDir: resolve(expandHomePath(productEnv(env, "AGENT_DIR") ?? files.config.agentDir ?? defaultAgentDir())),
         systemInstructionsPath: parseSystemInstructionsPath(productEnv(env, "SYSTEM_INSTRUCTIONS_PATH") ?? files.config.systemInstructionsPath),
         hooks: mergeHookConfigs(parseHookConfig(files.config.hooks), parseHookConfig(files.hooks), files.hookFiles),

package/dist/runtime/config/external-mcp-auth-store.js

@@ -0,0 +1,225 @@
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { withFileLock } from "../state/lock/file-lock.js";
+import { forgerelayConfigDir } from "./user-config.js";
+const AUTH_FILE_VERSION = 1;
+const AUTH_FILE_NAME = "mcp-auth.json";
+export class ExternalMcpCredentialStore {
+    configDir;
+    filePath;
+    constructor(options = {}) {
+        this.configDir = resolve(options.configDir ?? forgerelayConfigDir(options.env));
+        this.filePath = join(this.configDir, AUTH_FILE_NAME);
+    }
+    read(identity) {
+        const record = this.readFile().credentials[credentialKey(identity)];
+        if (!record || !sameIdentity(record.identity, identity))
+            return undefined;
+        return cloneRecord(record);
+    }
+    inspect() {
+        const exists = existsSync(this.filePath);
+        const file = this.readFile();
+        return { exists, credentialCount: Object.keys(file.credentials).length };
+    }
+    async replace(identity, serverUrl, record) {
+        let written;
+        await this.updateFile((file) => {
+            written = {
+                ...cloneRecord(record),
+                identity: normalizeIdentity(identity),
+                serverUrl,
+                revision: randomUUID(),
+                updatedAt: new Date().toISOString(),
+            };
+            file.credentials[credentialKey(identity)] = written;
+        });
+        return cloneRecord(written);
+    }
+    async update(identity, serverUrl, update) {
+        let written;
+        await this.updateFile((file) => {
+            const key = credentialKey(identity);
+            const existing = file.credentials[key];
+            const current = existing && sameIdentity(existing.identity, identity) ? cloneRecord(existing) : undefined;
+            const next = update(current);
+            if (!next) {
+                delete file.credentials[key];
+                written = undefined;
+                return;
+            }
+            written = {
+                ...cloneRecord(next),
+                identity: normalizeIdentity(identity),
+                serverUrl,
+                revision: randomUUID(),
+                updatedAt: new Date().toISOString(),
+            };
+            file.credentials[key] = written;
+        });
+        return written ? cloneRecord(written) : undefined;
+    }
+    async remove(identity) {
+        let removed = false;
+        await this.updateFile((file) => {
+            const key = credentialKey(identity);
+            const existing = file.credentials[key];
+            if (!existing || !sameIdentity(existing.identity, identity))
+                return;
+            delete file.credentials[key];
+            removed = true;
+        });
+        return removed;
+    }
+    withIdentityLock(identity, operation) {
+        mkdirSync(this.configDir, { recursive: true });
+        return withFileLock(join(this.configDir, `.mcp-auth-${credentialKeyHash(identity)}.lock`), operation, {
+            timeoutMs: 15_000,
+            staleMs: 60_000,
+            mode: 0o600,
+        });
+    }
+    readFile() {
+        if (!existsSync(this.filePath))
+            return emptyAuthFile();
+        let raw;
+        try {
+            raw = JSON.parse(readFileSync(this.filePath, "utf8"));
+        }
+        catch {
+            throw new Error(`Unable to read External MCP credential store ${this.filePath}: invalid JSON.`);
+        }
+        return parseAuthFile(raw, this.filePath);
+    }
+    async updateFile(update) {
+        mkdirSync(this.configDir, { recursive: true });
+        await withFileLock(`${this.filePath}.lock`, () => {
+            const file = this.readFile();
+            update(file);
+            writePrivateJsonFile(this.filePath, file);
+        }, { mode: 0o600 });
+    }
+}
+export function externalMcpCredentialIdentity(source, server, projectRoot) {
+    return source === "project"
+        ? { kind: "project", server, projectRoot: resolve(projectRoot) }
+        : { kind: "global", server };
+}
+export function credentialKey(identity) {
+    const normalized = normalizeIdentity(identity);
+    return normalized.kind === "global"
+        ? `global:${normalized.server}`
+        : `project:${credentialKeyHash(normalized)}:${normalized.server}`;
+}
+function credentialKeyHash(identity) {
+    const normalized = normalizeIdentity(identity);
+    const material = normalized.kind === "global"
+        ? `global\0${normalized.server}`
+        : `project\0${normalized.projectRoot}\0${normalized.server}`;
+    return createHash("sha256").update(material).digest("hex");
+}
+function normalizeIdentity(identity) {
+    return identity.kind === "project"
+        ? { kind: "project", server: identity.server, projectRoot: resolve(identity.projectRoot) }
+        : { kind: "global", server: identity.server };
+}
+function sameIdentity(left, right) {
+    const a = normalizeIdentity(left);
+    const b = normalizeIdentity(right);
+    return a.kind === b.kind
+        && a.server === b.server
+        && (a.kind === "global" || (b.kind === "project" && a.projectRoot === b.projectRoot));
+}
+function emptyAuthFile() {
+    return { version: AUTH_FILE_VERSION, credentials: {} };
+}
+function parseAuthFile(value, filePath) {
+    if (!isRecord(value) || value.version !== AUTH_FILE_VERSION || !isRecord(value.credentials)) {
+        throw new Error(`Unable to read External MCP credential store ${filePath}: unsupported format.`);
+    }
+    const credentials = {};
+    for (const [key, raw] of Object.entries(value.credentials)) {
+        credentials[key] = parseCredentialRecord(raw, filePath);
+    }
+    return { version: AUTH_FILE_VERSION, credentials };
+}
+function parseCredentialRecord(value, filePath) {
+    if (!isRecord(value) || !isCredentialIdentity(value.identity)) {
+        throw new Error(`Unable to read External MCP credential store ${filePath}: invalid credential identity.`);
+    }
+    if (typeof value.serverUrl !== "string"
+        || typeof value.revision !== "string"
+        || typeof value.updatedAt !== "string") {
+        throw new Error(`Unable to read External MCP credential store ${filePath}: invalid credential metadata.`);
+    }
+    if (value.tokens !== undefined
+        && (!isRecord(value.tokens) || typeof value.tokens.access_token !== "string")) {
+        throw new Error(`Unable to read External MCP credential store ${filePath}: invalid token record.`);
+    }
+    if (value.clientInformation !== undefined
+        && (!isRecord(value.clientInformation) || typeof value.clientInformation.client_id !== "string")) {
+        throw new Error(`Unable to read External MCP credential store ${filePath}: invalid client record.`);
+    }
+    if (value.discoveryState !== undefined
+        && (!isRecord(value.discoveryState) || typeof value.discoveryState.authorizationServerUrl !== "string")) {
+        throw new Error(`Unable to read External MCP credential store ${filePath}: invalid discovery record.`);
+    }
+    const reauthorization = parseReauthorization(value.reauthorization, filePath);
+    return {
+        identity: normalizeIdentity(value.identity),
+        serverUrl: value.serverUrl,
+        revision: value.revision,
+        updatedAt: value.updatedAt,
+        ...(value.tokens ? { tokens: structuredClone(value.tokens) } : {}),
+        ...(value.clientInformation
+            ? { clientInformation: structuredClone(value.clientInformation) }
+            : {}),
+        ...(value.discoveryState
+            ? { discoveryState: structuredClone(value.discoveryState) }
+            : {}),
+        ...(typeof value.authorizationServerUrl === "string"
+            ? { authorizationServerUrl: value.authorizationServerUrl }
+            : {}),
+        ...(typeof value.resourceUrl === "string" ? { resourceUrl: value.resourceUrl } : {}),
+        ...(reauthorization ? { reauthorization } : {}),
+    };
+}
+function parseReauthorization(value, filePath) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value)
+        || !["authorization_required", "invalid_grant", "insufficient_scope", "binding_changed"].includes(String(value.reason))
+        || typeof value.observedAt !== "string"
+        || (value.scope !== undefined && typeof value.scope !== "string")) {
+        throw new Error(`Unable to read External MCP credential store ${filePath}: invalid reauthorization state.`);
+    }
+    return {
+        reason: value.reason,
+        observedAt: value.observedAt,
+        ...(typeof value.scope === "string" && value.scope.trim() ? { scope: value.scope.trim() } : {}),
+    };
+}
+function isCredentialIdentity(value) {
+    if (!isRecord(value) || typeof value.server !== "string" || !value.server)
+        return false;
+    if (value.kind === "global")
+        return true;
+    return value.kind === "project" && typeof value.projectRoot === "string" && Boolean(value.projectRoot);
+}
+function cloneRecord(value) {
+    return structuredClone(value);
+}
+function writePrivateJsonFile(filePath, value) {
+    const temporary = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+        renameSync(temporary, filePath);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/runtime/config/external-mcp-config.js

@@ -0,0 +1,146 @@
+const MCP_SERVER_NAME_PATTERN = /^[a-z][a-z0-9._-]{0,63}$/;
+const MAX_MCP_SERVERS = 32;
+export function parseExternalMcpServers(value) {
+    return parseServerRegistry(value, "mcpServers", false);
+}
+export function parseExternalMcpStandaloneConfig(value) {
+    if (!isRecord(value))
+        throw new Error("External MCP configuration must be a JSON object.");
+    rejectUnknownKeys(value, new Set(["servers"]), "External MCP configuration");
+    if (!("servers" in value))
+        throw new Error("External MCP configuration must contain a servers object.");
+    return parseServerRegistry(value.servers, "servers", true);
+}
+function parseServerRegistry(value, label, allowDisabled) {
+    if (value === undefined && !allowDisabled)
+        return {};
+    if (!isRecord(value))
+        throw new Error(`${label} must be an object keyed by server name.`);
+    const entries = Object.entries(value);
+    if (entries.length > MAX_MCP_SERVERS) {
+        throw new Error(`${label} may contain at most ${MAX_MCP_SERVERS} configured servers.`);
+    }
+    return Object.fromEntries(entries.map(([name, raw]) => {
+        if (!MCP_SERVER_NAME_PATTERN.test(name)) {
+            throw new Error(`Invalid ${label} name '${name}'. Use a lowercase stable name.`);
+        }
+        if (!isRecord(raw))
+            throw new Error(`${label}.${name} must be an object.`);
+        const disabled = allowDisabled && "disabled" in raw ? parseDisabled(raw.disabled, `${label}.${name}.disabled`) : false;
+        const serverValue = allowDisabled && "disabled" in raw
+            ? Object.fromEntries(Object.entries(raw).filter(([key]) => key !== "disabled"))
+            : raw;
+        if (disabled && Object.keys(serverValue).length === 0) {
+            return [name, { disabled: true }];
+        }
+        const server = serverValue.transport === "stdio"
+            ? parseStdio(name, serverValue, label)
+            : serverValue.transport === "streamable-http"
+                ? parseHttp(name, serverValue, label)
+                : undefined;
+        if (!server)
+            throw new Error(`${label}.${name}.transport must be 'stdio' or 'streamable-http'.`);
+        return [name, disabled ? { disabled: true } : server];
+    }));
+}
+function parseStdio(name, value, label) {
+    const command = requiredString(value.command, `${label}.${name}.command`);
+    const args = optionalStringArray(value.args, `${label}.${name}.args`);
+    const env = optionalStringRecord(value.env, `${label}.${name}.env`);
+    const cwd = optionalString(value.cwd, `${label}.${name}.cwd`);
+    rejectUnknownKeys(value, new Set(["transport", "command", "args", "env", "cwd"]), `${label}.${name}`);
+    return {
+        transport: "stdio",
+        command,
+        ...(args ? { args } : {}),
+        ...(env ? { env } : {}),
+        ...(cwd ? { cwd } : {}),
+    };
+}
+function parseHttp(name, value, label) {
+    const url = requiredString(value.url, `${label}.${name}.url`);
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`${label}.${name}.url must be a valid HTTP(S) URL.`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`${label}.${name}.url must use http or https.`);
+    }
+    const headers = optionalStringRecord(value.headers, `${label}.${name}.headers`);
+    const oauth = parseOAuthClientConfig(value.oauth, `${label}.${name}.oauth`);
+    rejectUnknownKeys(value, new Set(["transport", "url", "headers", "oauth"]), `${label}.${name}`);
+    return {
+        transport: "streamable-http",
+        url: parsed.toString(),
+        ...(headers ? { headers } : {}),
+        ...(oauth ? { oauth } : {}),
+    };
+}
+function parseOAuthClientConfig(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value))
+        throw new Error(`${label} must be an object.`);
+    rejectUnknownKeys(value, new Set(["clientMetadataUrl", "callbackPort"]), label);
+    const clientMetadataUrl = requiredString(value.clientMetadataUrl, `${label}.clientMetadataUrl`);
+    let parsed;
+    try {
+        parsed = new URL(clientMetadataUrl);
+    }
+    catch {
+        throw new Error(`${label}.clientMetadataUrl must be a valid HTTPS URL.`);
+    }
+    if (parsed.protocol !== "https:" || parsed.pathname === "/") {
+        throw new Error(`${label}.clientMetadataUrl must use https and contain a non-root path.`);
+    }
+    const callbackPort = value.callbackPort;
+    if (!Number.isInteger(callbackPort) || Number(callbackPort) < 1024 || Number(callbackPort) > 65535) {
+        throw new Error(`${label}.callbackPort must be an integer from 1024 to 65535.`);
+    }
+    return {
+        clientMetadataUrl: parsed.toString(),
+        callbackPort: Number(callbackPort),
+    };
+}
+function parseDisabled(value, label) {
+    if (typeof value !== "boolean")
+        throw new Error(`${label} must be a boolean.`);
+    return value;
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${label} must be a non-empty string.`);
+    return value.trim();
+}
+function optionalString(value, label) {
+    if (value === undefined)
+        return undefined;
+    return requiredString(value, label);
+}
+function optionalStringArray(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new Error(`${label} must be an array of strings.`);
+    }
+    return [...value];
+}
+function optionalStringRecord(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value) || Object.values(value).some((entry) => typeof entry !== "string")) {
+        throw new Error(`${label} must be an object of string values.`);
+    }
+    return { ...value };
+}
+function rejectUnknownKeys(value, allowed, label) {
+    const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unknown.length > 0)
+        throw new Error(`${label} contains unsupported fields: ${unknown.join(", ")}.`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}