agent-relay-runner 0.89.2 → 0.90.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.89.2",
+  "version": "0.90.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.68"
+    "agent-relay-sdk": "0.2.69"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.89.2",
+  "version": "0.90.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/launch-assembly.ts

@@ -13,6 +13,7 @@ import {
   resolveClaudeProvisionedPlugins,
   resolveClaudeProvisionedSkills,
   resolveCodexProvisionedSkills,
+  resolveProjectMcpServers,
   profileProvisioning,
 } from "./provisioning";
 import {
@@ -73,6 +74,11 @@ export interface AssembledMcp {
   strict: boolean;
   /** Relay-provisioned server names (excludes the relay endpoint itself). */
   servers: string[];
+  /** #667 — project `.mcp.json` server names projected from the spawn cwd's committed
+   *  `.mcp.json` (via `--mcp-config`, so they survive strict). Sourced from the project,
+   *  not ambient host MCP. Empty unless the profile/spawn opted into `projectMcp`, and a
+   *  name already declared by relay-provisioned `servers` wins (not double-listed here). */
+  projectServers: string[];
   /** #662 — host USER-scope MCP server names (`~/.claude.json` `mcpServers`) re-injected
    *  into `--mcp-config` for an `mcp.mode:"host"` profile, so `--strict-mcp-config` keeps
    *  the ambient host MCP (callmux/qmd/gh) instead of dropping it. Empty for non-host mcp
@@ -202,6 +208,20 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   const mcpServers = Object.keys(provisionedMcp).filter((name) => name !== RELAY_MCP_SERVER_NAME);
   const relayEndpoint = profileAllowsRelayFeature(config, "mcp");
 
+  // #667 — project `.mcp.json` projection (opt-in). The spawn cwd's committed servers are
+  // injected through the SAME `--mcp-config` channel as relay-provisioned servers, so they
+  // survive `--strict-mcp-config` without the ambient project-discovery modal. A relay-
+  // provisioned server of the same name wins (the profile is the explicit, relay-owned
+  // source); the relay endpoint name is reserved. `declaredMcp` is the union relay injects.
+  const projectMcpRaw = resolveProjectMcpServers(config);
+  const projectMcp = Object.fromEntries(
+    Object.entries(projectMcpRaw).filter(
+      ([name]) => name !== RELAY_MCP_SERVER_NAME && !(name in provisionedMcp),
+    ),
+  );
+  const projectServers = Object.keys(projectMcp);
+  const declaredMcp = { ...projectMcp, ...provisionedMcp };
+
   // #662 — EVERY managed Claude launch is --strict-mcp-config, not just vanilla. A managed
   // agent runs headless (no human at the keyboard), so Claude's blocking "N new MCP servers
   // found in this project — select to enable" modal (raised on UNDECIDED cwd `.mcp.json`
@@ -224,7 +244,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     && (!config.agentProfile || config.agentProfile.mcp.mode === "host");
   const hostMcp = usesHostMcp ? hostUserScopeMcpServers() : {};
   const hostMcpServers = Object.keys(hostMcp).filter(
-    (name) => name !== RELAY_MCP_SERVER_NAME && !(name in provisionedMcp),
+    (name) => name !== RELAY_MCP_SERVER_NAME && !(name in declaredMcp),
   );
 
   const instructions = assembleInstructions(config);
@@ -238,7 +258,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
       relayUrl: config.relayUrl,
       ...(config.relayMcpEndpoint ? { endpoint: config.relayMcpEndpoint } : {}),
       includeRelay: relayEndpoint,
-      servers: provisionedMcp,
+      servers: declaredMcp,
       hostServers: hostMcp,
       strict: strictMcp,
     }),
@@ -258,7 +278,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     statusLine,
     skills: skills.map((s) => ({ name: s.name, dir: s.dir })),
     plugins: provisionedPlugins.map((p) => ({ name: p.name, dir: p.dir })),
-    mcp: { relayEndpoint, strict: strictMcp, servers: mcpServers, hostServers: hostMcpServers },
+    mcp: { relayEndpoint, strict: strictMcp, servers: mcpServers, projectServers, hostServers: hostMcpServers },
     instructions,
     args,
     env: configHome ? { CLAUDE_CONFIG_DIR: configHome } : {},
@@ -278,6 +298,18 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
   const provisionedMcp = profileProvisioning(config).mcpServers;
   const mcpServers = Object.keys(provisionedMcp).filter((name) => name !== RELAY_MCP_SERVER_NAME);
 
+  // #667 — project `.mcp.json` projection (opt-in), same union rule as Claude: a relay-
+  // provisioned server of the same name wins; the relay endpoint name is reserved. Codex has
+  // no `.mcp.json` discovery of its own, so this is purely additive (no strict/modal concern).
+  const projectMcpRaw = resolveProjectMcpServers(config);
+  const projectMcp = Object.fromEntries(
+    Object.entries(projectMcpRaw).filter(
+      ([name]) => name !== RELAY_MCP_SERVER_NAME && !(name in provisionedMcp),
+    ),
+  );
+  const projectServers = Object.keys(projectMcp);
+  const declaredMcp = { ...projectMcp, ...provisionedMcp };
+
   const instructions = assembleInstructions(config);
 
   // The skills/MCP/project-doc block; core launch config (model/approval/listen) stays
@@ -285,7 +317,7 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
   const args = [
     ...bundledSkillConfigArgs(skillDirs),
     ...(relayEndpoint ? relayMcpCodexConfigArgs(config.relayUrl, config.relayMcpEndpoint) : []),
-    ...codexProvisionedMcpArgs(provisionedMcp),
+    ...codexProvisionedMcpArgs(declaredMcp),
     ...codexProjectDocSuppressionArgs(config),
   ];
 
@@ -301,7 +333,7 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
     statusLine: false,
     skills: provisionedSkills.map((s) => ({ name: s.name, dir: s.dir })),
     plugins: [],
-    mcp: { relayEndpoint, strict: false, servers: mcpServers, hostServers: [] },
+    mcp: { relayEndpoint, strict: false, servers: mcpServers, projectServers, hostServers: [] },
     instructions,
     args,
     env: configHome ? { CODEX_HOME: configHome } : {},

package/src/profile-projection.ts

@@ -33,6 +33,7 @@ export function agentProfileProjectionReport(input: AgentProfileProjectionInput)
   add(provisioningSkillsEntry(assembled));
   add(provisioningPluginsEntry(assembled));
   add(provisioningMcpEntry(assembled));
+  add(projectMcpEntry(assembled));
   if (profile) add(filesystemEntry(profile));
   add(configHomeEntry(assembled));
   if (assembled.vanilla) add(vanillaLaunchEntry(provider));
@@ -143,6 +144,20 @@ function provisioningMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
     : `Relay-provisioned MCP servers emitted as -c mcp_servers.* overrides (${names.join(", ")}).`);
 }
 
+// #667 — project `.mcp.json` projection provenance. `not-applicable` when the profile/spawn
+// didn't opt in (the default); `applied` lists the spawn-cwd servers relay injected through
+// the controlled --mcp-config / -c path (sourced from the project, not ambient host MCP).
+function projectMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
+  const optedIn = Boolean(a.profile?.projectMcp);
+  const names = a.mcp.projectServers;
+  if (!optedIn) return notApplicable("projectMcp", "off", "Project .mcp.json projection is off (opt in via the projectMcp profile/spawn option).");
+  if (!names.length) return applied("projectMcp", "none", "Project .mcp.json projection is on, but the spawn cwd declared no injectable MCP servers.");
+  const label = `${names.length} server${names.length === 1 ? "" : "s"}`;
+  return applied("projectMcp", label, a.provider === "claude"
+    ? `Project .mcp.json servers composed into --mcp-config (${names.join(", ")})${a.mcp.strict ? "; survives --strict-mcp-config" : ""}.`
+    : `Project .mcp.json servers emitted as -c mcp_servers.* overrides (${names.join(", ")}).`);
+}
+
 function globalInstructionsEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
   const disposition = a.instructions.global;
   if (disposition === "allow") return applied("instructions.global", "allow", "Host/global provider instructions are left available.");

package/src/provisioning.ts

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
-import type { ProvisioningAssetFile, ResolvedProvisioning } from "agent-relay-sdk";
+import type { ProvisioningAssetFile, ProvisioningMcpServer, ResolvedProvisioning } from "agent-relay-sdk";
 import type { RunnerSpawnConfig } from "./adapter";
 
 // Runner-side materialization of the relay-resolved provisioning bundle
@@ -24,6 +24,56 @@ export function profileProvisioning(config: Pick<RunnerSpawnConfig, "agentProfil
   return { skills: p.skills ?? [], plugins: p.plugins ?? [], mcpServers: p.mcpServers ?? {} };
 }
 
+// The `mcpServers` keys a Claude `.mcp.json` entry may carry; coerced into the
+// provider-neutral ProvisioningMcpServer shape so the launch assembler projects them the
+// same way it does relay-provisioned servers (Claude `--mcp-config`, Codex `-c mcp_servers.*`).
+function coerceProjectMcpServer(raw: unknown): ProvisioningMcpServer | null {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw as Record<string, unknown>;
+  const server: ProvisioningMcpServer = {};
+  if (r.type === "stdio" || r.type === "http" || r.type === "sse") server.type = r.type;
+  if (typeof r.command === "string") server.command = r.command;
+  if (Array.isArray(r.args) && r.args.every((a) => typeof a === "string")) server.args = r.args as string[];
+  if (r.env && typeof r.env === "object") server.env = r.env as Record<string, string>;
+  if (typeof r.url === "string") server.url = r.url;
+  if (r.headers && typeof r.headers === "object") server.headers = r.headers as Record<string, string>;
+  // Drop an entry that names no transport (neither a command nor a url) — nothing to launch.
+  return server.command || server.url ? server : null;
+}
+
+// #667 — project `.mcp.json` MCP projection. OPT-IN via the resolved profile's `projectMcp`
+// (set per-spawn or by profile, relay-side). Reads the spawn cwd's COMMITTED `.mcp.json` and
+// returns its `mcpServers` as a provider-neutral record, so the launch assembler injects them
+// through the CONTROLLED `--mcp-config` (Claude) / `-c mcp_servers.*` (Codex) path that
+// survives `--strict-mcp-config` — the project's own servers travel with the repo like they do
+// for a human who clones it, WITHOUT enabling Claude's ambient project-discovery trust modal
+// (which wedges headless agents, the reason #662 made every managed launch strict). The runner
+// is the filesystem authority for the spawn cwd (relay may run on another host), so the read
+// lands here. Best-effort: a missing/malformed file (or one with no `mcpServers`) yields {} and
+// never aborts the launch. Returns {} when projection is OFF.
+export function resolveProjectMcpServers(
+  config: Pick<RunnerSpawnConfig, "agentProfile" | "cwd">,
+): Record<string, ProvisioningMcpServer> {
+  if (!config.agentProfile?.projectMcp) return {};
+  const file = join(config.cwd, ".mcp.json");
+  if (!existsSync(file)) return {};
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (err) {
+    console.warn(`project .mcp.json projection: failed to parse ${file}: ${(err as Error).message}`);
+    return {};
+  }
+  const servers = (parsed as { mcpServers?: unknown } | null)?.mcpServers;
+  if (!servers || typeof servers !== "object") return {};
+  const out: Record<string, ProvisioningMcpServer> = {};
+  for (const [name, raw] of Object.entries(servers as Record<string, unknown>)) {
+    const server = coerceProjectMcpServer(raw);
+    if (server) out[name] = server;
+  }
+  return out;
+}
+
 // A resolved provisioning asset: WHERE it lands (`dir`) and HOW it materializes
 // (`source`). `files` writes the inline set into `dir`; `link` symlinks a pre-existing
 // source dir at `dir`; `inPlace` uses the source dir as-is (no write, dir IS the source).

package/src/relay-injection-events.ts

@@ -39,6 +39,7 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
   if (!supportsLaunchAssembly(input.provider)) return events;
   const assembled = assembleLaunch(input.provider, input.config, input.providerConfig);
   const toolCount = assembled.skills.length + assembled.plugins.length + assembled.mcp.servers.length
+    + assembled.mcp.projectServers.length
     + (assembled.relaySkills ? 1 : 0)
     + (assembled.relayPlugin ? 1 : 0)
     + (assembled.mcp.relayEndpoint ? 1 : 0)
@@ -52,6 +53,7 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
     assembled.skills.length ? `${assembled.skills.length} skill${assembled.skills.length === 1 ? "" : "s"}` : "",
     assembled.plugins.length ? `${assembled.plugins.length} plugin${assembled.plugins.length === 1 ? "" : "s"}` : "",
     assembled.mcp.servers.length ? `${assembled.mcp.servers.length} MCP server${assembled.mcp.servers.length === 1 ? "" : "s"}` : "",
+    assembled.mcp.projectServers.length ? `${assembled.mcp.projectServers.length} project MCP server${assembled.mcp.projectServers.length === 1 ? "" : "s"}` : "",
   ].filter(Boolean);
   events.push({
     key: "tools",