@akira-tl/forgerelay 1.0.1 → 1.1.1

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

@@ -0,0 +1,165 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { parseExternalMcpStandaloneConfig, } from "./external-mcp-config.js";
+const MISSING_FINGERPRINT = "missing";
+const MAX_DIAGNOSTIC_LENGTH = 320;
+export class ExternalMcpConfigRegistry {
+    configDir;
+    legacyServers;
+    onDiagnostic;
+    global;
+    projects = new Map();
+    constructor(options) {
+        this.configDir = resolve(options.configDir);
+        this.legacyServers = { ...(options.legacyServers ?? {}) };
+        this.onDiagnostic = options.onDiagnostic;
+    }
+    resolve(workspaceRoot) {
+        const projectRoot = resolve(workspaceRoot);
+        const global = this.loadGlobalSource();
+        const projectPath = join(projectRoot, ".forgerelay", "mcp.json");
+        const project = this.loadDynamicSource("project", projectPath, this.projects.get(projectRoot));
+        this.projects.set(projectRoot, project);
+        return this.composeSnapshot(global, project);
+    }
+    resolveGlobal() {
+        return this.composeSnapshot(this.loadGlobalSource());
+    }
+    loadGlobalSource() {
+        const globalPath = join(this.configDir, "mcp.json");
+        this.global = this.loadDynamicSource("global", globalPath, this.global);
+        return this.global;
+    }
+    composeSnapshot(global, project) {
+        const servers = { ...this.legacyServers };
+        const origins = Object.fromEntries(Object.keys(this.legacyServers).map((name) => [name, "legacy"]));
+        const masked = {};
+        applySource(servers, origins, masked, global.entries, "global");
+        if (project)
+            applySource(servers, origins, masked, project.entries, "project");
+        const diagnostics = [global.diagnostic, project?.diagnostic]
+            .filter((entry) => entry !== undefined);
+        return {
+            servers,
+            origins,
+            masked,
+            sources: [
+                {
+                    source: "legacy",
+                    path: join(this.configDir, "config.json"),
+                    state: "valid",
+                    usingLastKnownGood: false,
+                },
+                global.status,
+                ...(project ? [project.status] : []),
+            ],
+            diagnostics,
+        };
+    }
+    loadDynamicSource(source, path, previous) {
+        let content;
+        try {
+            content = readFileSync(path, "utf8");
+        }
+        catch (error) {
+            if (isMissingFileError(error)) {
+                if (previous?.observedFingerprint === MISSING_FINGERPRINT)
+                    return previous;
+                return {
+                    observedFingerprint: MISSING_FINGERPRINT,
+                    entries: {},
+                    hasLastKnownGood: true,
+                    status: {
+                        source,
+                        path,
+                        state: "missing",
+                        usingLastKnownGood: false,
+                    },
+                };
+            }
+            const fingerprint = `read-error:${errorCode(error)}`;
+            if (previous?.observedFingerprint === fingerprint)
+                return previous;
+            return this.invalidSource(source, path, fingerprint, previous, error);
+        }
+        const fingerprint = createHash("sha256").update(content).digest("base64url");
+        if (previous?.observedFingerprint === fingerprint)
+            return previous;
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            return this.invalidSource(source, path, fingerprint, previous, new Error("Invalid JSON syntax."));
+        }
+        try {
+            const entries = parseExternalMcpStandaloneConfig(parsed);
+            return {
+                observedFingerprint: fingerprint,
+                entries,
+                hasLastKnownGood: true,
+                status: {
+                    source,
+                    path,
+                    state: "valid",
+                    usingLastKnownGood: false,
+                },
+            };
+        }
+        catch (error) {
+            return this.invalidSource(source, path, fingerprint, previous, error);
+        }
+    }
+    invalidSource(source, path, observedFingerprint, previous, error) {
+        const diagnostic = {
+            source,
+            path,
+            message: boundedDiagnosticMessage(error),
+        };
+        this.onDiagnostic?.(diagnostic);
+        return {
+            observedFingerprint,
+            entries: previous?.entries ?? {},
+            hasLastKnownGood: previous?.hasLastKnownGood ?? false,
+            status: {
+                source,
+                path,
+                state: "invalid",
+                usingLastKnownGood: previous?.hasLastKnownGood === true,
+            },
+            diagnostic,
+        };
+    }
+}
+function applySource(servers, origins, masked, entries, source) {
+    for (const [name, entry] of Object.entries(entries)) {
+        if ("disabled" in entry && entry.disabled === true) {
+            delete servers[name];
+            delete origins[name];
+            masked[name] = source;
+            continue;
+        }
+        servers[name] = entry;
+        origins[name] = source;
+        delete masked[name];
+    }
+}
+function boundedDiagnosticMessage(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    const normalized = raw.replace(/\s+/g, " ").trim() || "Invalid External MCP configuration.";
+    return normalized.length <= MAX_DIAGNOSTIC_LENGTH
+        ? normalized
+        : `${normalized.slice(0, MAX_DIAGNOSTIC_LENGTH - 3)}...`;
+}
+function isMissingFileError(error) {
+    return errorCode(error) === "ENOENT";
+}
+function errorCode(error) {
+    if (typeof error === "object" && error !== null && "code" in error) {
+        const code = error.code;
+        if (typeof code === "string" && code)
+            return code;
+    }
+    return "UNKNOWN";
+}

