@team-agent/installer 0.5.106 → 0.5.108

package/crates/team-agent/src/lifecycle/launch/pi_mcp_extension.js

@@ -0,0 +1,226 @@
+// The Rust materializer prepends teamMcpDefinition and teamMcpReceiptRoot as JSON.
+// No package discovery, private extension events, settings writes or factory calls.
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export default function teamAgentMcp(pi) {
+  // Keep full UUID entropy and all three native tool names below Pi's 64-character limit.
+  const alias = `team_${randomUUID().replaceAll("-", "")}`;
+  const wanted = teamMcpDefinition.includeTools;
+  const receipt = join(teamMcpReceiptRoot, `${alias}.json`);
+  let backend, surface, registration, timer, failure, bindingReady = false, stopped = false, starting = false;
+  let wireSuffix;
+  let nativeOwned = false;
+  const returned = new Set();
+  let frame = {
+    schema_version: "team-agent.pi-mcp.v1", alias,
+    api_shape: Object.fromEntries(["registerMcpServer", "unregisterMcpServer", "getCommands", "getAllTools", "getActiveTools"]
+      .map((name) => [name, typeof pi[name]])),
+    candidate: teamMcpDefinition.command, tools: wanted,
+    workspace: teamMcpDefinition.env.TEAM_AGENT_WORKSPACE,
+    agent_id: teamMcpDefinition.env.TEAM_AGENT_ID,
+    team_id: teamMcpDefinition.env.TEAM_AGENT_OWNER_TEAM_ID,
+  };
+
+  function publish(stage, extra = {}) {
+    frame = { ...frame, stage, backend, surface, ...extra };
+    const temp = `${receipt}.tmp`;
+    let written = false;
+    try {
+      writeFileSync(temp, JSON.stringify(frame) + "\n", { flag: "wx", mode: 0o600 });
+      written = true;
+      chmodSync(temp, 0o600);
+      renameSync(temp, receipt);
+    } catch (error) {
+      if (written) {
+        try { unlinkSync(temp); } catch { /* only the exact temporary file we created */ }
+      }
+      throw error;
+    }
+  }
+
+  function fail(ctx, stage, error) {
+    clearInterval(timer);
+    // Third-party error text can contain credentials: retain correlation, not its content.
+    const errorSha256 = createHash("sha256").update(String(error)).digest("hex");
+    failure = new Error(`Pi Team MCP unavailable at ${stage}; receipt ${receipt}`);
+    try { publish("Failed", { failed_stage: stage, error_sha256: errorSha256 }); }
+    catch { failure = new Error("Pi Team MCP failed and its owned receipt could not be written"); }
+    ctx.abort();
+    ctx.shutdown();
+    return failure;
+  }
+
+  function proxyAvailable() {
+    const tool = pi.getAllTools().find((tool) => tool.name === "mcp");
+    const properties = tool?.parameters?.properties;
+    return properties?.tool?.type === "string" && properties?.args
+      && pi.getActiveTools().includes("mcp");
+  }
+
+  function directBinding() {
+    const namespace = `mcp__${alias}`;
+    const tools = pi.getAllTools().filter((tool) => tool.namespace?.name === namespace && tool.exposure !== "hidden");
+    const active = new Set(pi.getActiveTools());
+    const names = wanted.map((name) => `mcp__${alias}__${name}`);
+    if (tools.length !== wanted.length) return undefined;
+    if (!names.every((name) => active.has(name) && tools.some((tool) => tool.name === name && tool.exposure === "direct"))) return undefined;
+    return names;
+  }
+
+  async function publicBridge(commands) {
+    const ownPath = realpathSync(fileURLToPath(import.meta.url));
+    const entries = new Set();
+    for (const command of commands) {
+      if (command.source !== "extension") continue;
+      const entry = command.sourceInfo?.path ?? command.path;
+      if (!entry || !isAbsolute(entry)) continue;
+      const canonical = realpathSync(entry);
+      if (canonical === ownPath) continue;
+      if (!statSync(canonical).isFile()) throw new Error("Loaded extension entry is not a regular file");
+      entries.add(canonical);
+    }
+    const bridges = [];
+    for (const entry of entries) {
+      // Import only the public exports of already-loaded entries, never their default factory.
+      const module = await import(pathToFileURL(entry).href);
+      if (typeof module.registerMcpServer === "function") bridges.push({ entry, register: module.registerMcpServer });
+    }
+    if (bridges.length > 1) throw new Error("Ambiguous loaded MCP registration capabilities");
+    return bridges[0];
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    if (starting || backend || failure || stopped) return;
+    starting = true;
+    try {
+      publish("ExecutableCatalogReady");
+      const native = typeof pi.registerMcpServer === "function" && typeof pi.unregisterMcpServer === "function";
+      const commands = typeof pi.getCommands === "function" ? pi.getCommands() : [];
+      const builtin = commands.some((command) => command.source === "extension" && command.sourceInfo?.path === "builtin:mcp");
+      const deadline = performance.now() + 30_000;
+      let loadingTimeout;
+      let bridge;
+      try {
+        if (!(native && builtin)) {
+          bridge = await Promise.race([
+            publicBridge(commands),
+            new Promise((_resolve, reject) => { loadingTimeout = setTimeout(() => reject(new Error("Public MCP capability loading timed out")), 30_000); }),
+          ]);
+        }
+      } finally { clearTimeout(loadingTimeout); }
+      if (stopped || failure) return;
+      if (bridge) {
+        backend = "public-bridge";
+        surface = "proxy";
+        registration = bridge.register({ pi, name: alias, definition: teamMcpDefinition });
+        if (!registration || typeof registration.dispose !== "function") throw new Error("Public MCP registration has no owned dispose handle");
+        publish("RegistrationSelected", { bridge_entry: bridge.entry });
+      } else if (native) {
+        backend = "native-api";
+        const { command, args, env, cwd } = teamMcpDefinition;
+        pi.registerMcpServer(alias, {
+          command, args, env, ...(cwd ? { cwd } : {}),
+          exposure: "hidden", toolExposure: Object.fromEntries(wanted.map((name) => [name, "direct"])),
+        });
+        nativeOwned = true;
+        publish("RegistrationSelected");
+      } else {
+        throw new Error("No native MCP API or loaded public MCP registration bridge");
+      }
+      // Never await connection here: later session_start handlers may own the consumer.
+      timer = setInterval(() => {
+        if (stopped || failure) return;
+        try {
+          if (performance.now() > deadline) {
+            fail(ctx, "tools-ready-timeout", new Error("MCP consumer did not expose the registered tools"));
+            return;
+          }
+          const names = backend === "native-api" ? directBinding() : undefined;
+          if (names) {
+            surface = "direct";
+            bindingReady = true;
+            clearInterval(timer);
+            publish("ToolsAvailable", { actual_tool_names: names, evidence: "pi-runtime-tool-registry" });
+          } else if (!builtin && proxyAvailable()) {
+            surface = "proxy";
+            bindingReady = true;
+            clearInterval(timer);
+            publish("RegistrationSelected", { evidence: "proxy-present; owned MCP calls still pending" });
+          }
+        } catch (error) { fail(ctx, "tools-ready", error); }
+      }, 25);
+    } catch (error) { throw fail(ctx, "registration", error); }
+  });
+
+  async function waitForBinding() {
+    while (!bindingReady && !failure && !stopped) await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+
+  // before_agent_start exceptions are diagnostic in Pi; input must be handled to stop a new run.
+  pi.on("input", async (_event, ctx) => {
+    await waitForBinding();
+    if (failure || stopped) {
+      ctx.shutdown();
+      return { action: "handled" };
+    }
+    return { action: "continue" };
+  });
+
+  pi.on("before_agent_start", async (event, ctx) => {
+    await waitForBinding();
+    if (failure) throw failure;
+    if (stopped || !backend) throw fail(ctx, "wire-binding", new Error("No owned MCP registration"));
+    if (surface === "direct" && !directBinding()) throw fail(ctx, "wire-binding", new Error("Owned MCP tools became unreachable"));
+    if (surface === "proxy" && !proxyAvailable()) throw fail(ctx, "wire-binding", new Error("MCP proxy became unreachable"));
+    const examples = wanted.map((tool) => {
+      const args = tool === "send_message" ? { to: "leader", content: "..." }
+        : tool === "report_result" ? { summary: "..." } : {};
+      return surface === "direct"
+        ? `- ${tool}: mcp__${alias}__${tool}; arguments ${JSON.stringify(args)}`
+        : `- ${tool}: mcp(${JSON.stringify({ tool: `${alias}_${tool}`, args })})`;
+    });
+    const base = wireSuffix && event.systemPrompt.endsWith(wireSuffix)
+      ? event.systemPrompt.slice(0, -wireSuffix.length) : event.systemPrompt;
+    wireSuffix = "\n\n# Team Agent MCP wire binding\n"
+      + "Use these actual tools for the logical Team Agent operations above. Do not pass sender, task_id or schema_version.\n"
+      + examples.join("\n");
+    return { systemPrompt: base + wireSuffix };
+  });
+
+  pi.on("before_provider_request", (_event, ctx) => {
+    if (failure || stopped || !bindingReady) ctx.abort();
+  });
+
+  pi.on("tool_result", (event, ctx) => {
+    if (stopped || failure) return;
+    const name = event.toolName === "mcp" ? event.input?.tool : event.toolName;
+    const tool = wanted.find((tool) => name === (surface === "direct" ? `mcp__${alias}__${tool}` : `${alias}_${tool}`));
+    if (!tool) return;
+    if (event.isError === false) returned.add(tool);
+    try {
+      publish(returned.size === wanted.length ? "ToolsVerified" : frame.stage, {
+        returned_tools: [...returned], last_call_is_error: event.isError ?? null,
+        evidence: "owned tool-result events; business success requires the original results",
+      });
+    } catch (error) { throw fail(ctx, "tool-receipt", error); }
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(timer);
+    const current = registration;
+    registration = undefined;
+    try {
+      if (nativeOwned) {
+        nativeOwned = false;
+        pi.unregisterMcpServer(alias);
+      }
+      await current?.dispose();
+      publish(failure ? "Failed" : frame.stage, { shutdown: true });
+    } catch (error) { throw fail(ctx, "shutdown", error); }
+  });
+}

