@akira-tl/forgerelay 1.0.1 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -39,6 +39,8 @@
     "dev": "node scripts/debug/serve.mjs",
     "debug:serve": "node scripts/debug/serve.mjs",
     "debug:accept": "node scripts/debug/accept.mjs",
+    "debug:accept:media": "node scripts/debug/accept/media.mjs",
+    "debug:accept:modern": "node scripts/debug/accept/modern-http.mjs",
     "debug:accept:relay": "node scripts/debug/relay-accept.mjs",
     "traffic:audit": "node --import tsx scripts/debug/traffic/traffic-audit.mjs",
     "lsp:interop": "node scripts/lsp/interop.mjs",
@@ -56,7 +58,7 @@
     "release:push-ready": "node scripts/release/push-ready.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "node --test scripts/debug/runtime.test.mjs scripts/release-proof.test.mjs scripts/release/release-gate.test.mjs scripts/release/push-ready.test.mjs scripts/release/release-version.test.mjs && tsx src/mcp/oauth/router.test.ts && tsx src/workspaces/relay/auth/remote-auth-cli.test.ts && tsx src/workspaces/relay/auth/remote-ssh-auth-cli.test.ts && tsx src/workspaces/relay/tests/lifecycle.test.ts && tsx src/workspaces/relay/tests/routing.test.ts && tsx src/workspaces/relay/tests/ssh.test.ts && tsx src/workspaces/relay/tests/process.test.ts && tsx src/workspaces/relay/tests/recovery.test.ts && tsx src/workspaces/relay/tests/checkpoint.test.ts && tsx src/runtime/config/config.test.ts && tsx src/runtime/shell/command-shell-runtime.test.ts && tsx src/runtime/instructions/shell-instructions.test.ts && tsx src/runtime/instructions/powershell-skill.test.ts && tsx src/cli/shell/setup.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/runtime/managed-language-servers.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/runtime/logging/logger.test.ts && tsx src/runtime/logging/proxy-trust.test.ts && tsx src/runtime/state/lock/file-lock.test.ts && tsx src/runtime/state/runtime-lease.test.ts && tsx src/mcp/panel/mcp-app-template.test.ts && tsx src/mcp/hooks/hooks.test.ts && tsx src/mcp/server/core/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/mcp/request-meta.test.ts && tsx src/mcp/artifacts/incoming-artifacts.test.ts && tsx src/mcp/artifacts/artifact-download.test.ts && tsx src/ui/core/card-types.test.ts && tsx src/ui/activity/model.test.ts && tsx src/ui/activity/detail-card.test.ts && tsx src/ui/review/patch-display.test.ts && tsx src/ui/core/tool-display.test.ts && tsx src/mcp/filesystem/apply-patch.test.ts && tsx src/mcp/process/process-platform.test.ts && tsx src/mcp/process/process-sessions.test.ts && tsx src/mcp/server/transport/mcp-sessions.test.ts && tsx src/mcp/server/transport/server-shutdown.test.ts && tsx src/mcp/server/operations/mutation-diagnostics.test.ts && tsx src/mcp/server/operations/hooks.test.ts && tsx src/subagents/providers/adapters/codex.test.ts && tsx src/subagents/providers/adapters/pi.test.ts && tsx src/subagents/providers/registry.test.ts && tsx src/subagents/providers/availability.test.ts && tsx src/subagents/profiles.test.ts && tsx src/subagents/cli-target.test.ts && tsx src/subagents/sessions/store.test.ts && tsx src/subagents/sessions/manager.test.ts && tsx src/subagents/sessions/mcp/capability.server.test.ts && tsx src/subagents/sessions/mcp/continuation.server.test.ts && tsx src/subagents/sessions/mcp/lifecycle.server.test.ts && tsx src/subagents/sessions/mcp/reconciliation.server.test.ts && tsx src/subagents/sessions/mcp/routing.server.test.ts && tsx src/mcp/filesystem/roots.test.ts && tsx src/mcp/filesystem/file-mutations.test.ts && tsx src/mcp/operations/edit-preflight.test.ts && tsx src/workspaces/resources/skills.test.ts && tsx src/runtime/state/db/migrations.test.ts && tsx src/workspaces/state/workspace-store.test.ts && tsx src/workspaces/tasks/workspace-tasks.test.ts && tsx src/workspaces/tasks/workspace-task-reminders.test.ts && tsx src/activity/history/audit-store.test.ts && tsx src/activity/history/bash-output-store.test.ts && tsx src/activity/runtime/lifecycle.test.ts && tsx src/activity/history/query-service.test.ts && tsx src/mcp/operations/core-operation-executor.test.ts && tsx src/mcp/operations/bulk-mutation.test.ts && tsx src/mcp/operations/batch/scheduler.test.ts && tsx src/mcp/operations/batch/executor-policy.test.ts && tsx src/workspaces.test.ts && tsx src/workspaces/conversation-checkout.test.ts && tsx src/workspaces/conversation-worktree.test.ts && tsx src/workspaces/git/worktree-recovery.test.ts && tsx src/mcp/server/workspace/workspace-inventory.test.ts && tsx src/mcp/server/workspace/workspace-recovery.test.ts && tsx src/mcp/server/workspace/workspace-checkpoint.test.ts && tsx src/workspaces/review/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && npm run build:app && tsx src/mcp/process/server.test.ts && tsx src/mcp/panel/server.test.ts && tsx src/mcp/server/server.test.ts && tsx src/mcp/oauth/oauth-store.test.ts && tsx src/cli/maintenance.test.ts && tsx src/cli/maintenance-prune.test.ts && tsx src/cli/cli.test.ts",
