@stage-labs/metro 0.1.0-beta.302 → 0.1.0-beta.304

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

@@ -1,28 +1,16 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-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';
-import { agentsDir } from '../agents/files.js';
-import { migrationRequestEffectful, type MigrationOperation } from './migration-operations.js';
 import { ApiError } from '@metro-labs/http/api-error';
-import { errMsg, log } from '@metro-labs/core/log';
-import { answerBlocked, mergeBlocked, screenCalls, type BlockedReason } from './relay-policy.js';
+import { log } from '@metro-labs/core/log';
+import { answerBlocked, mergeBlocked } from './relay-policy.js';
 
 export interface RelayApiDeps {
-  migrationDir?: string;
-  target: (connectorId: string, force: boolean) => Promise<RelayTarget>;
   identify: (req: IncomingMessage) => { subject: string; agentId: string } | null;
-  signedOut: (connectorId: string) => void;
-  blocked?: BlockedReason;
-  open?: (connectorId: string) => RelaySession | Promise<RelaySession> | null;
+  open: (connectorId: string) => RelaySession | Promise<RelaySession>;
 }
 
-const ID_PATH_RE = /^\/relay\/((?:org-)?[A-Za-z0-9][A-Za-z0-9_-]{10})$/;
+const ID_PATH_RE = /^\/relay\/(org-[A-Za-z0-9][A-Za-z0-9_-]{10})$/;
 const METHODS = new Set(['POST', 'GET', 'DELETE']);
 const RELAY_BODY_MAX = 8 * 1024 * 1024;
 const FIRST_BYTE_MS = 120_000;
