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

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';
@@ -18,7 +19,7 @@ export interface RelayApiDeps {
   identify: (req: IncomingMessage) => { subject: string; agentId: string } | null;
   signedOut: (connectorId: string) => void;
   blocked?: BlockedReason;
-  open?: (connectorId: string) => RelaySession | null;
+  open?: (connectorId: string) => RelaySession | Promise<RelaySession> | null;
 }
 
 const ID_PATH_RE = /^\/relay\/((?:org-)?[A-Za-z0-9][A-Za-z0-9_-]{10})$/;
@@ -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,11 +302,11 @@ 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> {
-  const session = deps.open?.(id);
+  const session = await deps.open?.(id);
   if (session === undefined || session === null) throw new ApiError('Organization connector tools are not switched on yet.', 503);
   try {
     const out = await exchangeOrg(id, session, read, signal, (target, body, guard) => {
@@ -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/tools.ts

@@ -1,85 +1 @@
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import type { FetchLike } from '@metro-labs/core/stations/oauth';
-import { authHeaders, INITIALIZE, mcpPost, payloadOf, type ConnectorAuth } from '@metro-labs/http/connector-mcp';
-import { refused } from '@metro-labs/http/connector-url';
-
-export interface RemoteTool {
-  name: string;
-  title: string;
-  description: string;
-  readOnly: boolean;
-}
-
-const TIMEOUT_MS = 15_000;
-const MAX_PAGES = 10;
-
-function resultOf(text: string, contentType: string): Record<string, unknown> | null {
-  let parsed: unknown = null;
-  try {
-    parsed = JSON.parse(payloadOf(text, contentType));
-  } catch {
-    return null;
-  }
-  return isRecord(parsed) && isRecord(parsed.result) ? parsed.result : null;
-}
-
-async function rpc(url: URL, auth: ConnectorAuth, session: Map<string, string>, body: unknown, fetchImpl?: FetchLike): Promise<Record<string, unknown> | null> {
-  const res = await mcpPost(url, auth, body, { timeoutMs: TIMEOUT_MS, headers: Object.fromEntries(session), fetch: fetchImpl });
-  const id = res.headers.get('mcp-session-id');
-  if (id !== null && id !== '') session.set('mcp-session-id', id);
-  const text = await res.text().catch(() => '');
-  if (res.status === 401 || res.status === 403) throw refused(`${url.hostname} rejected the credential; connect it again`);
-  if (!res.ok) throw refused(`${url.hostname} answered ${String(res.status)}`);
-  return resultOf(text, res.headers.get('content-type') ?? '');
-}
-
-function toTool(raw: unknown): RemoteTool | null {
-  if (!isRecord(raw) || typeof raw.name !== 'string') return null;
-  const annotations = isRecord(raw.annotations) ? raw.annotations : {};
-  const title = typeof raw.title === 'string' && raw.title !== '' ? raw.title : raw.name;
-  return { name: raw.name, title, description: typeof raw.description === 'string' ? raw.description : '', readOnly: annotations.readOnlyHint === true };
-}
-
-async function endSession(url: URL, auth: ConnectorAuth, session: Map<string, string>, fetchImpl?: FetchLike): Promise<void> {
-  if (!session.has('mcp-session-id')) return;
-  try {
-    const send = fetchImpl ?? fetch;
-    const res = await send(url.toString(), { method: 'DELETE', redirect: 'manual', signal: AbortSignal.timeout(TIMEOUT_MS), headers: { ...authHeaders(auth), ...Object.fromEntries(session) } });
-    if (res.ok) await res.body?.pipeTo(new WritableStream<Uint8Array>());
-    else await res.body?.cancel();
-  } catch (err) {
-    log.debug(fetchImpl === undefined ? { host: url.hostname, err: errMsg(err) } : {}, 'connector-tools: the remote declined to end the session');
-  }
-}
-
-const toolsOf = (result: Record<string, unknown>): RemoteTool[] =>
-  Array.isArray(result.tools) ? result.tools.flatMap((raw: unknown) => toTool(raw) ?? []) : [];
-
-function nextCursor(result: Record<string, unknown>, current: string): string | null {
-  const next = result.nextCursor;
-  return typeof next !== 'string' || next === '' || next === current ? null : next;
-}
-
-async function walkTools(url: URL, auth: ConnectorAuth, session: Map<string, string>, fetchImpl?: FetchLike): Promise<RemoteTool[]> {
-  const tools: RemoteTool[] = [];
-  let cursor: string | null = '';
-  for (let page = 0; page < MAX_PAGES && cursor !== null; page += 1) {
-    const result = await rpc(url, auth, session, { jsonrpc: '2.0', id: 2 + page, method: 'tools/list', params: cursor === '' ? {} : { cursor } }, fetchImpl);
-    if (result === null) break;
-    tools.push(...toolsOf(result));
-    cursor = nextCursor(result, cursor);
-  }
-  return tools;
-}
-
-export async function listRemoteTools(url: URL, auth: ConnectorAuth, fetchImpl?: FetchLike): Promise<RemoteTool[]> {
-  const session = new Map<string, string>();
-  const init = await rpc(url, auth, session, INITIALIZE, fetchImpl);
-  if (init === null || typeof init.protocolVersion !== 'string') throw refused(`${url.hostname} answered, but it does not speak MCP.`);
-  session.set('mcp-protocol-version', init.protocolVersion);
-  await rpc(url, auth, session, { jsonrpc: '2.0', method: 'notifications/initialized' }, fetchImpl);
-  const tools = await walkTools(url, auth, session, fetchImpl);
-  await endSession(url, auth, session, fetchImpl);
-  return tools;
-}
+export { listRemoteTools, type RemoteTool } from '@metro-labs/http/connector-tools';

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/node_modules/@metro-labs/http/package.json

@@ -18,6 +18,7 @@
     "./connector-resource": "./src/connector-resource.ts",
     "./connector-reach": "./src/connector-reach.ts",
     "./connector-mcp": "./src/connector-mcp.ts",
+    "./connector-tools": "./src/connector-tools.ts",
     "./connector-discovery": "./src/connector-discovery.ts",
     "./connector-oauth": "./src/connector-oauth.ts",
     "./connector-input": "./src/connector-input.ts",

package/runtime/node_modules/@metro-labs/http/src/connector-delivery-validation.ts

@@ -1,7 +1,7 @@
 import { parseId } from '@metro-labs/core/ids';
 import { isRecord } from '@metro-labs/core/is-record';
 import { connectorName } from './connector-input.js';
-import { connectorPolicyOf, type ConnectorPolicy } from './connector-policy.js';
+import { connectorPolicyLayersOf, connectorPolicyOf, type ConnectorPolicy, type ConnectorPolicyLayers } from './connector-policy.js';
 import { parsePublicConnectorUrl } from './connector-public-url.js';
 import { isOrganizationId } from './workos-token.js';
 
@@ -23,6 +23,7 @@ export interface DeliveredConnector {
   auth: 'none' | 'header' | 'oauth';
   headers: Record<string, string>;
   policy: ConnectorPolicy;
+  policyLayers?: ConnectorPolicyLayers;
   revision: string;
   state: 'ready' | 'signin' | 'unavailable';
   expiresAt?: number;
@@ -91,7 +92,7 @@ function urlOf(value: unknown): string {
 }
 
 function connectorOf(raw: unknown): DeliveredConnector {
-  const value = deliveryRecord(raw, ['id', 'name', 'url', 'auth', 'headers', 'policy', 'revision', 'state', 'expiresAt']);
+  const value = deliveryRecord(raw, ['id', 'name', 'url', 'auth', 'headers', 'policy', 'policyLayers', 'revision', 'state', 'expiresAt']);
   const id = parseId(value.id);
   if (id === null || typeof value.name !== 'string' || connectorName(value.name) !== value.name) throw new Error('Invalid delivered connector.');
   const url = urlOf(value.url);
@@ -99,7 +100,7 @@ function connectorOf(raw: unknown): DeliveredConnector {
   const state = stateOf(value.state, auth);
   deliveryBytes(value.revision, 32);
   if (Object.hasOwn(value, 'expiresAt') && !timestamp(value.expiresAt)) throw new Error('Invalid delivered connector expiry.');
-  return { id, name: value.name, url, auth, state, revision: String(value.revision), headers: headersOf(value.headers, auth, state), policy: connectorPolicyOf(value.policy), ...(timestamp(value.expiresAt) ? { expiresAt: value.expiresAt } : {}) };
+  return { id, name: value.name, url, auth, state, revision: String(value.revision), headers: headersOf(value.headers, auth, state), policy: connectorPolicyOf(value.policy), ...(Object.hasOwn(value, 'policyLayers') ? { policyLayers: connectorPolicyLayersOf(value.policyLayers) } : {}), ...(timestamp(value.expiresAt) ? { expiresAt: value.expiresAt } : {}) };
 }
 
 export function deliverySnapshotOf(raw: unknown): DeliverySnapshot {

package/runtime/node_modules/@metro-labs/http/src/connector-delivery.ts

@@ -2,8 +2,8 @@ import type { KeyObject } from 'node:crypto';
 import { CONNECTOR_DELIVERY_MAX_BYTES, DELIVERY_PLAINTEXT_MAX, deliveryContextBytes, deliverySnapshotOf, type DeliveryContext, type DeliverySnapshot } from './connector-delivery-validation.js';
 import { openTransfer, sealTransfer, type SealedTransfer } from './transfer-crypto.js';
 
-export { CONNECTOR_DELIVERY_LEASE_MS, CONNECTOR_DELIVERY_MAX_BYTES, deliverySnapshotOf, type DeliveryContext, type DeliverySnapshot, type DeliveredConnector } from './connector-delivery-validation.js';
-export { combineConnectorPolicies, connectorPolicyOf, type ConnectorPolicy } from './connector-policy.js';
+export { CONNECTOR_DELIVERY_LEASE_MS, CONNECTOR_DELIVERY_MAX_BYTES, DELIVERY_PLAINTEXT_MAX, deliverySnapshotOf, type DeliveryContext, type DeliverySnapshot, type DeliveredConnector } from './connector-delivery-validation.js';
+export { combineConnectorPolicies, connectorPolicyOf, effectiveConnectorPolicy, connectorPoliciesBlocked, validConnectorToolName, type ConnectorPolicy, type ConnectorPolicyLayers } from './connector-policy.js';
 export type SealedDelivery = SealedTransfer;
 
 export function sealConnectorDelivery(publicKey: string, context: DeliveryContext, snapshot: DeliverySnapshot): SealedDelivery {

package/runtime/node_modules/@metro-labs/http/src/connector-policy.ts

@@ -2,15 +2,24 @@ import { isRecord } from '@metro-labs/core/is-record';
 
 export type ConnectorDecision = 'allow' | 'ask' | 'deny';
 
+type ToolGroup = 'read' | 'write';
+
 export interface ConnectorPolicy {
   read?: ConnectorDecision;
   write?: ConnectorDecision;
   tools?: Record<string, ConnectorDecision>;
 }
 
+export interface ConnectorPolicyLayers {
+  organization: ConnectorPolicy;
+  agent: ConnectorPolicy;
+}
+
 const RANK: Record<ConnectorDecision, number> = { allow: 0, ask: 1, deny: 2 };
 const TOOL_RE = /^[A-Za-z0-9_.:/-]{1,256}$/;
 
+export const validConnectorToolName = (name: string): boolean => TOOL_RE.test(name) && !['__proto__', 'constructor', 'prototype'].includes(name);
+
 const decision = (value: unknown): value is ConnectorDecision => value === 'allow' || value === 'ask' || value === 'deny';
 
 export function connectorPolicyOf(value: unknown): ConnectorPolicy {
@@ -30,15 +39,23 @@ function toolPolicyOf(value: unknown): Record<string, ConnectorDecision> {
   if (!isRecord(value) || Object.keys(value).length > 2000) throw new Error('Invalid connector policy.');
   const out: Record<string, ConnectorDecision> = {};
   for (const [name, rule] of Object.entries(value)) {
-    if (!TOOL_RE.test(name) || ['__proto__', 'constructor', 'prototype'].includes(name) || !decision(rule)) throw new Error('Invalid connector policy.');
+    if (!validConnectorToolName(name) || !decision(rule)) throw new Error('Invalid connector policy.');
     out[name] = rule;
   }
   return out;
 }
 
+export function connectorPolicyLayersOf(value: unknown): ConnectorPolicyLayers {
+  if (!isRecord(value) || Object.keys(value).some((key) => !['organization', 'agent'].includes(key))) throw new Error('Invalid connector policy layers.');
+  return { organization: connectorPolicyOf(value.organization), agent: connectorPolicyOf(value.agent) };
+}
+
 const strictest = (...values: (ConnectorDecision | undefined)[]): ConnectorDecision => values.reduce<ConnectorDecision>((held, next) => next !== undefined && RANK[next] > RANK[held] ? next : held, 'allow');
+const toolRule = (policy: ConnectorPolicy, name: string): ConnectorDecision | undefined => policy.tools !== undefined && Object.hasOwn(policy.tools, name) ? policy.tools[name] : undefined;
+const toolGroup = (groups: Record<string, ToolGroup>, name: string): ToolGroup => Object.hasOwn(groups, name) && groups[name] === 'read' ? 'read' : 'write';
+const access = (policy: ConnectorPolicy, name: string, group: ToolGroup): ConnectorDecision => toolRule(policy, name) ?? policy[group] ?? 'allow';
 
-export function combineConnectorPolicies(global: ConnectorPolicy, assignment: ConnectorPolicy): ConnectorPolicy {
+export function combineConnectorPolicies(global: ConnectorPolicy, assignment: ConnectorPolicy, groups?: Record<string, ToolGroup>): ConnectorPolicy {
   const policies = [connectorPolicyOf(global), connectorPolicyOf(assignment)];
   const neutral = (policy: ConnectorPolicy): boolean => (policy.read ?? 'allow') === 'allow' && (policy.write ?? 'allow') === 'allow' && Object.keys(policy.tools ?? {}).length === 0;
   if (neutral(assignment)) return connectorPolicyOf(global);
@@ -48,9 +65,28 @@ export function combineConnectorPolicies(global: ConnectorPolicy, assignment: Co
     write: strictest(...policies.map((policy) => policy.write)),
   };
   const names = new Set(policies.flatMap((policy) => Object.keys(policy.tools ?? {})));
+  if (groups === undefined && names.size > 2000) return { read: 'deny', write: 'deny' };
   if (names.size > 0) {
     out.tools = {};
-    for (const name of names) out.tools[name] = strictest(...policies.flatMap((policy) => [policy.read, policy.write, policy.tools?.[name]]));
+    for (const name of names) {
+      out.tools[name] = groups === undefined
+        ? strictest(...policies.flatMap((policy) => [policy.read, policy.write, toolRule(policy, name)]))
+        : strictest(...policies.map((policy) => access(policy, name, toolGroup(groups, name))));
+    }
   }
   return out;
 }
+
+export function effectiveConnectorPolicy(row: { policy: ConnectorPolicy; policyLayers?: ConnectorPolicyLayers }, groups: Record<string, ToolGroup>): ConnectorPolicy {
+  const layers = row.policyLayers;
+  return layers === undefined ? connectorPolicyOf(row.policy) : combineConnectorPolicies(layers.organization, layers.agent, groups);
+}
+
+export function connectorPoliciesBlocked(layers: ConnectorPolicyLayers): boolean {
+  const policies = [layers.organization, layers.agent];
+  const names = new Set(policies.flatMap((policy) => Object.keys(policy.tools ?? {})));
+  return (['read', 'write'] as const).every((group) =>
+    strictest(...policies.map((policy) => policy[group])) === 'deny' &&
+    [...names].every((name) => strictest(...policies.map((policy) => access(policy, name, group))) === 'deny'),
+  );
+}