package/dist/runtime/testing/server-fixture.js

@@ -4,8 +4,7 @@ import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
 import { ActivityAuditStore } from "../../activity/history/audit-store.js";
 import { BashOutputStore } from "../../activity/history/bash-output-store.js";
 import { HostTurnStore } from "../../activity/history/host-turn-store.js";
@@ -30,7 +29,12 @@ export async function fixture(t, options = {}) {
     const project = join(root, "project");
     const agentDir = join(root, "agent");
     const stateDir = join(root, ".state");
+    const configDir = join(root, ".config");
     await mkdir(join(project, ".forgerelay", "agents"), { recursive: true });
+    await mkdir(configDir, { recursive: true });
+    if (options.userConfig) {
+        await writeFile(join(configDir, "config.json"), JSON.stringify(options.userConfig, null, 2) + "\n");
+    }
     await mkdir(agentDir, { recursive: true });
     await writeFile(join(agentDir, "AGENTS.md"), "global instructions\n");
     await writeFile(join(project, "AGENTS.md"), "project instructions\n");
@@ -51,7 +55,7 @@ export async function fixture(t, options = {}) {
         await git(project, ["commit", "-m", "Initial commit"]);
     }
     const loadedConfig = loadConfig({
-        FORGERELAY_CONFIG_DIR: join(root, ".config"),
+        FORGERELAY_CONFIG_DIR: configDir,
         FORGERELAY_STATE_DIR: stateDir,
         FORGERELAY_ALLOWED_ROOTS: root,
         FORGERELAY_WORKTREE_ROOT: join(root, ".worktrees"),
@@ -143,8 +147,9 @@ export async function callOpen(client, path, conversationScopeId, mode, newWorkt
     return client.callTool(params);
 }
 export function structuredContent(result) {
-    assert.ok(result.structuredContent);
-    return result.structuredContent;
+    const structured = result.structuredContent;
+    assert.ok(structured);
+    return structured;
 }
 export function responseText(result) {
     const content = result.content;

package/dist/server.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 import { registerAppResource } from "@modelcontextprotocol/ext-apps/server";
 import { registerActivityQueryTools } from "./activity/runtime/mcp-query-tools.js";
 import { buildCapabilityFingerprint, loadCapabilityGuides } from "./mcp/server/core/capabilities.js";
@@ -15,12 +15,14 @@ import { HookRunner } from "./mcp/hooks/hooks.js";
 import { checkHookConfiguration } from "./mcp/hooks/hook-cli.js";
 import { buildExecutionShellContext, buildServerInstructions, buildToolDescriptions, toolNames } from "./mcp/server-instructions.js";
 import { IncomingArtifactAdapterRegistry } from "./mcp/artifacts/incoming-artifacts.js";
+import { createExternalMcpCapabilityRuntime } from "./mcp/operations/external-mcp/external-mcp-runtime.js";
 import { registerProcessTools } from "./mcp/process/tools.js";
 import { attachCompletedProcessNotices, recordBashCompletion } from "./mcp/process/runtime.js";
 import { CompositeActivityCoordinator } from "./workspaces/composite/composite-activity.js";
 import { CompositeWorkspaceRegistry } from "./workspaces/composite/composite-workspaces.js";
 import { RemoteWorkspaceRelay } from "./workspaces/relay/workspace-relay.js";
-import { hostConversationScopeId } from "./mcp/request-meta.js";
+import { hostContextDeliveryScopeId, hostConversationScopeId } from "./mcp/request-meta.js";
+import { mcpHandlerRequestContext } from "./mcp/request-context.js";
 import { createActivityPanelApp } from "./mcp/panel/app.js";
 import { shutdownHttpServer } from "./mcp/server/transport/server-shutdown.js";
 import { formatPathForPrompt } from "./workspaces/resources/skills.js";
@@ -46,7 +48,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const activityPanelApp = createActivityPanelApp(config, FORGERELAY_VERSION);
     const ownsRemoteWorkspaces = options.remoteWorkspaces === undefined;
     const remoteWorkspaces = options.remoteWorkspaces
-        ?? new RemoteWorkspaceRelay(config.configDir, config.stateDir);
+        ?? new RemoteWorkspaceRelay(config.configDir, config.stateDir, config.mediaMaxBytes);
     const compositeWorkspaces = options.compositeWorkspaces
         ?? new CompositeWorkspaceRegistry(config.stateDir);
     const workspaceTasks = new WorkspaceTaskStore(config.stateDir);
@@ -109,16 +111,20 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         const reminderWorkspaceId = taskReminderWorkspaceIdFor(target);
         return attachWorkspaceTaskReminder(presented, reminderWorkspaceId ? taskReminders.recordWork(reminderWorkspaceId) : undefined);
     };
-    const hostScopeIdFor = (requestMeta, transportSessionId) => hostConversationScopeId(requestMeta, transportSessionId, connectionScopeId);
-    const prepareExecutionContext = async (target, requestMeta, signal, sessionId) => {
-        const conversationScopeId = hostScopeIdFor(requestMeta, sessionId);
+    const hostScopeIdFor = (requestContext) => hostConversationScopeId(requestContext, connectionScopeId);
+    const contextDeliveryScopeIdFor = (requestContext) => hostContextDeliveryScopeId(requestContext, connectionScopeId);
+    const prepareExecutionContext = async (target, requestContext) => {
+        const conversationScopeId = hostScopeIdFor(requestContext);
         const turnId = target.compositeWorkspaceId && target.memberName
             ? await compositeActivity.prepareMember(target.compositeWorkspaceId, target.memberName, target.executionWorkspaceId, conversationScopeId)
             : undefined;
         return {
-            requestMeta,
-            signal,
-            sessionId,
+            requestMeta: requestContext.requestMeta,
+            signal: requestContext.signal,
+            sessionId: requestContext.transportSessionId,
+            requestId: requestContext.requestId,
+            protocolEra: requestContext.protocolEra,
+            conversationScopeId,
             ...(turnId ? { turnId } : {}),
             ...(target.memberName ? { activityMember: target.memberName } : {}),
         };
@@ -128,11 +134,13 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const incomingArtifactRegistry = new IncomingArtifactAdapterRegistry(incomingArtifactAdapters);
     const artifactDownloadAvailable = config.artifactsEnabled && isArtifactDownloadSupportedPlatform();
     const reviewChangesAvailable = config.widgets === "changes";
+    const externalMcpCapability = createExternalMcpCapabilityRuntime(config);
     let batchExecutor;
     const batchExecuteAvailable = config.toolMode !== "codex";
     const capabilityRegistry = createCapabilityRegistry({
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
         ...subagentMcp.registryDependencies,
+        externalMcp: externalMcpCapability,
         workspaceRecovery: {
             available: true,
             run: async (input, context) => ({
@@ -457,10 +465,11 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             ...compact,
         });
     };
-    registerAppResource(server, "ForgeRelay Activity Panel", activityPanelApp.uri, activityPanelApp.resourceMetadata, async (uri, extra) => activityPanelApp.readResource(uri.toString(), extra.sessionId));
+    registerAppResource(server, "ForgeRelay Activity Panel", activityPanelApp.uri, activityPanelApp.resourceMetadata, async (uri, extra) => activityPanelApp.readResource(uri.toString(), mcpHandlerRequestContext(extra).transportSessionId));
     registerOpenWorkspaceTool({
         server, config, workspaces, remoteWorkspaces, compositeWorkspaces, workspaceTasks, processSessions,
         capabilityRegistry, compositeTaskGuides, loadCompositeMemberContext, rememberWorkspacePanelState, hostScopeIdFor,
+        contextDeliveryScopeIdFor,
         presentation: {
             config, forgerelayVersion: FORGERELAY_VERSION, workspaces, workspaceTasks, reviewCheckpoints,
             capabilityRegistry, subagentProviders, hooks, rememberWorkspacePanelState,

package/dist/subagents/sessions/mcp/audit.js

@@ -1,4 +1,19 @@
 export function capabilityActivityAuditRequest(input) {
+    if (input.name === "mcp.external") {
+        const argumentsValue = isAuditRecord(input.arguments) ? input.arguments : {};
+        const callArguments = isAuditRecord(argumentsValue.arguments) ? argumentsValue.arguments : undefined;
+        return {
+            workspaceId: input.workspaceId,
+            name: input.name,
+            action: "run",
+            arguments: {
+                operation: argumentsValue.operation,
+                ...(typeof argumentsValue.server === "string" ? { server: argumentsValue.server } : {}),
+                ...(typeof argumentsValue.tool === "string" ? { tool: argumentsValue.tool } : {}),
+                ...(callArguments ? { argumentKeys: Object.keys(callArguments).sort() } : {}),
+            },
+        };
+    }
     if (input.name !== "subagent.session") {
         return {
             workspaceId: input.workspaceId,
@@ -24,6 +39,23 @@ export function capabilityActivityAuditRequest(input) {
     };
 }
 export function capabilityActivityAuditResult(name, result) {
+    if (name === "mcp.external" && isAuditRecord(result)) {
+        const structuredContent = isAuditRecord(result.structuredContent) ? result.structuredContent : undefined;
+        const capabilityResult = structuredContent && isAuditRecord(structuredContent.result)
+            ? structuredContent.result
+            : undefined;
+        const error = structuredContent && isAuditRecord(structuredContent.error)
+            ? structuredContent.error
+            : undefined;
+        return {
+            name,
+            action: "run",
+            ...(capabilityResult ? { result: summarizeExternalMcpCapabilityResult(capabilityResult) } : {}),
+            ...(error
+                ? { error: { code: error.code } }
+                : {}),
+        };
+    }
     if (name !== "subagent.session" || !isAuditRecord(result))
         return result;
     const structuredContent = isAuditRecord(result.structuredContent) ? result.structuredContent : undefined;
@@ -50,6 +82,55 @@ export function capabilityActivityAuditResult(name, result) {
 function isAuditRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function summarizeExternalMcpCapabilityResult(result) {
+    const summary = {
+        operation: result.operation,
+        ...(typeof result.server === "string" ? { server: result.server } : {}),
+        ...(typeof result.tool === "string" ? { tool: result.tool } : {}),
+    };
+    if (Array.isArray(result.servers)) {
+        summary.servers = result.servers.flatMap((entry) => {
+            if (!isAuditRecord(entry) || typeof entry.name !== "string")
+                return [];
+            return [{ name: entry.name, transport: entry.transport }];
+        });
+    }
+    if (Array.isArray(result.tools)) {
+        summary.tools = result.tools.flatMap((entry) => isAuditRecord(entry) && typeof entry.name === "string" ? [entry.name] : []);
+    }
+    if (Array.isArray(result.content)) {
+        summary.contentTypes = result.content.flatMap((entry) => isAuditRecord(entry) && typeof entry.type === "string" ? [entry.type] : []);
+        const media = result.content.flatMap((entry, index) => {
+            if (!isAuditRecord(entry)
+                || entry.type !== "image"
+                || typeof entry.mimeType !== "string"
+                || typeof entry.bytes !== "number")
+                return [];
+            return [{ index, mimeType: entry.mimeType, bytes: entry.bytes }];
+        });
+        if (media.length > 0)
+            summary.media = media;
+    }
+    if (Array.isArray(result.transforms)) {
+        const transforms = result.transforms.flatMap((entry) => {
+            if (!isAuditRecord(entry)
+                || (entry.phase !== "request" && entry.phase !== "result")
+                || typeof entry.name !== "string"
+                || (entry.scope !== "global" && entry.scope !== "project")
+                || entry.status !== "passed")
+                return [];
+            return [{
+                    phase: entry.phase,
+                    name: entry.name.slice(0, 200),
+                    scope: entry.scope,
+                    status: "passed",
+                }];
+        });
+        if (transforms.length > 0)
+            summary.transforms = transforms;
+    }
+    return summary;
+}
 function summarizeSubagentCapabilityResult(result) {
     const summary = { operation: result.operation };
     const session = isAuditRecord(result.session) ? result.session : undefined;