@@ -43,8 +31,7 @@ const PASS_RES = [
 const keepaliveMs = (): number =>
   Number(process.env.METRO_RELAY_KEEPALIVE_MS) || 25_000;
 
-const reconnectUrl = (id: string): string =>
-  `https://metro.box/#/connector/${id}`;
+const isRelaySse = (contentType: string | undefined): boolean => /^text\/event-stream\s*(?:;|$)/i.test(contentType ?? '');
 
 function answer(
   res: ServerResponse,
@@ -56,13 +43,6 @@ function answer(
   res.end(JSON.stringify(body));
 }
 
-const signinAnswer = (res: ServerResponse, id: string): void => {
-  answer(res, 424, {
-    error: 'this connector needs signing in again',
-    reconnect: reconnectUrl(id),
-  });
-};
-
 function closeIfBodyUnread(req: IncomingMessage, res: ServerResponse): void {
   if (req.readableEnded) return;
   const drop = (): void => {
@@ -108,10 +88,9 @@ async function forward(
   target: { url: string; headers: Record<string, string> },
   body: Uint8Array<ArrayBuffer> | null,
   signal: AbortSignal,
-  sensitive = false,
 ): Promise<Response> {
   const firstByte = setTimeout(() => {
-    log.warn(sensitive ? {} : { url: target.url }, 'relay: upstream sent no response in time');
+    log.warn('relay: upstream sent no response in time');
   }, FIRST_BYTE_MS);
   firstByte.unref?.();
   try {
@@ -132,12 +111,12 @@ interface Keepalive {
   stop: () => void;
 }
 
-function startKeepalive(res: ServerResponse, listener?: PassiveSseListener): Keepalive {
+function startKeepalive(res: ServerResponse): Keepalive {
   let timer: ReturnType<typeof setTimeout> | undefined;
   const arm = (): void => {
     timer = setTimeout(() => {
       try {
-        if (listener?.keepaliveAllowed() !== false) res.write(': keepalive\n\n');
+        res.write(': keepalive\n\n');
       } catch {
         log.debug('relay: keepalive write failed');
       }
@@ -173,17 +152,13 @@ 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;
   }
 }
 
@@ -196,7 +171,7 @@ function passedHeaders(upstream: Response): Record<string, string> {
   return headers;
 }
 
-async function pipe(res: ServerResponse, upstream: Response, answers: Record<string, unknown>[], listener?: PassiveSseListener): Promise<void> {
+async function pipe(res: ServerResponse, upstream: Response, answers: Record<string, unknown>[]): Promise<void> {
   const headers = passedHeaders(upstream);
   if (answers.length > 0 && (upstream.status === 200 || upstream.status === 202)) {
     await mergeBlocked(res, upstream, headers, answers);
@@ -210,46 +185,38 @@ async function pipe(res: ServerResponse, upstream: Response, answers: Record<str
     res.end();
     return;
   }
-  const keepalive = sse ? startKeepalive(res, listener) : null;
+  const keepalive = sse ? startKeepalive(res) : null;
   try {
-    await pumpBody(res, upstream.body, () => keepalive?.touch(), listener);
+    await pumpBody(res, upstream.body, () => keepalive?.touch());
   } finally {
     keepalive?.stop();
   }
   res.end();
 }
 
-const authFailed = (status: number): boolean =>
-  status === 401 || status === 403;
-
-type Exchanged =
-  | { kind: 'response'; upstream: Response }
-  | { kind: 'missing' }
-  | { kind: 'signin' };
+async function deliver(res: ServerResponse, upstream: Response, answers: Record<string, unknown>[]): Promise<void> {
+  if (upstream.status >= 300 && upstream.status < 400) {
+    await upstream.body?.cancel();
+    answer(res, 502, { error: 'the connector redirected; metro does not follow' });
+    return;
+  }
+  await pipe(res, upstream, answers);
+}
 
-async function exchange(
+async function relayOnce(
   req: IncomingMessage,
+  res: ServerResponse,
   connectorId: string,
   deps: RelayApiDeps,
-  body: Uint8Array<ArrayBuffer> | null,
   signal: AbortSignal,
-  dispatch: MigrationOperation['dispatch'],
-): Promise<Exchanged> {
-  assertLocalMigrationUse(connectorId, deps.migrationDir);
-  const target = await deps.target(connectorId, false);
-  assertLocalMigrationUse(connectorId, deps.migrationDir);
-  if (target.kind !== 'ok') return { kind: target.kind };
-  let upstream = await dispatch(() => forward(req, target, body, signal), { effectful: migrationRequestEffectful(req.method, body) });
-  if (!authFailed(upstream.status)) return { kind: 'response', upstream };
-  await upstream.body?.cancel();
-  assertLocalMigrationUse(connectorId, deps.migrationDir);
-  const fresh = await deps.target(connectorId, true);
-  assertLocalMigrationUse(connectorId, deps.migrationDir);
-  if (fresh.kind !== 'ok') return { kind: 'signin' };
-  upstream = await dispatch(() => forward(req, fresh, body, signal), { effectful: migrationRequestEffectful(req.method, body) });
-  if (!authFailed(upstream.status)) return { kind: 'response', upstream };
-  await upstream.body?.cancel();
-  return { kind: 'signin' };
+): Promise<void> {
+  const read = req.method === 'POST' ? await readCapped(req) : null;
+  const session = await deps.open(connectorId);
+  try {
+    const out = await exchangeOrg(connectorId, session, read, signal, (target, body, guard) => forward(req, target, body, guard));
+    if (out.kind === 'blocked') answerBlocked(res, out.screened);
+    else await deliver(res, out.upstream, out.answers);
+  } finally { session.close(); }
 }
 
 async function relayExchange(
@@ -268,7 +235,7 @@ async function relayExchange(
     res.socket?.removeListener('close', bail);
   });
   try {
-    await relayOnce(req, res, connectorId, deps, control);
+    await relayOnce(req, res, connectorId, deps, control.signal);
   } catch (err) {
     if (!control.signal.aborted) throw err;
     log.debug({ connector: connectorId }, 'relay: the client left before the answer ended');
@@ -276,71 +243,6 @@ async function relayExchange(
   }
 }
 
-async function deliver(
-  res: ServerResponse,
-  connectorId: string,
-  deps: RelayApiDeps,
-  out: Exchanged,
-  answers: Record<string, unknown>[],
-  listener?: PassiveSseListener,
-): Promise<void> {
-  if (out.kind === 'missing') {
-    answer(res, 404, { error: 'no such connector' });
-    return;
-  }
-  if (out.kind === 'signin') {
-    noteHealth(connectorId, false, 'the sign-in has expired, connect it again');
-    deps.signedOut(connectorId);
-    signinAnswer(res, connectorId);
-    return;
-  }
-  if (out.upstream.status >= 300 && out.upstream.status < 400) {
-    await out.upstream.body?.cancel();
-    noteHealth(connectorId, false, 'the connector redirected; metro does not follow');
-    answer(res, 502, { error: 'the connector redirected; metro does not follow' });
-    return;
-  }
-  const { status } = out.upstream;
-  noteHealth(connectorId, status < 400, status < 400 ? null : `the connector answered ${String(status)}`);
-  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 = 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) => {
-      const send = () => forward(req, target, body, guard, true);
-      return session.dispatch?.(send, migrationRequestEffectful(req.method, body)) ?? send();
-    });
-    if (out.kind === 'blocked') answerBlocked(res, out.screened);
-    else await deliver(res, id, deps, out, out.answers);
-  } finally { session.close(); }
-}
-
-async function relayOnce(
-  req: IncomingMessage,
-  res: ServerResponse,
-  connectorId: string,
-  deps: RelayApiDeps,
-  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);
-  await withLocalMigrationOperation(connectorId, dir, async (operation) => {
-    const screened = read === null || deps.blocked === undefined ? null : screenCalls(read, connectorId, deps.blocked);
-    if (screened?.forward === null) {
-      answerBlocked(res, screened);
-      return;
-    }
-    const out = await exchange(req, connectorId, deps, screened === null ? read : screened.forward, signal, operation.dispatch);
-    const listener = out.kind === 'response' ? passiveRelayListener(req, res, out.upstream, operation, () => { control.abort(); }) : undefined;
-    await deliver(res, connectorId, deps, out, screened?.answers ?? [], listener);
-  });
-}
-
 function dispatch(
   req: IncomingMessage,
   res: ServerResponse,
@@ -354,19 +256,12 @@ function dispatch(
   }
   relayExchange(req, res, connectorId, deps)
     .catch((err: unknown) => {
-      if (err instanceof ApiError) {
-        answer(res, err.status, { error: err.message });
-        if (!res.writableEnded) res.end();
-      } else if (isOrgRelayId(connectorId)) {
+      if (err instanceof ApiError) answer(res, err.status, { error: err.message });
+      else {
         log.warn({ connector: connectorId }, 'organization relay: request failed');
         answer(res, 503, { error: 'The organization connector is unavailable. Try again.' });
-        if (!res.writableEnded) res.end();
-      } else {
-        log.warn({ err: errMsg(err), connector: connectorId }, 'relay: failed');
-        noteHealth(connectorId, false, `metro could not reach the connector: ${whyUnreachable(err)}`);
-        answer(res, 502, { error: `metro could not reach the connector: ${whyUnreachable(err)}` });
-        if (!res.writableEnded) res.end();
       }
+      if (!res.writableEnded) res.end();
       closeIfBodyUnread(req, res);
     });
 }

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

@@ -33,14 +33,27 @@ function parseKeys(text: string): Map<string, string> {
   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`);
-  }
+const sameKeys = (a: ReadonlyMap<string, string>, b: ReadonlyMap<string, string>): boolean =>
+  a.size === b.size && [...a].every(([id, key]) => b.get(id) === key);
+
+function serverKeyFiles(dir = agentsDir()): { path: string; marker: string } {
+  return { path: join(dir, 'connector-server-keys.json'), marker: join(dir, 'connector-server-keys.initialized') };
+}
+
+export function readServerKeys(dir = agentsDir()): Map<string, string> | undefined {
+  const { path, marker } = serverKeyFiles(dir);
+  return readKeys(path, marker);
+}
+
+export function writeServerKeys(keys: ReadonlyMap<string, string>, dir = agentsDir()): void {
+  const { path, marker } = serverKeyFiles(dir);
+  if (!existsSync(marker)) writeSecure(marker, '1\n');
+  writeSecure(path, `${JSON.stringify({ version: 1, keys: Object.fromEntries(keys) }, null, 2)}\n`);
+}
+
+export function persistentServerKeys(rows: PluginRow[], dir = agentsDir()): Map<string, string> {
+  const saved = readServerKeys(dir);
+  const keys = serverKeysOf(rows, saved);
+  if (saved === undefined ? keys.size > 0 : !sameKeys(saved, keys)) writeServerKeys(keys, dir);
   return keys;
 }

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

@@ -19,6 +19,7 @@ import { errMsg } from '@metro-labs/core/log';
 import { channelLog, type McpSession } from './session.js';
 import { SessionSlot } from './session-slot.js';
 import { connectCallBridge } from './call-bridge.js';
+import { connectServerApprovals } from './server-approvals.js';
 import { handleIncomingDiagnostic } from './diagnostics.js';
 
 const isInitialize = (b: unknown): boolean =>
@@ -120,6 +121,7 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
   const voiceSlot = new SessionSlot(false, 'voice');
   activeSlots = [slot, voiceSlot];
   connectCallBridge(() => slot.current);
+  connectServerApprovals(() => slot.current);
 
   const httpHandler = async (
     req: IncomingMessage,

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

@@ -75,15 +75,16 @@ function metroLines(tool: string, input: Record<string, unknown>): string[] {
 
 const ARGS_MAX = 8;
 
-function connectorLines(name: string, tool: string, input: Record<string, unknown> | undefined): string[] {
-  const lines = [`Approval needed: ${tool}`, `Connector: ${name}`];
+function argLines(input: Record<string, unknown> | undefined): string[] {
   const args = Object.entries(input ?? {}).flatMap(([key, value]) => {
     const text = argText(value);
     return text === undefined ? [] : [`${key}: ${shorten(text)}`];
   });
-  lines.push(...args.slice(0, ARGS_MAX));
-  if (args.length > ARGS_MAX) lines.push(`(${String(args.length - ARGS_MAX)} more)`);
-  return lines;
+  return args.length > ARGS_MAX ? [...args.slice(0, ARGS_MAX), `(${String(args.length - ARGS_MAX)} more)`] : args;
+}
+
+function connectorLines(name: string, tool: string, input: Record<string, unknown> | undefined): string[] {
+  return [`Approval needed: ${tool}`, `Connector: ${name}`, ...argLines(input)];
 }
 
 function bodyLines(params: PermissionParams): string[] {
@@ -100,9 +101,27 @@ function bodyLines(params: PermissionParams): string[] {
   return [`Claude wants to run ${params.tool_name}: ${shorten(params.description)}`, '', ...raw];
 }
 
-export function promptBody(params: PermissionParams): string {
-  const answer = `Reply "yes ${params.request_id}" or "no ${params.request_id}"`;
-  const body = bodyLines(params).join('\n');
+function withAnswer(requestId: string, lines: string[]): string {
+  const answer = `Reply "yes ${requestId}" or "no ${requestId}"`;
+  const body = lines.join('\n');
   const room = PROMPT_MAX - answer.length - 3;
   return `${body.length > room ? `${body.slice(0, room)}…` : body}\n\n${answer}`;
 }
+
+export function promptBody(params: PermissionParams): string {
+  return withAnswer(params.request_id, bodyLines(params));
+}
+
+export interface ServerPrompt {
+  requestId: string;
+  tool: string;
+  connector: string | undefined;
+  preview: string;
+}
+
+export function serverPromptBody(prompt: ServerPrompt): string {
+  const { input } = readPreview(prompt.preview);
+  const raw = prompt.preview.trim() === '' ? [] : [shorten(prompt.preview, RAW_MAX)];
+  const args = input === undefined ? raw : argLines(input);
+  return withAnswer(prompt.requestId, [`Approval needed: ${prompt.tool}`, ...(prompt.connector === undefined ? [] : [`Connector: ${prompt.connector}`]), ...args]);
+}

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

@@ -24,7 +24,7 @@ type PermissionRequest = z.infer<typeof PermissionRequestSchema>;
 
 const trainOf = (line: string): string => line.split('/')[2] ?? '';
 
-async function metroSend(line: string, text: string): Promise<void> {
+export async function metroSend(line: string, text: string): Promise<void> {
   await metroCall(trainOf(line), 'send', { line, text });
 }
 
@@ -36,15 +36,17 @@ export interface PermissionRelayDeps {
   log: (...a: unknown[]) => void;
 }
 
-const callChat = (deps: PermissionRelayDeps): string | undefined => {
+export type PromptLineDeps = Pick<PermissionRelayDeps, 'relay' | 'inScope' | 'live' | 'log'>;
+
+const callChat = (deps: PromptLineDeps): string | undefined => {
   const route = sharedCalls.snapshot();
   return route !== null && deps.inScope(route.line) ? route.line : undefined;
 };
 
-const ownerChat = (deps: PermissionRelayDeps, owner: OwnerLine | undefined): string | undefined =>
+const ownerChat = (deps: PromptLineDeps, owner: OwnerLine | undefined): string | undefined =>
   owner !== undefined && mayApprove(owner.line, owner.from) && deps.inScope(owner.line) && lineReceives(owner.line) ? owner.line : undefined;
 
-function relayLine(deps: PermissionRelayDeps, requestId: string, callLine?: string): string | undefined {
+export function relayLine(deps: PromptLineDeps, requestId: string, callLine?: string): string | undefined {
   if (!deps.live()) {
     deps.log('permission_request: live events are off, so no chat answer can arrive; held for the page only', requestId);
     return undefined;

package/runtime/node_modules/@metro-labs/daemon/src/mcp/server-approvals.ts

@@ -0,0 +1,109 @@
+import type { MetroEvent } from '@metro-labs/core/events';
+import { errMsg, log } from '@metro-labs/core/log';
+import type { McpApproval, McpDecision } from '@metro-labs/http/mcp-server-protocol';
+import { holdPrompt, isPromptHeld, type Behavior } from '../approvals/pending.js';
+import { ownerLine } from '../approvals/owner-line.js';
+import { metroNotice } from '../channels/notice.js';
+import { connectorGates } from '../connectors/gates.js';
+import { serverKey } from '../connectors/plugin-sync.js';
+import type { AnswerOutcome } from '../mcp-server/link.js';
+import { serverPromptBody } from './permission-prompt.js';
+import { metroSend, relayLine } from './permission-relay.js';
+import { channelLog, type McpSession } from './session.js';
+
+const RECENT_MS = 10 * 60_000;
+const RECENT_MAX = 1_000;
+
+const owner = {};
+const recent = new Map<string, number>();
+let current: () => McpSession | undefined = () => undefined;
+
+export function connectServerApprovals(session: () => McpSession | undefined): void {
+  current = session;
+}
+
+function promptLineFor(requestId: string): string | undefined {
+  const session = current();
+  if (session === undefined) return undefined;
+  return relayLine({ relay: session.relay, inScope: (line) => session.inScope(line), live: session.live, log: channelLog }, requestId);
+}
+
+const noticeLineFor = (line: string | undefined): string | undefined => line ?? current()?.relay.knownLine ?? ownerLine()?.line;
+
+function remember(id: string, now = Date.now()): void {
+  for (const [seen, at] of recent) if (now - at >= RECENT_MS) recent.delete(seen);
+  recent.set(id, now);
+  while (recent.size > RECENT_MAX) {
+    const oldest = recent.keys().next();
+    if (oldest.done) break;
+    recent.delete(oldest.value);
+  }
+}
+
+const answeredRecently = (id: string, now = Date.now()): boolean => now - (recent.get(id) ?? -Infinity) < RECENT_MS;
+
+function connectorName(key: string): string | undefined {
+  const names = new Set(connectorGates().filter((gate) => gate.server === key || serverKey(gate.name) === key).map((gate) => gate.name));
+  return names.size === 1 ? [...names][0] : undefined;
+}
+
+const noticeText = (tool: string, id: string, behavior: Behavior): string =>
+  behavior === 'allow' ? `Approved: ${tool} (${id}). Call call_tool again with the same arguments and approval: "${id}".` : `Denied: ${tool} (${id}).`;
+
+const requestedAt = (at: number, now = Date.now()): number => (Number.isFinite(at) && at > 0 ? Math.min(at, now) : now);
+
+interface Held {
+  id: string;
+  tool: string;
+  line: string | undefined;
+  answer: (decision: McpDecision) => Promise<AnswerOutcome>;
+  publish: (event: MetroEvent) => void;
+}
+
+async function deliver(held: Held, behavior: Behavior): Promise<void> {
+  const outcome = await held.answer(behavior);
+  if (outcome !== 'acknowledged') {
+    log.info({ id: held.id, outcome }, 'mcp-server: the answer was not taken, so the agent is not told');
+    return;
+  }
+  const line = noticeLineFor(held.line);
+  if (line === undefined) {
+    log.warn({ id: held.id }, 'mcp-server: no chat is known to tell the agent the answer');
+    return;
+  }
+  held.publish(metroNotice(line, noticeText(held.tool, held.id, behavior)));
+}
+
+function sender(held: Held): (behavior: Behavior) => Promise<void> {
+  return (behavior) => {
+    remember(held.id);
+    deliver(held, behavior).catch((err: unknown) => {
+      log.warn({ id: held.id, err: errMsg(err) }, 'mcp-server: the answer could not be delivered');
+    });
+    return Promise.resolve();
+  };
+}
+
+export function holdServerApproval(approval: McpApproval, answer: Held['answer'], publish: Held['publish']): boolean {
+  if (isPromptHeld(approval.id) || answeredRecently(approval.id)) return false;
+  const tool = `${approval.connector}.${approval.tool}`;
+  const name = connectorName(approval.connector);
+  const line = promptLineFor(approval.id);
+  const held: Held = { id: approval.id, tool, line, answer, publish };
+  holdPrompt(
+    { requestId: approval.id, tool, description: name ?? approval.connector, preview: approval.preview, line, at: requestedAt(approval.requestedAt), origin: 'mcp-server' },
+    owner,
+    sender(held),
+    line === undefined ? undefined : async (text) => metroSend(line, text),
+  );
+  log.info({ id: approval.id, tool, inChat: line !== undefined }, 'mcp-server: an approval is waiting for the owner');
+  if (line !== undefined)
+    metroSend(line, serverPromptBody({ requestId: approval.id, tool, connector: name, preview: approval.preview })).catch((err: unknown) => {
+      log.warn({ id: approval.id, err: errMsg(err) }, 'mcp-server: the approval prompt could not be posted');
+    });
+  return true;
+}
+
+export function forgetServerApprovals(): void {
+  recent.clear();
+}

package/runtime/node_modules/@metro-labs/daemon/src/mcp-server/config.ts

@@ -0,0 +1,29 @@
+import { log } from '@metro-labs/core/log';
+
+export const MCP_SERVER_KEY = 'mcp';
+
+const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]']);
+
+let refused: string | undefined;
+
+function usable(raw: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    return false;
+  }
+  const secure = url.protocol === 'https:' || (url.protocol === 'http:' && LOOPBACK.has(url.hostname));
+  return secure && url.username === '' && url.password === '' && url.search === '' && url.hash === '';
+}
+
+export function mcpServerUrl(env: NodeJS.ProcessEnv = process.env): string | null {
+  const raw = env.METRO_MCP_SERVER_URL?.trim() ?? '';
+  if (raw === '') return null;
+  if (usable(raw)) return raw.replace(/\/+$/, '');
+  if (refused !== raw) {
+    refused = raw;
+    log.warn({ url: raw }, 'mcp-server: METRO_MCP_SERVER_URL must be an https url (http only on this machine), so it is ignored');
+  }
+  return null;
+}