+    "test": "node --test scripts/debug/runtime.test.mjs scripts/release-proof.test.mjs scripts/release/release-gate.test.mjs scripts/release/push-ready.test.mjs scripts/release/release-version.test.mjs && tsx src/mcp/oauth/router.test.ts && tsx src/workspaces/relay/auth/remote-auth-cli.test.ts && tsx src/workspaces/relay/auth/remote-ssh-auth-cli.test.ts && tsx src/workspaces/relay/tests/lifecycle.test.ts && tsx src/workspaces/relay/tests/routing.test.ts && tsx src/workspaces/relay/tests/ssh.test.ts && tsx src/workspaces/relay/tests/process.test.ts && tsx src/workspaces/relay/tests/recovery.test.ts && tsx src/workspaces/relay/tests/checkpoint.test.ts && tsx src/runtime/config/config.test.ts && tsx src/runtime/config/external-mcp-registry.test.ts && tsx src/runtime/config/external-mcp-auth-store.test.ts && tsx src/mcp/operations/external-mcp/external-mcp-oauth.test.ts && tsx src/cli/mcp/status.test.ts && tsx src/cli/mcp/diagnostics.test.ts && tsx src/cli/mcp/external-mcp.test.ts && tsx src/runtime/shell/command-shell-runtime.test.ts && tsx src/runtime/instructions/shell-instructions.test.ts && tsx src/runtime/instructions/powershell-skill.test.ts && tsx src/cli/shell/setup.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/runtime/managed-language-servers.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/runtime/logging/logger.test.ts && tsx src/runtime/logging/proxy-trust.test.ts && tsx src/runtime/state/lock/file-lock.test.ts && tsx src/runtime/state/runtime-lease.test.ts && tsx src/mcp/panel/mcp-app-template.test.ts && tsx src/mcp/hooks/hooks.test.ts && tsx src/mcp/server/core/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/mcp/request-context.test.ts && tsx src/mcp/request-meta.test.ts && tsx src/mcp/artifacts/incoming-artifacts.test.ts && tsx src/mcp/artifacts/artifact-download.test.ts && tsx src/ui/core/card-types.test.ts && tsx src/ui/activity/model.test.ts && tsx src/ui/activity/detail-card.test.ts && tsx src/ui/review/patch-display.test.ts && tsx src/ui/core/tool-display.test.ts && tsx src/mcp/filesystem/apply-patch.test.ts && tsx src/mcp/process/process-platform.test.ts && tsx src/mcp/process/process-sessions.test.ts && tsx src/mcp/server/transport/mcp-sessions.test.ts && tsx src/mcp/server/transport/server-shutdown.test.ts && tsx src/mcp/server/operations/mutation-diagnostics.test.ts && tsx src/mcp/server/operations/hooks.test.ts && tsx src/subagents/providers/adapters/codex.test.ts && tsx src/subagents/providers/adapters/pi.test.ts && tsx src/subagents/providers/registry.test.ts && tsx src/subagents/providers/availability.test.ts && tsx src/subagents/profiles.test.ts && tsx src/subagents/cli-target.test.ts && tsx src/subagents/sessions/store.test.ts && tsx src/subagents/sessions/manager.test.ts && tsx src/subagents/sessions/mcp/capability.server.test.ts && tsx src/subagents/sessions/mcp/continuation.server.test.ts && tsx src/subagents/sessions/mcp/lifecycle.server.test.ts && tsx src/subagents/sessions/mcp/reconciliation.server.test.ts && tsx src/subagents/sessions/mcp/routing.server.test.ts && tsx src/mcp/filesystem/roots.test.ts && tsx src/mcp/filesystem/file-mutations.test.ts && tsx src/mcp/operations/edit-preflight.test.ts && tsx src/workspaces/resources/skills.test.ts && tsx src/runtime/state/db/migrations.test.ts && tsx src/workspaces/state/workspace-store.test.ts && tsx src/workspaces/tasks/workspace-tasks.test.ts && tsx src/workspaces/tasks/workspace-task-reminders.test.ts && tsx src/activity/history/audit-store.test.ts && tsx src/activity/history/bash-output-store.test.ts && tsx src/activity/runtime/lifecycle.test.ts && tsx src/activity/history/query-service.test.ts && tsx src/mcp/operations/core-operation-executor.test.ts && tsx src/mcp/operations/bulk-mutation.test.ts && tsx src/mcp/operations/batch/scheduler.test.ts && tsx src/mcp/operations/batch/executor-policy.test.ts && tsx src/workspaces.test.ts && tsx src/workspaces/conversation-checkout.test.ts && tsx src/workspaces/conversation-worktree.test.ts && tsx src/workspaces/git/worktree-recovery.test.ts && tsx src/mcp/server/workspace/workspace-inventory.test.ts && tsx src/mcp/server/workspace/workspace-recovery.test.ts && tsx src/mcp/server/workspace/workspace-checkpoint.test.ts && tsx src/workspaces/review/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && npm run build:app && tsx src/mcp/process/server.test.ts && tsx src/mcp/panel/server.test.ts && tsx src/mcp/server/server.test.ts && tsx src/mcp/oauth/oauth-store.test.ts && tsx src/cli/maintenance.test.ts && tsx src/cli/maintenance-prune.test.ts && tsx src/cli/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",
@@ -79,13 +81,18 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.1.0",
     "@clack/prompts": "^1.5.1",