package/crates/team-agent/src/lifecycle/launch/quick_start.rs

@@ -2788,43 +2788,6 @@ mod fresh_quick_start_leader_binding_tests {
         let _ = std::fs::remove_dir_all(&workspace);
     }
 
-    #[test]
-    fn attach_registry_or_readback_failure_rolls_back_exact_state_bytes() {
-        assert_failure_rolls_back_this_attempt(
-            "attach-failure",
-            MockOps {
-                attach_ok: false,
-                ..MockOps::default()
-            },
-            1,
-            0,
-            0,
-            false,
-        );
-        assert_failure_rolls_back_this_attempt(
-            "registry-failure",
-            MockOps {
-                register_ok: false,
-                ..MockOps::default()
-            },
-            1,
-            1,
-            0,
-            true,
-        );
-        assert_failure_rolls_back_this_attempt(
-            "readback-failure",
-            MockOps {
-                readback_ok: false,
-                ..MockOps::default()
-            },
-            1,
-            1,
-            1,
-            true,
-        );
-    }
-
     #[test]
     fn attach_failure_rolls_back_exact_state_bytes() {
         assert_failure_rolls_back_this_attempt(

package/crates/team-agent/src/lifecycle/tests/agent_ops.rs

@@ -365,15 +365,6 @@ fn add_agent_joins_w2_into_running_roster_and_existing_session() {
     );
 }
 
-// REAL-MACHINE e2e boundary (rt-host-a verifies): after `add-agent w2`, the coordinator delivers
-// `send w2` and w2 reports a result (full round-trip). #[ignore] — needs a live tmux session + worker.
-#[test]
-#[ignore = "real-machine: add-agent then send w2 round-trips"]
-fn add_agent_then_send_w2_round_trips() {
-    // The framework asserts: add-agent w2 -> w2 in the live session + roster -> `send w2 <msg>` ->
-    // coordinator delivers -> w2 emits a result_envelope (results row). Not unit-testable in-process.
-}
-
 #[derive(Clone)]
 struct SocketRecordingRunner {
     recorded: std::sync::Arc<std::sync::Mutex<Vec<Vec<String>>>>,

package/crates/team-agent/src/lifecycle/tests/fixtures/pi_native_mcp_host.mjs

@@ -0,0 +1,71 @@
+import { writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+const [wrapperPath, receiptPath, cwd] = process.argv.slice(2);
+if (!wrapperPath || !receiptPath || !cwd) throw new Error("expected wrapper, receipt, and cwd");
+
+const registrations = [];
+const unregistrations = [];
+const handlers = new Map();
+const extensionCommands = [{
+  name: "mcp",
+  source: "extension",
+  sourceInfo: { path: "builtin:mcp", source: "builtin", scope: "user", origin: "top-level" },
+}];
+const pi = {
+  on(event, handler) {
+    const list = handlers.get(event) ?? [];
+    list.push(handler);
+    handlers.set(event, list);
+  },
+  getCommands() {
+    return extensionCommands;
+  },
+  getMcpServers() {
+    return registrations.map(({ name, config }) => ({ name, config, extensionPath: "<native-n1-fixture>" }));
+  },
+  getAllTools() {
+    return registrations.flatMap(({ name, config }) => Object.entries(config.toolExposure ?? {})
+      .map(([tool, exposure]) => ({ name: `mcp__${name}__${tool}`, namespace: { name: `mcp__${name}` }, exposure })));
+  },
+  getActiveTools() {
+    return this.getAllTools().filter((tool) => tool.exposure !== "hidden").map((tool) => tool.name);
+  },
+  registerMcpServer(name, config) {
+    registrations.push({ name, config });
+  },
+  unregisterMcpServer(name) {
+    unregistrations.push(name);
+  },
+};
+
+const extension = await import(pathToFileURL(wrapperPath).href);
+if (typeof extension.default !== "function") throw new Error("generated wrapper has no default extension factory");
+await extension.default(pi);
+const context = {
+  cwd,
+  sessionManager: {
+    getSessionFile: () => undefined,
+    getLeafId: () => undefined,
+    getEntries: () => [],
+  },
+};
+for (const handler of handlers.get("session_start") ?? []) {
+  await handler({ type: "session_start" }, context);
+}
+if (registrations.length !== 1) throw new Error(`expected one native MCP registration, saw ${registrations.length}`);
+const expectedTools = Object.keys(registrations[0].config.toolExposure ?? {})
+  .map((tool) => `mcp__${registrations[0].name}__${tool}`);
+const deadline = Date.now() + 3_000;
+while (!expectedTools.every((name) => pi.getActiveTools().includes(name))) {
+  if (Date.now() >= deadline) throw new Error(`native MCP tools never became active: ${pi.getActiveTools()}`);
+  await new Promise((resolve) => setTimeout(resolve, 10));
+}
+const beforeAgentStart = handlers.get("before_agent_start")?.[0];
+if (typeof beforeAgentStart !== "function") throw new Error("generated wrapper omitted before_agent_start wire binding");
+const binding = await beforeAgentStart({ systemPrompt: "N1 fixture" }, context);
+const wirePrompt = binding?.systemPrompt;
+if (typeof wirePrompt !== "string" || !expectedTools.every((name) => wirePrompt.includes(name))) {
+  throw new Error(`native Team tool wire binding is incomplete: ${wirePrompt}`);
+}
+await writeFile(receiptPath, `${JSON.stringify({ registrations, unregistrations, activeTools: pi.getActiveTools(), expectedTools, wirePrompt }, null, 2)}\n`, "utf8");

package/crates/team-agent/src/lifecycle/tests/lane_ops.rs

@@ -1321,33 +1321,6 @@ fn lanea_stop_window_present_kills_and_stopped_true() {
     );
 }
 
-// ── STOP #2 (stop-display-noop-2) [RED] — close ghostty_workspace slot: persist display.status/pane_title
-// Golden operations.py:88-92 -> display/close.py:84-85 relabels the slot: display["status"]="stopped",
-// display["pane_title"]=f"stopped: {agent_id}", written back into the persisted agent entry. Rust never
-// touches the display (mark_agent_stopped leaves it as-is) and hardcodes display_closed:false. RED: the
-// persisted display.status/pane_title are the in-process observable.
-#[test]
-#[ignore = "legacy external display contract removed; runtime is silent tmux only"]
-fn lanea_stop_ghostty_workspace_relabels_slot_to_stopped() {
-    let ws = lanea_ws_agents(json!({
-        "alpha": { "status": "running", "provider": "codex", "window": "alpha",
-                   "display": { "backend": "ghostty_workspace", "pane_id": "%5", "linked_session": "disp-alpha", "status": "running", "pane_title": "alpha" } }
-    }));
-    let tx = LaneTransport::new("team-laneateam", &["alpha"]);
-    let _ = stop_agent_with_transport(&ws, &aid("alpha"), None, &tx).expect("stop ok");
-    let state = crate::state::persist::load_runtime_state(&ws).expect("load state");
-    assert_eq!(
-        state.pointer("/agents/alpha/display/status").and_then(serde_json::Value::as_str),
-        Some("stopped"),
-        "stop must relabel a ghostty_workspace slot: display.status='stopped' (close.py:84); Rust leaves it 'running'"
-    );
-    assert_eq!(
-        state.pointer("/agents/alpha/display/pane_title").and_then(serde_json::Value::as_str),
-        Some("stopped: alpha"),
-        "stop must set display.pane_title='stopped: <id>' (close.py:85); Rust never touches the display"
-    );
-}
-
 // ── RESET #3 (reset-paused-restart-2) [RED] — reset of a PAUSED agent returns ok=true (NOT an Err) ───
 // Golden operations.py:126-140: after discard, reset re-spawns via start_agent(force,allow_fresh).
 // discard does NOT clear `paused`, so start_agent returns the refusal-shaped {ok:False,status:paused,
@@ -1851,42 +1824,3 @@ fn fresh_start_persists_boundary_from_before_transport_spawn() {
          spawned_at={spawned_at}, transport_observed_at={transport_observed_at}"
     );
 }
-
-// ── REMOVE #6/#12 (remove-rollback-no-agent-health-3 / remove-rollback-health-1) [SEAM #[ignore]] ────
-// Golden _RemoveRollback captures `self.health = copy.deepcopy(store.agent_health().get(agent_id))`
-// (agents.py:185) and restore() re-upserts it via _restore_agent_health (agents.py:215-218,268-278). The
-// Rust RemoveRollback has NO health field and never restores it (restart.rs:972-1067). This is only
-// observable when a step AFTER the agent_health delete fails — but Rust's only post-delete step is the
-// snapshot, which golden runs OUTSIDE the rollback-protected region (agents.py:135). Exercising it
-// golden-faithfully needs a production failure-injection seam at an in-try step after the delete (mirror
-// the coordinator SaveHook). PORTER: add `health: Option<Value>` to RemoveRollback (capture the row
-// before delete; restore re-upserts status||"IDLE"/last_output_at/context_usage_pct/current_task_id, or
-// deletes if None) AND move save_team_runtime_snapshot OUTSIDE the rollback region (golden agents.py:135).
-#[test]
-#[ignore = "seam: agent_health rollback restore needs a failure-injection hook (post-delete, in-try) to \
-            exercise in-process; golden agents.py:185/215-218/268-278. Porter adds RemoveRollback.health + \
-            moves save_team_runtime_snapshot outside the rollback region."]
-fn lanea_remove_rollback_restores_agent_health() {
-    // Golden contract (verified by reading agents.py): on a mid-remove failure after the agent_health
-    // row is deleted, rollback re-upserts the captured row so the health history is not lost.
-}
-
-// ── FORK (fork-incomplete-rollback) [SEAM #[ignore]] — post-spawn rollback arms ─────────────────────
-// Golden operations.py:384-394 wraps spec-mutation..start_coordinator in try/except; on ANY failure it
-// (1) kills the spawned tmux window if present, (2) adapter.cleanup_mcp, (3) restores old spec text, and
-// (4) restores prior state. Rust only restores the spec on the spawn_into arm (launch.rs:481); the
-// save_runtime_state (486-487) and start_coordinator (488-493) failure arms leave the spec mutated, the
-// already-spawned window un-killed, and the state un-rolled-back; install_mcp/cleanup_mcp are absent.
-// The adapter.fork_plan arm IS covered HARD above (lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm).
-// The post-SPAWN arms need a failure-injection seam after spawn_into (codex+subscription forks past
-// adapter.fork_plan, so the spawn succeeds and there is no in-process way to fail save/coordinator cleanly).
-// PORTER: a Drop guard armed after the spec write, disarmed on success — kills the window, restores spec
-// + state, runs cleanup_mcp on every post-write error arm.
-#[test]
-#[ignore = "seam: fork post-spawn rollback arms (save_runtime_state / start_coordinator failure) need a \
-            failure-injection hook after spawn_into; golden operations.py:384-394. Porter wires a Drop \
-            guard (kill window + restore spec/state + cleanup_mcp) armed after the spec write."]
-fn lanea_fork_rollback_complete_on_post_spawn_failure() {
-    // Golden contract (operations.py:384-394): a post-spawn failure kills the spawned window, restores
-    // the old spec text + prior state, and runs cleanup_mcp before re-raising.
-}