@stage-labs/metro 0.1.0-beta.292 → 0.1.0-beta.293

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.292",
+  "version": "0.1.0-beta.293",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.292",
+  "version": "0.1.0-beta.293",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/marketplace/plugin/bin/policy.mjs

@@ -59,7 +59,10 @@ function decide(policy, name, group) {
 const normalized = (name) => name.replace(/[^a-zA-Z0-9_-]/g, '_');
 
 function connectorCall(snap, toolName) {
-  for (const [server, entry] of Object.entries(isRecord(snap.connectors) ? snap.connectors : {})) {
+  const entries = Object.entries(isRecord(snap.connectors) ? snap.connectors : {});
+  const legacy = entries.filter(([, entry]) => isRecord(entry) && !/^org-[A-Za-z0-9][A-Za-z0-9_-]{10}$/.test(text(entry.id)) && toolName.startsWith(`mcp__${normalized(`metro.box ${text(entry.name)}`)}__`));
+  if (legacy.length > 1) return { name: 'ambiguous connector name; use its instance server key', tool: toolName, group: 'write', policy: { write: 'deny' } };
+  for (const [server, entry] of entries) {
     if (!isRecord(entry)) continue;
     const name = text(entry.name);
     const prefixes = [`mcp__plugin_metro_${server}__`, `mcp__${server}__`];

package/runtime/node_modules/@metro-labs/daemon/src/connectors/gates.ts

@@ -20,7 +20,6 @@ export interface ConnectorGate {
 }
 
 let gates: ConnectorGate[] = [];
-let managed = new Set<string>();
 
 const normalized = (name: string): string => name.replace(/[^a-zA-Z0-9_-]/g, '_');
 
@@ -31,21 +30,21 @@ function approvalChanged(gate: ConnectorGate, tool: string, next: GateRow | unde
   return before !== after;
 }
 
-export function registerConnectors(rows: readonly GateRow[], managedIds: readonly string[] = [], keys: ReadonlyMap<string, string> = serverKeysOf([...rows])): void {
-  const nextManaged = new Set(managedIds);
-  revokeToolPrompts((tool) => {
-    const found = connectorToolOf(tool);
-    if (found === undefined || (!isOrgRelayId(found.gate.id) && !managed.has(found.gate.id) && !nextManaged.has(found.gate.id))) return false;
-    return approvalChanged(found.gate, found.tool, rows.find((row) => row.id === found.gate.id), keys);
-  });
-  managed = nextManaged;
-  gates = rows.map((row) => ({
+export function registerConnectors(rows: readonly GateRow[], keys: ReadonlyMap<string, string> = serverKeysOf([...rows])): void {
+  const next = rows.map((row) => ({
     id: row.id,
     name: row.name,
     server: keys.get(row.id) ?? '',
     policy: row.config.policy ?? {},
     tools: row.config.toolGroups ?? {},
   }));
+  revokeToolPrompts((tool) => {
+    const before = connectorToolOf(tool);
+    const after = connectorToolOf(tool, next);
+    if (before?.gate.id !== after?.gate.id) return true;
+    return before !== undefined && approvalChanged(before.gate, before.tool, rows.find((row) => row.id === before.gate.id), keys);
+  });
+  gates = next;
   const entries = rows.flatMap((row): [PolicyTarget, ToolPolicy][] =>
     row.config.policy === undefined ? [] : [[{ kind: 'connector', id: row.id }, row.config.policy]],
   );
@@ -63,7 +62,7 @@ const promptFor = (connectorId: string, tool: string) => (asked: string): boolea
 
 export function blockedReason(connectorId: string, tool: string, args: Record<string, unknown> = {}): string | null {
   const gate = gates.find((g) => g.id === connectorId);
-  if (gate === undefined) return null;
+  if (gate === undefined) return 'This connector is not available.';
   settlePrompts(promptFor(connectorId, tool), args);
   const access = policyFor({ kind: 'connector', id: connectorId }, { name: tool, group: toolGroupOf(gate, tool) });
   if (access === 'deny') return `Blocked by the owner's policy for ${gate.name} (${tool}).`;
@@ -92,19 +91,24 @@ export function requestConnectorBlocker(): () => BlockedReason {
   };
 }
 
-function prefixesOf(gate: ConnectorGate): string[] {
-  const prefixes = [`mcp__plugin_metro_${gate.server}__`, `mcp__${gate.server}__`];
-  return isOrgRelayId(gate.id) ? prefixes : [...prefixes, `mcp__${normalized(`metro.box ${gate.name}`)}__`];
+function resolvedTool(gate: ConnectorGate, called: string): { gate: ConnectorGate; tool: string } {
+  const known = [...Object.keys(gate.tools), ...Object.keys(gate.policy.tools ?? {})];
+  return { gate, tool: known.find((name) => name === called) ?? known.find((name) => normalized(name) === called) ?? called };
 }
 
-export function connectorToolOf(toolName: string): { gate: ConnectorGate; tool: string } | undefined {
+export function connectorToolOf(toolName: string, entries: readonly ConnectorGate[] = gates): { gate: ConnectorGate; tool: string } | undefined {
   if (toolName.startsWith('mcp__metro__')) return undefined;
-  for (const gate of gates)
-    for (const prefix of prefixesOf(gate))
-      if (toolName.startsWith(prefix) && toolName.length > prefix.length) {
-        const called = toolName.slice(prefix.length);
-        const known = [...Object.keys(gate.tools), ...Object.keys(gate.policy.tools ?? {})];
-        return { gate, tool: known.find((name) => name === called) ?? known.find((name) => normalized(name) === called) ?? called };
-      }
-  return undefined;
+  for (const gate of entries)
+    for (const prefix of [`mcp__plugin_metro_${gate.server}__`, `mcp__${gate.server}__`])
+      if (toolName.startsWith(prefix) && toolName.length > prefix.length) return resolvedTool(gate, toolName.slice(prefix.length));
+  return legacyToolOf(toolName, entries);
+}
+
+function legacyToolOf(toolName: string, entries: readonly ConnectorGate[]): { gate: ConnectorGate; tool: string } | undefined {
+  if (!toolName.startsWith('mcp__metro_box_')) return undefined;
+  const legacy = entries.filter((gate) => !isOrgRelayId(gate.id) && toolName.startsWith(`mcp__${normalized(`metro.box ${gate.name}`)}__`));
+  const gate = legacy.length === 1 ? legacy[0] : undefined;
+  if (gate === undefined) return undefined;
+  const called = toolName.slice(`mcp__${normalized(`metro.box ${gate.name}`)}__`.length);
+  return called === '' ? undefined : resolvedTool(gate, called);
 }

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-control.ts

@@ -62,7 +62,7 @@ function checkResponse(record: MigrationRecord, remote: RemoteMigration): void {
 }
 
 function callFailure(error: unknown, action: string): ApiError {
-  if (error instanceof MetroApiRefusal && error.code === 'migration_conflict') return new MigrationBlocked('destination_changed', 'The destination already has credentials, a name conflict or changed settings. Inspect it and reconcile; Metro will not overwrite credentials or create a duplicate.');
+  if (error instanceof MetroApiRefusal && error.code === 'migration_conflict') return new MigrationBlocked('destination_changed', 'The mapped destination already has credentials or changed settings. Inspect it and reconcile; Metro will not overwrite credentials or create a duplicate.');
   if (action === 'prepare' && error instanceof MetroApiRefusal && error.upstreamStatus === 400 && error.code === 'oauth_resource_required') {
     return new ApiError("Enter the provider's public OAuth resource. Roll back this preparation, then prepare again with that public value; never enter credentials.", 400);
   }
@@ -210,7 +210,8 @@ export class ConnectorMigrations {
 
   private waiting(context: Context, record: MigrationRecord, includeOrganization = false): boolean {
     const uncertain = migrationUncertaintyReceipt(record.sourceId, this.dir) !== null;
-    if (!uncertain && this.localIdle(record.sourceId) && (!includeOrganization || this.orgIdle(record.sourceId))) return false;
+    const localIdle = this.localIdle(record.sourceId);
+    if (!uncertain && localIdle && (!includeOrganization || this.orgIdle(record.sourceId))) return false;
     this.save(context, { ...record, reason: uncertain ? migrationRefreshUncertain(record.sourceId, this.dir) ? 'local_refresh_uncertain' : 'requests_uncertain' : 'waiting_for_local' });
     return true;
   }
@@ -300,6 +301,7 @@ export class ConnectorMigrations {
   private async resolve(context: Context, record: MigrationRecord, receipt: string | null): Promise<void> {
     this.check(context, record);
     if (receipt === null || receipt !== migrationUncertaintyReceipt(record.sourceId, this.dir)) throw conflict('The outstanding request receipt changed. Refresh before confirming that vendor requests have settled.');
+    localMigrationIdle(record.sourceId, this.dir, true);
     if (migrationRefreshUncertain(record.sourceId, this.dir)) return this.recoverRefresh(context, record, receipt);
     if (!resolveMigrationUncertainty(record.sourceId, receipt, this.dir)) throw conflict('Requests are still running or their receipt changed. Wait for vendor completion, then refresh before confirming settlement.');
     this.save(context, { ...record, reason: record.phase === 'prepared' ? 'not_verified' : null });

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-guard.ts

@@ -3,7 +3,7 @@ import type { FetchLike } from '@metro-labs/core/stations/oauth';
 import { agentsDir } from '../agents/files.js';
 import type { AgentKey } from './agent-key.js';
 import { migrationRecord, migrationRecords } from './migration-state.js';
-import { assertMigrationOutcomeKnown, beginMigrationOperation, migrationOperationsIdle, migrationRequestEffectful, type MigrationOperation } from './migration-operations.js';
+import { assertMigrationOutcomeKnown, beginMigrationOperation, drainMigrationListeners, migrationOperationsIdle, migrationRequestEffectful, type MigrationOperation } from './migration-operations.js';
 
 const locked = (phase: string): boolean => phase !== 'rolled_back';
 const retired = (record: NonNullable<ReturnType<typeof migrationRecord>>): boolean => record.move === true || record.phase === 'cutover' || record.phase === 'active' || record.phase === 'rollback';
@@ -26,17 +26,19 @@ export function assertLocalMigrationUse(id: string, dir = agentsDir()): void {
   assertMigrationOutcomeKnown(id, dir);
 }
 
-export function assertLocalMigrationEdit(id: string, name: string | undefined, dir = agentsDir()): void {
-  if (migrationRecords(dir).some((record) => locked(record.phase) && (record.sourceId === id || record.name === name))) throw refused();
+export function assertLocalMigrationEdit(id: string, dir = agentsDir()): void {
+  if (migrationRecords(dir).some((record) => locked(record.phase) && record.sourceId === id)) throw refused();
 }
 
 export function migrationExportableRows<T extends { id: string; name: string }>(rows: readonly T[], dir = agentsDir()): T[] {
   const records = migrationRecords(dir).filter((record) => locked(record.phase));
-  return rows.filter((row) => !records.some((record) => record.sourceId === row.id || record.name === row.name));
+  return rows.filter((row) => !records.some((record) => record.sourceId === row.id));
 }
 
 export function localMigrationIdle(id: string, dir = agentsDir(), allowUncertain = false): boolean {
-  return migrationOperationsIdle(id, dir, !allowUncertain && migrationSource(id, dir) !== null);
+  const record = migrationSource(id, dir);
+  if (record !== null && retired(record)) drainMigrationListeners(id, dir);
+  return migrationOperationsIdle(id, dir, !allowUncertain && record !== null);
 }
 
 export interface LocalMigrationOperation extends MigrationOperation {
@@ -45,11 +47,11 @@ export interface LocalMigrationOperation extends MigrationOperation {
   close: () => void;
 }
 
-export function beginLocalMigrationOperation(id: string, dir = agentsDir(), edit = false, name?: string): LocalMigrationOperation {
+export function beginLocalMigrationOperation(id: string, dir = agentsDir(), edit = false): LocalMigrationOperation {
   let closed = false;
   const check = (): void => {
     if (closed) throw refused();
-    if (edit) assertLocalMigrationEdit(id, name, dir);
+    if (edit) assertLocalMigrationEdit(id, dir);
     else assertLocalMigrationUse(id, dir);
   };
   check();
@@ -61,14 +63,15 @@ export function beginLocalMigrationOperation(id: string, dir = agentsDir(), edit
   return {
     check,
     dispatch,
+    passiveListener: tracked.passiveListener,
     persistedRefresh: tracked.persistedRefresh,
     fetch: (input, init) => dispatch(() => fetch(input, init), { effectful: migrationRequestEffectful(init?.method, init?.body) }),
     close: () => { closed = true; tracked.close(); },
   };
 }
 
-export async function withLocalMigrationOperation<T>(id: string, dir: string, run: (operation: LocalMigrationOperation) => Promise<T>, edit = false, name?: string): Promise<T> {
-  const operation = beginLocalMigrationOperation(id, dir, edit, name);
+export async function withLocalMigrationOperation<T>(id: string, dir: string, run: (operation: LocalMigrationOperation) => Promise<T>, edit = false): Promise<T> {
+  const operation = beginLocalMigrationOperation(id, dir, edit);
   try { return await run(operation); }
   finally { operation.close(); }
 }

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-operations.ts

@@ -17,13 +17,20 @@ interface RequestOperation {
   refresh: boolean;
 }
 
+interface PassiveListener {
+  idle: () => boolean;
+  stop: () => void;
+}
+
 export interface MigrationOperation {
+  passiveListener: (listener: PassiveListener) => void;
   dispatch: (send: () => Promise<Response>, options?: { protectedSource?: boolean; effectful?: boolean; refresh?: boolean }) => Promise<Response>;
   close: () => void;
   persistedRefresh: () => void;
 }
 
 const leases = new Map<string, Set<string>>();
+const listeners = new Map<string, PassiveListener>();
 const requests = new Map<string, RequestOperation>();
 const held = new Map<string, RequestOperation>();
 const keyOf = (source: string, dir: string): string => JSON.stringify([resolve(dir), source]);
@@ -103,6 +110,17 @@ export function assertMigrationOutcomeKnown(source: string, dir = agentsDir()):
   if (migrationUncertaintyReceipt(source, dir) !== null) throw uncertain();
 }
 
+export function drainMigrationListeners(source: string, dir: string): void {
+  const active = [...(leases.get(keyOf(source, dir)) ?? [])];
+  if (active.length === 0 || active.some((lease) => listeners.get(lease)?.idle() !== true)) return;
+  if (readPending(source, dir).some((id) => requests.has(id))) return;
+  for (const lease of active) {
+    const listener = listeners.get(lease);
+    listeners.delete(lease);
+    listener?.stop();
+  }
+}
+
 export function migrationOperationsIdle(source: string, dir: string, protectedSource: boolean): boolean {
   if (leases.has(keyOf(source, dir))) return false;
   return !protectedSource || readPending(source, dir).length === 0;
@@ -181,6 +199,7 @@ export function beginMigrationOperation(source: string, dir: string, protectedSo
   leases.set(key, active);
   let closed = false;
   return {
+    passiveListener: (listener) => { if (!closed) listeners.set(lease, listener); },
     dispatch: (send, options = {}) => {
       if (closed) return Promise.reject(uncertain());
       return dispatch(source, dir, lease, options.protectedSource ?? protectedSource, options.effectful ?? true, options.refresh ?? false, send);
@@ -191,6 +210,7 @@ export function beginMigrationOperation(source: string, dir: string, protectedSo
     close: () => {
       if (closed) return;
       closed = true;
+      listeners.delete(lease);
       for (const request of held.values()) if (request.lease === lease) {
         finish(request, false);
         held.delete(request.id);

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-preview.ts

@@ -201,13 +201,11 @@ function previewRows(dir: string): MigrationConnector[] {
   const rows = readRows(dir).map(previewRow);
   const seen = new Map<string, MigrationConnector>();
   for (const row of rows) {
-    for (const key of [`id:${row.id}`, `name:${row.name}`]) {
-      const prior = seen.get(key);
-      if (prior !== undefined) {
-        for (const duplicate of [prior, row]) if (!duplicate.issues.includes('invalid_config')) duplicate.issues.push('invalid_config');
-      }
-      seen.set(key, row);
+    const prior = seen.get(row.id);
+    if (prior !== undefined) {
+      for (const duplicate of [prior, row]) if (!duplicate.issues.includes('invalid_config')) duplicate.issues.push('invalid_config');
     }
+    seen.set(row.id, row);
   }
   return rows;
 }

package/runtime/node_modules/@metro-labs/daemon/src/connectors/oauth-routes.ts

@@ -51,7 +51,7 @@ export async function startOAuth(
       returnTo,
     }, operation.fetch);
     const row = await deps.createPendingConnector({
-      name: bodyField(body, 'name'),
+      name,
       url: bodyField(body, 'url'),
       clientId,
       clientSecret,
@@ -69,7 +69,7 @@ export async function startOAuth(
       'connector-api: stored unconnected, sending the user to sign in',
     );
     sendJson(req, res, 201, { ...payload(row), authorizeUrl: authorize });
-  }, true, name);
+  }, true);
 }
 
 export async function handleConnect(

package/runtime/node_modules/@metro-labs/daemon/src/connectors/plugin-sync.ts

@@ -33,21 +33,48 @@ export function serverKey(name: string): string {
   return slug === '' ? 'connector' : slug;
 }
 
-export function serverKeysOf(rows: PluginRow[]): Map<string, string> {
+function legacyOwners(rows: PluginRow[], published: PluginRow[]): Map<string, string> {
+  const visible = new Set(published.map((row) => row.id));
   const taken = new Map<string, number>();
-  const keys = new Map<string, string>();
-  for (const row of rows.filter((row) => !isOrgRelayId(row.id))) {
-    const wanted = serverKey(row.name);
-    const seen = taken.get(wanted) ?? 0;
-    taken.set(wanted, seen + 1);
-    keys.set(row.id, seen === 0 ? wanted : `${wanted}-${row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}`);
+  const owners = new Map<string, string>();
+  const reserved = new Set<string>();
+  for (const row of rows.filter((entry) => !isOrgRelayId(entry.id))) {
+    const slug = serverKey(row.name);
+    const seen = taken.get(slug) ?? 0;
+    taken.set(slug, seen + 1);
+    const key = seen === 0 ? slug : `${slug}-${row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}`;
+    reserved.add(key);
+    if (visible.has(row.id)) owners.set(key, row.id);
+  }
+  for (const row of rows.filter((entry) => isOrgRelayId(entry.id) && visible.has(entry.id)).sort((a, b) => a.id.localeCompare(b.id))) {
+    const key = availableKey(orgKey(row), reserved);
+    reserved.add(key);
+    owners.set(key, row.id);
   }
+  return new Map([...owners].map(([key, id]) => [id, key]));
+}
+
+const orgKey = (row: PluginRow): string => `org-${serverKey(row.name).slice(0, 35)}-${Buffer.from(row.id.slice(4)).toString('hex')}`;
+
+function availableKey(wanted: string, reserved: ReadonlySet<string>): string {
+  let key = wanted;
+  let suffix = 1;
+  while (reserved.has(key)) key = `${wanted}-${String(suffix++)}`;
+  return key;
+}
+
+export function serverKeysOf(rows: PluginRow[], saved?: ReadonlyMap<string, string>, published: PluginRow[] = rows): Map<string, string> {
+  const keys = new Map(saved ?? legacyOwners(rows, published));
   const reserved = new Set(keys.values());
-  for (const row of rows.filter((row) => isOrgRelayId(row.id)).sort((a, b) => a.id.localeCompare(b.id))) {
-    const wanted = `org-${serverKey(row.name).slice(0, 35)}-${Buffer.from(row.id.slice(4)).toString('hex')}`;
-    let key = wanted;
-    let suffix = 1;
-    while (reserved.has(key)) key = `${wanted}-${String(suffix++)}`;
+  const local = rows.filter((row) => !isOrgRelayId(row.id));
+  const organization = rows.filter((row) => isOrgRelayId(row.id)).sort((a, b) => a.id.localeCompare(b.id));
+  for (const row of [...local, ...organization]) {
+    if (keys.has(row.id)) continue;
+    const slug = serverKey(row.name);
+    const wanted = isOrgRelayId(row.id)
+      ? orgKey(row)
+      : reserved.has(slug) ? `${slug}-${row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}` : slug;
+    const key = availableKey(wanted, reserved);
     reserved.add(key);
     keys.set(row.id, key);
   }

package/runtime/node_modules/@metro-labs/daemon/src/connectors/publication.ts

@@ -1,5 +1,6 @@
 import { registerConnectors, type GateRow } from './gates.js';
-import { serverKeysOf, syncPluginServers } from './plugin-sync.js';
+import { syncPluginServers } from './plugin-sync.js';
+import { persistentServerKeys } from './server-keys.js';
 import { isOrgRelayId } from './relay-id.js';
 import { migrationRecords } from './migration-state.js';
 
@@ -17,14 +18,7 @@ function metadata(rows: readonly GateRow[]): GateRow[] {
   }));
 }
 
-export function publishConnectors(): void {
-  let records: ReturnType<typeof migrationRecords>;
-  try { records = migrationRecords().filter((record) => record.phase !== 'rolled_back'); }
-  catch (error) {
-    registerConnectors([], local.map((row) => row.id));
-    syncPluginServers([]);
-    throw error;
-  }
+function publishedRows(records: ReturnType<typeof migrationRecords>): GateRow[] {
   const retired = new Set(records.filter((record) => !['preparing', 'prepared'].includes(record.phase)).map((record) => record.sourceId));
   const aliases = new Map(organization.filter((row) => records.some((record) => record.phase === 'active' && record.sourceId === row.id && record.name === row.name)).map((row) => [row.id, row]));
   const rows = local.flatMap((row) => {
@@ -32,8 +26,25 @@ export function publishConnectors(): void {
     return alias !== undefined ? [alias] : retired.has(row.id) ? [] : [row];
   });
   rows.push(...organization.filter((row) => isOrgRelayId(row.id) && !records.some((record) => row.id === `org-${record.destinationId ?? ''}`)));
-  const keys = serverKeysOf([...local, ...rows.filter((row) => isOrgRelayId(row.id))]);
-  registerConnectors(rows, [...retired, ...aliases.keys()], keys);
+  return rows;
+}
+
+export function publishConnectors(): void {
+  let rows: GateRow[];
+  let keys: Map<string, string>;
+  try {
+    const records = migrationRecords().filter((record) => record.phase !== 'rolled_back');
+    rows = publishedRows(records);
+    const active = new Set(records.filter((record) => record.phase === 'active').map((record) => record.sourceId));
+    const reserved = [...rows, ...local.filter((row) => active.has(row.id))];
+    keys = persistentServerKeys([...local, ...organization.filter((row) => isOrgRelayId(row.id))], undefined, reserved);
+  }
+  catch (error) {
+    registerConnectors([]);
+    syncPluginServers([]);
+    throw error;
+  }
+  registerConnectors(rows, keys);
   syncPluginServers(rows, { keys });
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/connectors/relay-passive.ts

@@ -0,0 +1,96 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { JSONRPCNotificationSchema, ServerNotificationSchema } from '@modelcontextprotocol/sdk/types.js';
+import { isRecord } from '@metro-labs/core/is-record';
+import type { MigrationOperation } from './migration-operations.js';
+
+export const isRelaySse = (contentType: string | null | undefined): boolean => /^text\/event-stream\s*(?:;|$)/i.test(contentType ?? '');
+const MAX_FRAME = 64 * 1024;
+const NOTIFICATIONS = new Set(['notifications/tools/list_changed', 'notifications/resources/list_changed', 'notifications/prompts/list_changed', 'notifications/resources/updated', 'notifications/message']);
+
+export class PassiveSseListener {
+  forwarding = false;
+  private pending: Buffer[] = [];
+  private length = 0;
+  private data: string[] = [];
+  private fields = false;
+  private size = 0;
+  private unsafe = false;
+  private skipLf = false;
+  private first = true;
+  private readonly decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+  idle(): boolean { return !this.unsafe && this.length === 0 && !this.fields && !this.forwarding; }
+  keepaliveAllowed(): boolean { return this.unsafe || this.idle(); }
+
+  observe(chunk: Uint8Array): void {
+    if (this.unsafe) return;
+    this.scan(chunk);
+    if (this.unsafe) { this.pending = []; this.length = 0; this.data = []; }
+  }
+
+  private append(bytes: Uint8Array): void {
+    this.length += bytes.length;
+    if (this.length + this.size > MAX_FRAME) this.unsafe = true;
+    else if (bytes.length > 0) this.pending.push(Buffer.from(bytes));
+  }
+
+  private scan(bytes: Uint8Array): void {
+    let start = 0;
+    for (let at = 0; at < bytes.length; at += 1) {
+      if (at - start + this.length + this.size > MAX_FRAME) { this.unsafe = true; return; }
+      const byte = bytes[at];
+      if (this.skipLf && byte === 10) { this.skipLf = false; start = at + 1; continue; }
+      this.skipLf = false;
+      if (byte !== 10 && byte !== 13) continue;
+      this.append(bytes.subarray(start, at));
+      try { this.line(this.decoder.decode(Buffer.concat(this.pending, this.length)), this.length); }
+      catch { this.unsafe = true; }
+      this.pending = []; this.length = 0;
+      this.skipLf = byte === 13;
+      start = at + 1;
+      if (this.unsafe) return;
+    }
+    this.append(bytes.subarray(start));
+  }
+
+  private line(raw: string, length: number): void {
+    const line = this.first && raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
+    this.first = false;
+    if (line === '') {
+      if (this.data.length > 0 && !this.notification()) this.unsafe = true;
+      this.data = []; this.fields = false; this.size = 0;
+      return;
+    }
+    if (line.startsWith(':')) return;
+    this.size += length;
+    if (this.size > MAX_FRAME) { this.unsafe = true; return; }
+    this.fields = true;
+    const colon = line.indexOf(':');
+    const field = colon < 0 ? line : line.slice(0, colon);
+    const value = colon < 0 ? '' : line.slice(colon + 1).replace(/^ /, '');
+    this.field(field, value);
+  }
+
+  private field(field: string, value: string): void {
+    if (field === 'data') this.data.push(value);
+    else if (field === 'event') { if (value !== '' && value !== 'message') this.unsafe = true; }
+    else if (field === 'retry') { if (!/^\d+$/.test(value)) this.unsafe = true; }
+    else this.unsafe = true;
+  }
+
+  private notification(): boolean {
+    const text = this.data.join('\n');
+    if (text === '') return true;
+    const value: unknown = JSON.parse(text);
+    return isRecord(value) && typeof value.method === 'string' && NOTIFICATIONS.has(value.method)
+      && JSONRPCNotificationSchema.safeParse(value).success && ServerNotificationSchema.safeParse(value).success;
+  }
+}
+
+export function passiveRelayListener(req: IncomingMessage, res: ServerResponse, upstream: Response, operation: MigrationOperation, stop: () => void): PassiveSseListener | undefined {
+  if (req.method !== 'GET' || req.headers['last-event-id'] !== undefined || req.headers['transfer-encoding'] !== undefined || Number(req.headers['content-length'] ?? 0) !== 0) return undefined;
+  if (upstream.status !== 200 || upstream.body === null || !isRelaySse(upstream.headers.get('content-type'))) return undefined;
+  const listener = new PassiveSseListener();
+  operation.passiveListener({ idle: () => listener.idle() && res.writableLength === 0 && !res.destroyed, stop });
+  return listener;
+}

package/runtime/node_modules/@metro-labs/daemon/src/connectors/relay.ts

@@ -3,6 +3,7 @@ import { whyUnreachable } from '@metro-labs/http/connector-reach';
 import { noteHealth } from './health.js';
 import type { RelayTarget } from './relay-target.js';
 import type { RelaySession } from './relay-session.js';
+import { isRelaySse, passiveRelayListener, type PassiveSseListener } from './relay-passive.js';
 import { isOrgRelayId } from './relay-id.js';
 import { exchangeOrg } from './org-relay.js';
 import { assertLocalMigrationUse, migrationSource, withLocalMigrationOperation } from './migration-guard.js';
@@ -131,12 +132,12 @@ interface Keepalive {
   stop: () => void;
 }
 
-function startKeepalive(res: ServerResponse): Keepalive {
+function startKeepalive(res: ServerResponse, listener?: PassiveSseListener): Keepalive {
   let timer: ReturnType<typeof setTimeout> | undefined;
   const arm = (): void => {
     timer = setTimeout(() => {
       try {
-        res.write(': keepalive\n\n');
+        if (listener?.keepaliveAllowed() !== false) res.write(': keepalive\n\n');
       } catch {
         log.debug('relay: keepalive write failed');
       }
@@ -172,13 +173,17 @@ async function pumpBody(
   res: ServerResponse,
   body: ReadableStream<Uint8Array>,
   touch: () => void,
+  listener?: PassiveSseListener,
 ): Promise<void> {
   const reader = body.getReader();
   for (;;) {
     const { done, value } = await reader.read();
     if (done) return;
+    listener?.observe(value);
     touch();
+    if (listener !== undefined) listener.forwarding = true;
     if (!res.write(value)) await drainedOrClosed(res);
+    if (listener !== undefined) listener.forwarding = false;
   }
 }
 
@@ -191,22 +196,23 @@ function passedHeaders(upstream: Response): Record<string, string> {
   return headers;
 }
 
-async function pipe(res: ServerResponse, upstream: Response, answers: Record<string, unknown>[]): Promise<void> {
+async function pipe(res: ServerResponse, upstream: Response, answers: Record<string, unknown>[], listener?: PassiveSseListener): Promise<void> {
   const headers = passedHeaders(upstream);
   if (answers.length > 0 && (upstream.status === 200 || upstream.status === 202)) {
     await mergeBlocked(res, upstream, headers, answers);
     return;
   }
-  const sse = (headers['content-type'] ?? '').includes('text/event-stream');
+  const sse = isRelaySse(headers['content-type']);
   if (sse) headers['x-accel-buffering'] = 'no';
   res.writeHead(upstream.status, headers);
+  if (sse) res.flushHeaders();
   if (upstream.body === null) {
     res.end();
     return;
   }
-  const keepalive = sse ? startKeepalive(res) : null;
+  const keepalive = sse ? startKeepalive(res, listener) : null;
   try {
-    await pumpBody(res, upstream.body, () => keepalive?.touch());
+    await pumpBody(res, upstream.body, () => keepalive?.touch(), listener);
   } finally {
     keepalive?.stop();
   }
@@ -262,7 +268,7 @@ async function relayExchange(
     res.socket?.removeListener('close', bail);
   });
   try {
-    await relayOnce(req, res, connectorId, deps, control.signal);
+    await relayOnce(req, res, connectorId, deps, control);
   } catch (err) {
     if (!control.signal.aborted) throw err;
     log.debug({ connector: connectorId }, 'relay: the client left before the answer ended');
@@ -276,6 +282,7 @@ async function deliver(
   deps: RelayApiDeps,
   out: Exchanged,
   answers: Record<string, unknown>[],
+  listener?: PassiveSseListener,
 ): Promise<void> {
   if (out.kind === 'missing') {
     answer(res, 404, { error: 'no such connector' });
@@ -295,7 +302,7 @@ async function deliver(
   }
   const { status } = out.upstream;
   noteHealth(connectorId, status < 400, status < 400 ? null : `the connector answered ${String(status)}`);
-  await pipe(res, out.upstream, answers);
+  await pipe(res, out.upstream, answers, listener);
 }
 
 async function relayOrg(req: IncomingMessage, res: ServerResponse, id: string, deps: RelayApiDeps, read: Uint8Array<ArrayBuffer> | null, signal: AbortSignal): Promise<void> {
@@ -316,8 +323,9 @@ async function relayOnce(
   res: ServerResponse,
   connectorId: string,
   deps: RelayApiDeps,
-  signal: AbortSignal,
+  control: AbortController,
 ): Promise<void> {
+  const { signal } = control;
   const read = req.method === 'POST' ? await readCapped(req) : null;
   const dir = deps.migrationDir ?? agentsDir();
   if (isOrgRelayId(connectorId) || migrationSource(connectorId, dir)?.phase === 'active') return relayOrg(req, res, connectorId, deps, read, signal);
@@ -328,7 +336,8 @@ async function relayOnce(
       return;
     }
     const out = await exchange(req, connectorId, deps, screened === null ? read : screened.forward, signal, operation.dispatch);
-    await deliver(res, connectorId, deps, out, screened?.answers ?? []);
+    const listener = out.kind === 'response' ? passiveRelayListener(req, res, out.upstream, operation, () => { control.abort(); }) : undefined;
+    await deliver(res, connectorId, deps, out, screened?.answers ?? [], listener);
   });
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/connectors/server-keys.ts

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { writeSecure } from '@metro-labs/core/secure-fs';
+import { agentsDir } from '../agents/files.js';
+import { serverKeysOf, type PluginRow } from './plugin-sync.js';
+
+const invalid = (): Error => new Error('Invalid connector server keys. Restore the saved namespace mapping and initialization marker.');
+
+function readKeys(path: string, marker: string): Map<string, string> | undefined {
+  try {
+    const marked = existsSync(marker);
+    if (marked && readFileSync(marker, 'utf8') !== '1\n') throw invalid();
+    if (!existsSync(path)) {
+      if (marked) throw invalid();
+      return undefined;
+    }
+    if (!marked) throw invalid();
+    return parseKeys(readFileSync(path, 'utf8'));
+  } catch { throw invalid(); }
+}
+
+function parseKeys(text: string): Map<string, string> {
+  const raw: unknown = JSON.parse(text);
+  if (!isRecord(raw) || raw.version !== 1 || !isRecord(raw.keys)) throw invalid();
+  const keys = new Map<string, string>();
+  const reserved = new Set<string>();
+  for (const [id, key] of Object.entries(raw.keys)) {
+    if (typeof key !== 'string' || !/^[a-z0-9-]+$/.test(key) || reserved.has(key)) throw invalid();
+    reserved.add(key);
+    keys.set(id, key);
+  }
+  return keys;
+}
+
+export function persistentServerKeys(rows: PluginRow[], dir = agentsDir(), published: PluginRow[] = rows): Map<string, string> {
+  const path = join(dir, 'connector-server-keys.json');
+  const marker = join(dir, 'connector-server-keys.initialized');
+  const saved = readKeys(path, marker);
+  const keys = serverKeysOf(rows, saved, published);
+  if (keys.size > 0 && keys.size !== saved?.size) {
+    if (saved === undefined) writeSecure(marker, '1\n');
+    writeSecure(path, `${JSON.stringify({ version: 1, keys: Object.fromEntries(keys) }, null, 2)}\n`);
+  }
+  return keys;
+}

package/runtime/node_modules/@metro-labs/daemon/src/connectors/store.ts

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import { closeSync, fsyncSync, openSync } from 'node:fs';
 import { publishLocalConnectors } from './publication.js';
+import { persistentServerKeys } from './server-keys.js';
 import { assertLocalMigrationEdit, localMigrationEnabled, localMigrationIdle, migrationSource, withLocalMigrationOperation } from './migration-guard.js';
 import type { FetchLike } from '@metro-labs/core/stations/oauth';
 import type { RelayTarget } from './relay-target.js';
@@ -116,6 +117,8 @@ export function readLocalConnectors(dir = agentsDir()): LocalConnectorRow[] {
 }
 
 function writeRows(dir: string, rows: LocalConnectorRow[]): void {
+  persistentServerKeys(readLocalConnectors(dir), dir);
+  persistentServerKeys(rows, dir);
   writeSecure(filePath(dir), `${JSON.stringify({ version: 1, connectors: rows }, null, 2)}\n`);
   if (dir !== agentsDir()) return;
   publishLocalConnectors(rows);
@@ -130,7 +133,7 @@ function rowOrThrow(id: string, dir: string): LocalConnectorRow {
 }
 
 function replace(dir: string, row: LocalConnectorRow, refresh = false): Connector {
-  if (!refresh) assertLocalMigrationEdit(row.id, row.name, dir);
+  if (!refresh) assertLocalMigrationEdit(row.id, dir);
   writeRows(dir, readLocalConnectors(dir).map((r) => (r.id === row.id ? row : r)));
   return connectorFromRow(row);
 }
@@ -150,17 +153,17 @@ export function localImportConnectors(
   const fresh =
     mode === 'overwrite'
       ? rows
-      : rows.filter((row) => !current.some((r) => r.id === row.id || r.name === row.name));
+      : rows.filter((row) => !current.some((r) => r.id === row.id));
   const imported: LocalConnectorRow[] = fresh.map((row) => ({
     id: row.id,
     name: row.name,
     url: row.url,
     config: readConfig(row.config),
   }));
-  for (const row of imported) assertLocalMigrationEdit(row.id, row.name, dir);
+  for (const row of imported) assertLocalMigrationEdit(row.id, dir);
   const ids = new Set(imported.map((r) => r.id));
-  const names = new Set(imported.map((r) => r.name));
-  writeRows(dir, [...current.filter((r) => !ids.has(r.id) && !names.has(r.name)), ...imported]);
+  if (ids.size !== imported.length) throw new ConnectorError('The import contains duplicate connector IDs.', 400);
+  writeRows(dir, [...current.filter((r) => !ids.has(r.id)), ...imported]);
   return imported.length;
 }
 
@@ -172,14 +175,7 @@ export async function localGetConnector(id: string, dir = agentsDir()): Promise<
   return Promise.resolve(connectorFromRow(rowOrThrow(id, dir)));
 }
 
-function assertNameFree(name: string, exceptId: string | null, dir: string): void {
-  if (readLocalConnectors(dir).some((r) => r.id !== exceptId && r.name === name))
-    throw new ConnectorError(`a connector named '${name}' already exists on this daemon`, 409);
-}
-
 function insert(dir: string, name: string, url: URL, config: ConnectorConfig): Connector {
-  assertLocalMigrationEdit('', name, dir);
-  assertNameFree(name, null, dir);
   const row: LocalConnectorRow = { id: newId(), name, url: connectorUrlText(url), config };
   writeRows(dir, [...readLocalConnectors(dir), row]);
   return connectorFromRow(row);
@@ -193,7 +189,7 @@ export async function localCreateConnector(input: ConnectorInput, dir = agentsDi
   return withLocalMigrationOperation('', dir, async (operation) => {
     const verified = stamp(await verifyRemoteMcp(url, auth, operation.fetch));
     return insert(dir, name, url, { auth, createdAt: new Date().toISOString(), verified, oauth: await oauthCapable(url, auth, operation.fetch), client });
-  }, true, name);
+  }, true);
 }
 
 export async function localCreatePendingConnector(input: PendingConnectorInput, dir = agentsDir()): Promise<Connector> {
@@ -309,13 +305,12 @@ export async function loadConnectorPolicies(dir = agentsDir()): Promise<void> {
 export async function localRenameConnector(id: string, raw: string, dir = agentsDir()): Promise<Connector> {
   const name = connectorName(raw);
   const row = rowOrThrow(id, dir);
-  assertNameFree(name, id, dir);
   return Promise.resolve(replace(dir, { ...row, name }));
 }
 
 export async function localDeleteConnector(id: string, dir = agentsDir()): Promise<DeletedConnector> {
   const row = rowOrThrow(id, dir);
-  assertLocalMigrationEdit(id, row.name, dir);
+  assertLocalMigrationEdit(id, dir);
   writeRows(dir, readLocalConnectors(dir).filter((r) => r.id !== id));
   return Promise.resolve({ id: row.id, name: row.name });
 }

package/runtime/node_modules/@metro-labs/daemon/src/connectors/transfer-store.ts

@@ -6,7 +6,7 @@ import { connectorAuth, connectorName } from '@metro-labs/http/connector-input';
 import { readConfig } from './config.js';
 import { parseConnectorUrl } from '@metro-labs/http/connector-url';
 import { normalizePolicy } from '../policy/policy.js';
-import { localImportConnectors, readLocalConnectors, type LocalConnectorRow } from './store.js';
+import { localImportConnectors, type LocalConnectorRow } from './store.js';
 
 export interface ConnectorCopyResult {
   sourceId: string | null;
@@ -28,7 +28,6 @@ function copyRow(raw: unknown): LocalConnectorRow {
 export function copyConnectorRows(value: unknown, dir?: string): ConnectorCopyResult[] {
   if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.connectors) || value.connectors.length > 500)
     throw new ApiError('invalid connector transfer', 400);
-  const names = new Set(readLocalConnectors(dir).map((row) => row.name));
   const imported: LocalConnectorRow[] = [];
   const results: ConnectorCopyResult[] = value.connectors.map((raw: unknown) => {
     const sourceId = isRecord(raw) && typeof raw.id === 'string' ? parseId(raw.id) : null;
@@ -38,8 +37,6 @@ export function copyConnectorRows(value: unknown, dir?: string): ConnectorCopyRe
     } catch {
       return { sourceId, status: 'invalid' };
     }
-    if (names.has(row.name)) return { sourceId, status: 'skipped' };
-    names.add(row.name);
     const id = newId();
     imported.push({ ...row, id });
     return { sourceId, id, status: 'copied' };

package/runtime/node_modules/@metro-labs/daemon/src/mcp/permission-prompt.ts

@@ -1,6 +1,6 @@
 import { str } from '@metro-labs/core/str';
 import { readPreview, shownValue } from '../approvals/preview.js';
-import { connectorToolOf } from '../connectors/gates.js';
+import { connectorGates, connectorToolOf } from '../connectors/gates.js';
 import { stationByName } from '../stations/registry.js';
 import { stationOfAccount } from './read-tool.js';
 
@@ -92,7 +92,11 @@ function bodyLines(params: PermissionParams): string[] {
   const raw = params.input_preview.trim() === '' ? [] : [shorten(params.input_preview, RAW_MAX)];
   if (metro !== undefined) return input === undefined ? [`Approval needed: ${metro}`, ...raw] : metroLines(metro, input);
   const connector = connectorToolOf(params.tool_name);
-  if (connector !== undefined) return connectorLines(connector.gate.name, connector.tool, input);
+  if (connector !== undefined) {
+    const { gate, tool } = connector;
+    const duplicate = connectorGates().some((entry) => entry.id !== gate.id && entry.name === gate.name);
+    return connectorLines(duplicate ? `${gate.name} (${gate.id})` : gate.name, tool, input);
+  }
   return [`Claude wants to run ${params.tool_name}: ${shorten(params.description)}`, '', ...raw];
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/mcp/policy-gate.ts

@@ -4,7 +4,6 @@ import { accountFromLine, knownAccounts } from '../agents/map.js';
 import { policyFor, storedPolicy, strictest, type Access, type PolicyTarget } from '../policy/policy.js';
 import { errResult } from './ctx.js';
 import { NEEDS_APPROVAL, takeGrant } from '../approvals/pending.js';
-import { connectorToolOf } from '../connectors/gates.js';
 import { profileScopeLine } from './profile-lookup.js';
 import { stationOfAccount } from './read-tool.js';
 import { stationForTool, toolGroupOf } from './tool-catalog.js';
@@ -56,7 +55,7 @@ export function channelDecision(name: string, a: Record<string, unknown>): Polic
   return verdict;
 }
 
-const isChannelTool = (name: string) => (tool: string): boolean => tool.endsWith(`__${name}`) && connectorToolOf(tool) === undefined;
+const isChannelTool = (name: string) => (tool: string): boolean => tool === `mcp__metro__${name}`;
 
 export function policyGate(name: string, a: Record<string, unknown>): ToolResult | undefined {
   const { access, target } = channelDecision(name, a);

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.292"
+  "version": "0.1.0-beta.293"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.292",
+  "version": "0.1.0-beta.293",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",