-    "@modelcontextprotocol/ext-apps": "^1.7.2",
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/client": "^2.0.0",
+    "@modelcontextprotocol/core": "^2.0.0",
+    "@modelcontextprotocol/express": "^2.0.0",
+    "@modelcontextprotocol/ext-apps": "^2.0.0",
+    "@modelcontextprotocol/node": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
     "@pierre/diffs": "^1.2.5",
     "better-sqlite3": "^13.0.3",
     "diff": "^8.0.3",
     "drizzle-orm": "^0.45.2",
     "express": "^5.2.1",
+    "express-rate-limit": "8.5.2",
     "lucide": "^1.24.0",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
@@ -96,6 +103,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
     "@types/node": "^25.9.1",

package/scripts/debug/accept/bootstrap.mjs

@@ -192,7 +192,10 @@ export async function runBootstrapAcceptance({ server, packageJson, ownerToken,
       "capability-guides.read",
       "code.intelligence",
       "workspace.tasks",
+      "workspace.recovery",
+      "workspace.checkpoint",
       "batch.execute",
+      "mcp.external",
       ...(process.platform === "linux" ? ["artifact.native-download"] : []),
       "ui.mcp-app",
       "review.changes",
@@ -203,7 +206,9 @@ export async function runBootstrapAcceptance({ server, packageJson, ownerToken,
     "hooks.check",
     "review.changes",
     "code.intelligence",
+    "workspace.checkpoint",
     "workspace.tasks",
+    "mcp.external",
     "batch.execute",
     ...(process.platform === "linux" ? ["artifact.download"] : []),
   ]);

package/scripts/debug/accept/harness.mjs

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import {
   createDebugEnvironment,
+  debugConfigDir,
   debugRoot,
   repoRoot,
 } from "../runtime.mjs";
@@ -19,6 +20,7 @@ import { assertCurlAvailable, assertDebugPortFree, pass, setupGitProject } from
 export async function createAcceptanceHarness() {
   const packageJson = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8"));
   const acceptanceRoot = resolve(debugRoot, "acceptance");
+  const configDir = resolve(acceptanceRoot, "config");
   const stateDir = resolve(acceptanceRoot, "state");
   const worktreeRoot = resolve(acceptanceRoot, "worktrees");
   const hookLog = resolve(acceptanceRoot, "hooks.jsonl");
@@ -35,7 +37,11 @@ export async function createAcceptanceHarness() {
   assertCurlAvailable();
   await assertDebugPortFree();
   rmSync(acceptanceRoot, { recursive: true, force: true });
-  mkdirSync(acceptanceRoot, { recursive: true });
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(
+    join(configDir, "config.json"),
+    readFileSync(join(debugConfigDir, "config.json"), "utf8"),
+  );
   setupGitProject(checkoutWorkspace);
   setupGitProject(lifecycleDeleteWorkspace);
   writeFileSync(join(lifecycleDeleteWorkspace, "keep.txt"), "keep checkout files\n");
@@ -44,6 +50,7 @@ export async function createAcceptanceHarness() {
 
   const { env } = createDebugEnvironment({
     ownerToken,
+    configDir,
     stateDir,
     worktreeRoot,
     hookLog,
@@ -56,7 +63,7 @@ export async function createAcceptanceHarness() {
     encoding: "utf8",
   });
   assert.equal(doctor.status, 0, doctor.stderr);
-  assert.match(doctor.stdout, /Public base URL: http:\/\/127\.0\.0\.1:7677/);
+  assert.match(doctor.stdout, /Client-facing base URL: http:\/\/127\.0\.0\.1:7677/);
   assert.match(doctor.stdout, /Tool mode: full/);
   assert.match(doctor.stdout, /Widgets: changes/);
   assert.match(doctor.stdout, /Trust proxy: off/);
@@ -69,7 +76,7 @@ export async function createAcceptanceHarness() {
   });
 
   return {
-    packageJson, acceptanceRoot, stateDir, worktreeRoot, hookLog, checkoutWorkspace,
+    packageJson, acceptanceRoot, configDir, stateDir, worktreeRoot, hookLog, checkoutWorkspace,
     lifecycleDeleteWorkspace, codeIntelligenceLog, fakeLanguageServer, gitProject, releaseProject,
     releaseRemote, ownerToken, tempAcceptanceRoot, env, server,
   };

package/scripts/debug/accept/media.mjs

@@ -0,0 +1,335 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { randomBytes, randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { deflateSync } from "node:zlib";
+import { debugBaseUrl, debugMcpUrl, debugRoot, repoRoot } from "../runtime.mjs";
+import {
+  assertDebugPortFree,
+  authorizeDebugClient,
+  callTool,
+  curlRequest,
+  initializeRequest,
+  jsonRequest,
+  mcpHeaders,
+  mcpRequest,
+  pass,
+  stopServer,
+  toolText,
+  waitForHealth,
+} from "./support.mjs";
+
+const acceptanceRoot = resolve(debugRoot, "media-acceptance");
+const configDir = join(acceptanceRoot, "config");
+const stateDir = join(acceptanceRoot, "state");
+const workspaceRoot = join(acceptanceRoot, "workspace");
+const outsideRoot = resolve(tmpdir(), `forgerelay-media-outside-${randomUUID()}`);
+const ownerToken = randomBytes(32).toString("base64url");
+const credentialSentinel = "MEDIA_ACCEPTANCE_EXTERNAL_MCP_CREDENTIAL_SECRET";
+const directImageBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Y9ZcXcAAAAASUVORK5CYII=";
+const externalFixture = fileURLToPath(
+  new URL("../../../src/mcp/operations/external-mcp/test-fixtures/external-mcp-server.mjs", import.meta.url),
+);
+const transformScriptPath = join(workspaceRoot, ".forgerelay", "path-image-transform.mjs");
+const transformHookPath = join(workspaceRoot, ".forgerelay", "hooks", "20-render-path-image.json");
+
+await assertDebugPortFree();
+rmSync(acceptanceRoot, { recursive: true, force: true });
+rmSync(outsideRoot, { recursive: true, force: true });
+mkdirSync(configDir, { recursive: true });
+mkdirSync(stateDir, { recursive: true });
+mkdirSync(join(workspaceRoot, "renders"), { recursive: true });
+mkdirSync(join(workspaceRoot, ".forgerelay", "hooks"), { recursive: true });
+mkdirSync(outsideRoot, { recursive: true });
+
+const visualSentinel = createVisualSentinelPng();
+const visualSentinelBase64 = visualSentinel.toString("base64");
+writeFileSync(join(workspaceRoot, "visual-sentinel.png"), visualSentinel);
+writeFileSync(join(workspaceRoot, "renders", "output.png"), visualSentinel);
+writeFileSync(join(outsideRoot, "outside.txt"), "outside allowed root\n");
+writeFileSync(join(workspaceRoot, "README.md"), "media acceptance workspace\n");
+
+const mediaMaxBytes = visualSentinel.byteLength + Math.max(32, Math.floor(visualSentinel.byteLength / 2));
+assert.ok(mediaMaxBytes >= visualSentinel.byteLength);
+assert.ok(mediaMaxBytes < visualSentinel.byteLength * 2);
+
+writeFileSync(join(configDir, "config.json"), `${JSON.stringify({
+  host: "127.0.0.1",
+  port: 7677,
+  allowedRoots: [workspaceRoot],
+  publicBaseUrl: debugBaseUrl,
+  allowedHosts: ["localhost", "127.0.0.1", "::1"],
+  stateDir,
+  worktreeRoot: join(acceptanceRoot, "worktrees"),
+  mediaMaxBytes,
+  mcpServers: {
+    blender: {
+      transport: "stdio",
+      command: process.execPath,
+      args: [externalFixture],
+      env: { FORGERELAY_MEDIA_ACCEPTANCE_SECRET: credentialSentinel },
+    },
+  },
+}, null, 2)}\n`);
+writeFileSync(join(configDir, "auth.json"), `${JSON.stringify({
+  ownerToken,
+  instanceId: "media-acceptance-7677",
+}, null, 2)}\n`, { mode: 0o600 });
+
+const cleanEnv = Object.fromEntries(
+  Object.entries(process.env).filter(([name]) =>
+    name !== "HOST" && name !== "PORT" && !name.startsWith("FORGERELAY_")
+  ),
+);
+const env = {
+  ...cleanEnv,
+  HOST: "127.0.0.1",
+  PORT: "7677",
+  FORGERELAY_CONFIG_DIR: configDir,
+  FORGERELAY_OAUTH_OWNER_TOKEN: ownerToken,
+  FORGERELAY_PUBLIC_BASE_URL: debugBaseUrl,
+  FORGERELAY_TOOL_MODE: "full",
+  FORGERELAY_WIDGETS: "off",
+  FORGERELAY_LOG_LEVEL: "info",
+  FORGERELAY_LOG_FORMAT: "json",
+};
+
+let serverLogs = "";
+const server = spawn(process.execPath, ["--import", "tsx", "src/cli.ts", "serve"], {
+  cwd: repoRoot,
+  env,
+  stdio: ["ignore", "pipe", "pipe"],
+});
+server.stdout?.on("data", (chunk) => { serverLogs += chunk.toString(); });
+server.stderr?.on("data", (chunk) => { serverLogs += chunk.toString(); });
+
+let completed = false;
+try {
+  await waitForHealth(server);
+  pass("media acceptance health", debugBaseUrl);
+
+  const authorizationServer = jsonRequest(`${debugBaseUrl}/.well-known/oauth-authorization-server`);
+  assert.equal(authorizationServer.status, 200);
+  const oauth = authorizeDebugClient(authorizationServer.json, ownerToken);
+  const initialized = mcpRequest(oauth.accessToken, undefined, initializeRequest(1));
+  const sessionId = initialized.response.headers.get("mcp-session-id");
+  assert.ok(sessionId);
+  const initializedNotification = curlRequest({
+    method: "POST",
+    url: debugMcpUrl,
+    headers: mcpHeaders(oauth.accessToken, sessionId),
+    body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }),
+  });
+  assert.equal(initializedNotification.status, 202);
+  pass("media acceptance OAuth/MCP", "real HTTP MCP session initialized on 7677");
+
+  let requestId = 10;
+  const nextId = () => requestId++;
+  const conversation = { "openai/session": "media-acceptance-7677" };
+  const opened = callTool(oauth.accessToken, sessionId, nextId(), "open_workspace", {
+    path: workspaceRoot,
+    context: "none",
+  }, conversation);
+  assert.equal(opened.isError, undefined, toolText(opened));
+  const workspaceId = opened.structuredContent.workspaceId;
+  assert.match(workspaceId, /^ws_/);
+
+  const readImage = callTool(oauth.accessToken, sessionId, nextId(), "read", {
+    workspaceId,
+    path: "visual-sentinel.png",
+  }, conversation);
+  assert.equal(readImage.isError, undefined, toolText(readImage));
+  const readImageContent = readImage.content.find((entry) => entry.type === "image");
+  assert.ok(readImageContent);
+  assert.equal(readImageContent.mimeType, "image/png");
+  assert.equal(readImageContent.data, visualSentinelBase64);
+  assert.deepEqual(readImage.structuredContent.media, {
+    type: "image",
+    mimeType: "image/png",
+    bytes: visualSentinel.byteLength,
+  });
+  assert.equal(JSON.stringify(readImage.structuredContent).includes(visualSentinelBase64), false);
+  assert.equal(JSON.stringify(readImage._meta ?? {}).includes(visualSentinelBase64), false);
+  pass(
+    "real 7677 image Read",
+    `${visualSentinel.byteLength} PNG bytes reached the Host-facing MCP result unchanged`,
+  );
+
+  const outsideRead = callTool(oauth.accessToken, sessionId, nextId(), "read", {
+    path: join(outsideRoot, "outside.txt"),
+  }, conversation);
+  assert.equal(outsideRead.isError, true);
+  pass("real 7677 allowed-root containment", "unscoped Read outside the configured root was rejected");
+
+  const externalCall = (tool) => callTool(oauth.accessToken, sessionId, nextId(), "capability", {
+    workspaceId,
+    name: "mcp.external",
+    action: "run",
+    arguments: { operation: "call", server: "blender", tool },
+  }, conversation);
+
+  const directImage = externalCall("direct_image");
+  assert.equal(directImage.isError, undefined, toolText(directImage));
+  const externalImage = directImage.content.find((entry) => entry.type === "image");
+  assert.ok(externalImage);
+  assert.equal(externalImage.mimeType, "image/png");
+  assert.equal(externalImage.data, directImageBase64);
+  assert.equal(JSON.stringify(directImage.structuredContent).includes(directImageBase64), false);
+  pass("real 7677 external MCP ImageContent", "published mcp.external Capability forwarded direct image content");
+
+  const pathOnly = externalCall("path_only");
+  assert.equal(pathOnly.isError, undefined, toolText(pathOnly));
+  assert.equal(pathOnly.content.some((entry) => entry.type === "image"), false);
+  assert.equal(toolText(pathOnly), "renders/output.png");
+  pass("external MCP default reference pass-through", "path-only result stayed path-only without a transform Hook");
+
+  installPathTransform({ duplicate: false });
+  const transformed = externalCall("path_only");
+  assert.equal(transformed.isError, undefined, toolText(transformed));
+  const transformedImage = transformed.content.find((entry) => entry.type === "image");
+  assert.ok(transformedImage);
+  assert.equal(transformedImage.mimeType, "image/png");
+  assert.equal(transformedImage.data, visualSentinelBase64);
+  assert.equal(JSON.stringify(transformed.structuredContent).includes(visualSentinelBase64), false);
+  pass("external MCP explicit transform", "the same path-only result became ImageContent only after the matching Hook was installed");
+
+  installPathTransform({ duplicate: true });
+  const transformedOversize = externalCall("path_only");
+  assert.equal(transformedOversize.isError, true);
+  assert.match(toolText(transformedOversize), /mcp\.media_too_large/i);
+  assert.equal(transformedOversize.content.some((entry) => entry.type === "image"), false);
+  assert.equal(JSON.stringify(transformedOversize).includes(visualSentinelBase64), false);
+  pass("transformed media budget", "post-transform media was revalidated against the configured aggregate limit");
+
+  const malformed = externalCall("malformed_image");
+  assert.equal(malformed.isError, true);
+  assert.match(toolText(malformed), /mcp\.media_malformed/i);
+  const upstreamFailure = externalCall("fail");
+  assert.equal(upstreamFailure.isError, true);
+  assert.equal(JSON.stringify(upstreamFailure).includes(credentialSentinel), false);
+  pass("external MCP negative boundaries", "malformed media and upstream failure stayed bounded and credential-safe");
+
+  completed = true;
+} finally {
+  await stopServer(server).catch(() => undefined);
+  if (completed) {
+    assertDirectoryDoesNotContain(stateDir, visualSentinelBase64);
+    assertDirectoryDoesNotContain(stateDir, directImageBase64);
+    assert.equal(serverLogs.includes(visualSentinelBase64), false, "server logs persisted transformed/read image base64");
+    assert.equal(serverLogs.includes(directImageBase64), false, "server logs persisted external image base64");
+    assert.equal(serverLogs.includes(credentialSentinel), false, "server logs leaked external MCP credentials");
+    pass("media persistence boundary", "image base64 stayed out of ForgeRelay state and logs");
+  }
+  rmSync(outsideRoot, { recursive: true, force: true });
+}
+
+if (completed) {
+  console.log("Media acceptance passed.");
+}
+
+function installPathTransform({ duplicate }) {
+  writeFileSync(transformScriptPath, [
+    'import { readFileSync } from "node:fs";',
+    'import { resolve } from "node:path";',
+    'let input = "";',
+    'for await (const chunk of process.stdin) input += chunk;',
+    'const envelope = JSON.parse(input);',
+    'const path = envelope.result?.content?.find((entry) => entry.type === "text")?.text;',
+    'if (typeof path !== "string") throw new Error("expected path-only upstream result");',
+    'const data = readFileSync(resolve(process.cwd(), path)).toString("base64");',
+    `const images = Array.from({ length: ${duplicate ? 2 : 1} }, () => ({ type: "image", data, mimeType: "image/png" }));`,
+    'process.stdout.write(JSON.stringify({ version: 1, result: { content: images } }));',
+    '',
+  ].join("\n"));
+  writeFileSync(transformHookPath, `${JSON.stringify({
+    event: "ExternalMcpAfterForward",
+    matcher: {
+      capability: "mcp.external",
+      externalServer: "blender",
+      externalTool: "path_only",
+    },
+    command: 'node ".forgerelay/path-image-transform.mjs"',
+    timeoutSeconds: 10,
+    report: true,
+  }, null, 2)}\n`);
+}
+
+function assertDirectoryDoesNotContain(root, needle) {
+  if (!existsSync(root)) return;
+  const target = Buffer.from(needle, "utf8");
+  const pending = [root];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const path = join(directory, entry.name);
+      if (entry.isDirectory()) pending.push(path);
+      else if (entry.isFile()) {
+        assert.equal(readFileSync(path).includes(target), false, `ForgeRelay persisted media base64 in ${path}`);
+      }
+    }
+  }
+}
+
+function createVisualSentinelPng() {
+  const width = 180;
+  const height = 100;
+  const stride = (width * 4) + 1;
+  const raw = Buffer.alloc(stride * height);
+  for (let y = 0; y < height; y += 1) {
+    const row = y * stride;
+    raw[row] = 0;
+    for (let x = 0; x < width; x += 1) {
+      const offset = row + 1 + (x * 4);
+      let pixel = [246, 246, 246, 255];
+      if (x >= 14 && x < 64 && y >= 20 && y < 80) pixel = [220, 36, 48, 255];
+      if (x >= 116 && x < 166 && y >= 20 && y < 80) pixel = [36, 86, 220, 255];
+      if (x >= 84 && x < 96 && y >= 10 && y < 90) pixel = [18, 18, 18, 255];
+      raw[offset] = pixel[0];
+      raw[offset + 1] = pixel[1];
+      raw[offset + 2] = pixel[2];
+      raw[offset + 3] = pixel[3];
+    }
+  }
+
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    pngChunk("IHDR", ihdr),
+    pngChunk("IDAT", deflateSync(raw, { level: 9 })),
+    pngChunk("IEND", Buffer.alloc(0)),
+  ]);
+}
+
+function pngChunk(type, data) {
+  const typeBuffer = Buffer.from(type, "ascii");
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length, 0);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([typeBuffer, data])), 0);
+  return Buffer.concat([length, typeBuffer, data, crc]);
+}
+
+function crc32(buffer) {
+  let crc = 0xffffffff;
+  for (const byte of buffer) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit += 1) {
+      crc = (crc >>> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
+    }
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}

package/scripts/debug/accept/modern-http.mjs

@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { debugRoot, repoRoot } from "../runtime.mjs";
+import { assertPortFree, pass, stopServer, waitForHealth } from "./support.mjs";
+
+const port = 7678;
+const baseUrl = `http://127.0.0.1:${port}`;
+const mcpUrl = `${baseUrl}/mcp`;
+const acceptanceRoot = resolve(debugRoot, "modern-http-acceptance");
+const configDir = join(acceptanceRoot, "config");
+const stateDir = join(acceptanceRoot, "state");
+const worktreeRoot = join(acceptanceRoot, "worktrees");
+const workspaceRoot = join(acceptanceRoot, "workspace");
+const ownerToken = randomBytes(32).toString("base64url");
+
+await assertPortFree(port);
+rmSync(acceptanceRoot, { recursive: true, force: true });
+mkdirSync(configDir, { recursive: true });
+mkdirSync(stateDir, { recursive: true });
+mkdirSync(workspaceRoot, { recursive: true });
+writeFileSync(join(workspaceRoot, "README.md"), "modern MCP acceptance workspace\n");
+writeFileSync(join(configDir, "config.json"), `${JSON.stringify({
+  host: "127.0.0.1",
+  port,
+  allowedRoots: [workspaceRoot],
+  publicBaseUrl: baseUrl,
+  allowedHosts: ["localhost", "127.0.0.1", "::1"],
+  stateDir,
+  worktreeRoot,
+}, null, 2)}\n`);
+writeFileSync(join(configDir, "auth.json"), `${JSON.stringify({
+  ownerToken,
+  instanceId: "modern-http-acceptance-7678",
+}, null, 2)}\n`, { mode: 0o600 });
+
+const cleanEnv = Object.fromEntries(
+  Object.entries(process.env).filter(([name]) =>
+    name !== "HOST" && name !== "PORT" && !name.startsWith("FORGERELAY_")
+  ),
+);
+const env = {
+  ...cleanEnv,
+  HOST: "127.0.0.1",
+  PORT: String(port),
+  FORGERELAY_CONFIG_DIR: configDir,
+  FORGERELAY_OAUTH_OWNER_TOKEN: ownerToken,
+  FORGERELAY_PUBLIC_BASE_URL: baseUrl,
+  FORGERELAY_TOOL_MODE: "full",
+  FORGERELAY_WIDGETS: "off",
+  FORGERELAY_LOG_LEVEL: "debug",
+  FORGERELAY_LOG_FORMAT: "json",
+};
+
+let serverLogs = "";
+const server = spawn(process.execPath, ["--import", "tsx", "src/cli.ts", "serve"], {
+  cwd: repoRoot,
+  env,
+  stdio: ["ignore", "pipe", "pipe"],
+});
+server.stdout?.on("data", (chunk) => { serverLogs += chunk.toString(); });
+server.stderr?.on("data", (chunk) => { serverLogs += chunk.toString(); });
+
+let client;
+try {
+  await waitForHealth(server, baseUrl);
+  pass("modern HTTP health", baseUrl);
+
+  const unauthorized = await fetch(mcpUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream",
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "server/discover", params: {} }),
+  });
+  assert.equal(unauthorized.status, 401);
+  assert.match(unauthorized.headers.get("www-authenticate") ?? "", /Bearer .*resource_metadata=/i);
+  pass("modern HTTP bearer challenge", "unauthenticated MCP request advertises protected-resource metadata");
+
+  const tokenResponse = await fetch(`${baseUrl}/auth/cli`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ owner_token: ownerToken }),
+  });
+  const tokenBody = await tokenResponse.text();
+  assert.equal(tokenResponse.status, 200, tokenBody);
+  const tokens = JSON.parse(tokenBody);
+  assert.equal(tokens.token_type, "bearer");
+  assert.ok(tokens.access_token);
+  pass("modern HTTP auth", "real ForgeRelay bearer token issued on 7678");
+
+  const transport = new StreamableHTTPClientTransport(new URL(mcpUrl), {
+    requestInit: {
+      headers: { authorization: `Bearer ${tokens.access_token}` },
+    },
+  });
+  client = new Client(
+    { name: "forgerelay-modern-http-acceptance", version: "1.0.0" },
+    { versionNegotiation: { mode: { pin: "2026-07-28" } } },
+  );
+  await client.connect(transport);
+  assert.equal(client.getProtocolEra(), "modern");
+  assert.equal(client.getNegotiatedProtocolVersion(), "2026-07-28");
+  assert.equal(transport.sessionId, undefined);
+  pass("modern protocol negotiation", "2026-07-28 connected without Mcp-Session-Id");
+
+  const listed = await client.listTools();
+  assert.ok(listed.tools.some((tool) => tool.name === "open_workspace"));
+  const opened = await client.callTool({
+    name: "open_workspace",
+    arguments: { path: workspaceRoot, context: "none" },
+  });
+  assert.notEqual(opened.isError, true);
+  const workspaceId = String(opened.structuredContent?.workspaceId ?? "");
+  assert.match(workspaceId, /^ws_/);
+  pass("modern tools call", "tools/list and open_workspace completed over stateless HTTP");
+
+  const conversationMeta = { "dev.forgerelay/conversation": "modern-http-acceptance-conversation" };
+  const panel = await client.callTool({
+    name: "activity_panel",
+    arguments: { workspaceId },
+    _meta: conversationMeta,
+  });
+  assert.notEqual(panel.isError, true);
+  const turnId = String(panel.structuredContent?.turnId ?? "");
+  assert.match(turnId, /^turn_/);
+  const restored = await client.callTool({
+    name: "activity_snapshot",
+    arguments: { workspaceId },
+    _meta: conversationMeta,
+  });
+  assert.notEqual(restored.isError, true);
+  assert.equal(restored.structuredContent?.turnId, turnId);
+  pass("modern vendor conversation continuity", "stable ForgeRelay metadata restored the Host Turn across stateless requests");
+
+  const requestScopedPanel = await client.callTool({
+    name: "activity_panel",
+    arguments: { workspaceId },
+  });
+  assert.notEqual(requestScopedPanel.isError, true);
+  const requestScopedSnapshot = await client.callTool({
+    name: "activity_snapshot",
+    arguments: { workspaceId },
+  });
+  assert.equal(requestScopedSnapshot.isError, true);
+  assert.match(
+    requestScopedSnapshot.content?.map((entry) => entry.type === "text" ? entry.text : "").join("\n") ?? "",
+    /could not resolve the current Host Turn/i,
+  );
+  pass("modern request scope isolation", "requests without stable metadata do not share Host Turn state");
+
+  assert.equal(serverLogs.includes("\"protocolEra\":\"modern\""), true);
+  pass("modern routing observability", "ForgeRelay classified the accepted request as modern");
+
+  console.log("Modern HTTP acceptance passed.");
+} catch (error) {
+  if (serverLogs) process.stderr.write(`\n--- ForgeRelay 7678 logs ---\n${serverLogs}`);
+  throw error;
+} finally {
+  try {
+    await client?.close();
+  } finally {
+    await stopServer(server);
+  }
+}