@stage-labs/metro 0.1.0-beta.84 → 0.1.0-beta.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.84",
+  "version": "0.1.0-beta.87",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/node_modules/@metro-labs/daemon/src/agents/accounts-api.ts

@@ -1,5 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from '@metro-labs/core/log';
+import { normalizeAllowlist } from './allowlist.js';
+import type { RecentSender } from './senders.js';
 import { ApiError } from '@metro-labs/http/api-error';
 import {
   apiFailure,
@@ -63,13 +65,24 @@ export interface AccountApiDeps {
     accountId: string,
   ) => Promise<AccountRef>;
   syncStations: (station: StationName) => Promise<void>;
+  reloadAgents: () => Promise<void>;
+  setAllowlist: (
+    subject: string,
+    agentId: string,
+    station: StationName,
+    accountId: string,
+    allowlist: string[],
+  ) => Promise<string[]>;
+  recentSenders: (station: StationName, accountId: string) => RecentSender[];
 }
 
 export type AccountRoute =
   | { kind: 'start' }
   | { kind: 'session'; attachId: string }
   | { kind: 'step'; attachId: string }
-  | { kind: 'account'; station: StationName; accountId: string };
+  | { kind: 'account'; station: StationName; accountId: string }
+  | { kind: 'allowlist'; station: StationName; accountId: string }
+  | { kind: 'senders'; station: StationName; accountId: string };
 
 export const ATTACHABLE: string[] = [
   ...ATTACHABLE_STATIONS,
@@ -81,6 +94,8 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   session: ['GET', 'DELETE'],
   step: ['POST'],
   account: ['DELETE'],
+  allowlist: ['PUT'],
+  senders: ['GET'],
 };
 
 function twoSegmentRoute(head: string, tail: string): AccountRoute | null {
@@ -100,10 +115,17 @@ export function accountRoute(rest: string[]): AccountRoute | null {
       : ATTACH_ID_RE.test(head)
         ? { kind: 'session', attachId: head }
         : null;
+  if (rest.length === 3 && tail !== undefined) return accountSubRoute(head, tail, rest[2]);
   if (rest.length !== 2 || tail === undefined) return null;
   return twoSegmentRoute(head, tail);
 }
 
+function accountSubRoute(head: string, tail: string, sub: string | undefined): AccountRoute | null {
+  if (!isStationName(head) || (sub !== 'allowlist' && sub !== 'senders')) return null;
+  const accountId = parseAccountId(tail);
+  return accountId === null ? null : { kind: sub, station: head, accountId };
+}
+
 export function accountRouteAllows(
   route: AccountRoute,
   method: string | undefined,
@@ -242,6 +264,36 @@ async function handleDetach(
   });
 }
 
+async function applied(deps: AccountApiDeps): Promise<boolean> {
+  try {
+    await deps.reloadAgents();
+    return true;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'account-api: allowlist reload failed, the change lands at the next boot');
+    return false;
+  }
+}
+
+async function handleAllowlist(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  session: ApiSession,
+  agentId: string,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  const wanted = normalizeAllowlist(bodyField(await readJsonBody(req), 'allowlist'));
+  const allowlist = await deps.setAllowlist(session.subject, agentId, target.station, target.accountId, wanted);
+  log.info({ agentId, station: target.station, account: target.accountId, senders: allowlist.length }, 'account-api: allowlist set');
+  sendJson(req, res, 200, {
+    agentId,
+    station: target.station,
+    accountId: target.accountId,
+    allowlist,
+    activated: await applied(deps),
+  });
+}
+
 async function handleSession(
   req: IncomingMessage,
   res: ServerResponse,
@@ -292,6 +344,11 @@ async function dispatchRoute(
     );
   if (route.kind === 'step')
     return handleStep(req, res, deps, ownerOf(session, agentId), route.attachId);
+  if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, session, agentId, route);
+  if (route.kind === 'senders') {
+    sendJson(req, res, 200, { senders: deps.recentSenders(route.station, route.accountId) });
+    return;
+  }
   return handleDetach(req, res, deps, session, agentId, route);
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/agents/allowlist.ts

@@ -0,0 +1,37 @@
+import { ApiError } from '@metro-labs/http/api-error';
+
+export const EVERYONE = '*';
+const MAX_ENTRIES = 500;
+const MAX_LENGTH = 200;
+
+function hasControlChar(value: string): boolean {
+  for (const ch of value) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code < 0x20 || code === 0x7f) return true;
+  }
+  return false;
+}
+
+function senderId(entry: unknown): string {
+  if (typeof entry !== 'string') throw new ApiError('allowlist must be a list of sender ids', 400);
+  const value = entry.trim();
+  if (value.length > MAX_LENGTH || hasControlChar(value))
+    throw new ApiError(`a sender id is at most ${String(MAX_LENGTH)} plain characters`, 400);
+  return value;
+}
+
+export function normalizeAllowlist(raw: unknown): string[] {
+  if (!Array.isArray(raw)) throw new ApiError('allowlist must be a list of sender ids', 400);
+  if (raw.length > MAX_ENTRIES) throw new ApiError(`allowlist holds at most ${String(MAX_ENTRIES)} senders`, 400);
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const entry of raw) {
+    const value = senderId(entry);
+    if (value === EVERYONE) return [EVERYONE];
+    const key = value.toLowerCase();
+    if (key === '' || seen.has(key)) continue;
+    seen.add(key);
+    out.push(value);
+  }
+  return out.length === 0 ? [EVERYONE] : out;
+}

package/runtime/node_modules/@metro-labs/daemon/src/agents/file-admin.ts

@@ -310,6 +310,22 @@ export async function localAttachAccount(
   return Promise.resolve({ agentId, station, accountId });
 }
 
+export async function localSetAllowlist(
+  subject: string,
+  agentId: string,
+  station: StationName,
+  accountId: string,
+  allowlist: string[],
+  dir = agentsDir(),
+): Promise<string[]> {
+  const stored = ownedOrThrow(subject, agentId, dir);
+  const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
+  if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
+  account.allowlist = allowlist;
+  save(stored);
+  return Promise.resolve(allowlist);
+}
+
 export async function localDetachAccount(
   subject: string,
   agentId: string,

package/runtime/node_modules/@metro-labs/daemon/src/agents/map.ts

@@ -65,6 +65,10 @@ export function stationAgentIds(station: string): string[] {
     .map(([, id]) => id);
 }
 
+export function allowlistForAccount(station: string, accountId: string): string[] | undefined {
+  return allowlistMap[mapKey(station, accountId)];
+}
+
 export function allowlistForLine(line: string): string[] | undefined {
   const a = accountFromLine(line);
   return a ? allowlistMap[mapKey(a.station, a.accountId)] : undefined;

package/runtime/node_modules/@metro-labs/daemon/src/agents/senders.ts

@@ -0,0 +1,38 @@
+import { bufferedSince, type MetroEvent } from '@metro-labs/core/events';
+import { accountFromLine } from './map.js';
+
+export interface RecentSender {
+  id: string;
+  name: string;
+  at: string;
+}
+
+const DEFAULT_LIMIT = 20;
+
+const SKIP = new Set(['', 'self', 'unknown']);
+
+function sameAccount(from: string, station: string, accountId: string): boolean {
+  const account = accountFromLine(from);
+  return account?.station === station && account.accountId === accountId;
+}
+
+function senderOf(event: MetroEvent, station: string, accountId: string): { id: string; name: string } | null {
+  const from = String(event.from);
+  if (event.station !== station || !sameAccount(from, station, accountId)) return null;
+  const id = from.split('/').pop() ?? '';
+  if (SKIP.has(id)) return null;
+  return { id, name: event.fromDisplayName ?? event.fromName ?? '' };
+}
+
+export function recentSenders(station: string, accountId: string, limit = DEFAULT_LIMIT): RecentSender[] {
+  const seen = new Set<string>();
+  const out: RecentSender[] = [];
+  for (const { event } of bufferedSince(0).reverse()) {
+    const sender = senderOf(event, station, accountId);
+    if (sender === null || seen.has(sender.id.toLowerCase())) continue;
+    seen.add(sender.id.toLowerCase());
+    out.push({ ...sender, at: event.ts });
+    if (out.length >= limit) break;
+  }
+  return out;
+}

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

@@ -19,7 +19,10 @@ import {
   trainEventToMetroEvent,
 } from '../routes/http.js';
 import { localAgentKey } from '../stations/materialize.js';
-import { fileSource } from '../agents/files.js';
+import { agentsDir, fileSource } from '../agents/files.js';
+import { ConnectorAggregate } from '../connectors/aggregate.js';
+import { setConnectorToolProvider } from '../mcp/connector-tools.js';
+import { invalidateToolSchema } from '../mcp/tool-dispatch.js';
 import { applyLocalOwner } from './local-owner.js';
 import { localOwner } from '../agents/file-admin.js';
 import { ensureStationDeps } from '../stations/runtime-deps.js';
@@ -29,6 +32,7 @@ import {
   agentLiveness,
   closeAgentSession,
   createMetroMcp,
+  announceToolSchemaToAll,
 } from '../mcp/index.js';
 import { metroCall } from '../mcp/ctx.js';
 import { gatherAccountsForAgents } from '../mcp/accounts.js';
@@ -98,6 +102,9 @@ async function syncStations(station: StationName): Promise<void> {
 function sessionApis(): SessionApis {
   return localSessionApis({
       syncStations,
+      reloadAgents: async () => {
+        await reloadFrom(fileSource);
+      },
       restart: () => {
         exitCode = RESTART_EXIT;
         onShutdown();
@@ -114,6 +121,22 @@ function sessionApis(): SessionApis {
     });
 }
 
+let connectors: ConnectorAggregate | null = null;
+
+function startConnectors(): void {
+  const aggregate = new ConnectorAggregate(agentsDir(), () => {
+    invalidateToolSchema();
+    announceToolSchemaToAll();
+  });
+  connectors = aggregate;
+  setConnectorToolProvider({
+    list: () => aggregate.list(),
+    owns: (name) => aggregate.owns(name),
+    call: (name, args) => aggregate.call(name, args),
+  });
+  aggregate.start();
+}
+
 async function main(): Promise<void> {
   applyLocalOwner();
   await materializeFrom(fileSource, { allowEmpty: true });
@@ -126,6 +149,7 @@ async function main(): Promise<void> {
     metroCall,
   );
   metroMcp.startInbound();
+  startConnectors();
   startUploadReaper();
   announceLocalEndpoint();
   tunnel?.start();
@@ -145,6 +169,7 @@ async function shutdown(): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
   log.info('dispatcher shutting down');
+  connectors?.stop();
   tunnel?.stop();
   if (webhookServer) {
     const server = webhookServer;

package/runtime/node_modules/@metro-labs/daemon/src/claude/api.ts

@@ -4,6 +4,14 @@ import { apiFailure, apiSession, cors, readJsonBody, sendJson } from '@metro-lab
 import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
 import { listClaudeSettings, SETTINGS_MAX, writeClaudeSettings } from './settings.js';
+import {
+  createClaudeSkill,
+  deleteClaudeSkill,
+  listClaudeSkills,
+  readClaudeSkill,
+  skillHomes,
+  writeClaudeSkill,
+} from './skills.js';
 import {
   answerClaudeLogin,
   claudeAccount,
@@ -54,6 +62,10 @@ const COLLECTIONS: Record<string, Handler> = {
   sessions: (query, dir) => ({ sessions: listClaudeSessions(projectOf(query), dir) }),
   memory: (query, dir) => listMemory(projectOf(query), dir),
   settings: (_query, dir) => ({ files: listClaudeSettings(dir) }),
+  skills: (_query, dir) => ({
+    skills: listClaudeSkills(dir),
+    places: skillHomes(dir).map((home) => ({ id: home.prefix, scope: home.scope, where: home.where })),
+  }),
 };
 
 const ITEMS: Record<string, Handler> = {
@@ -62,17 +74,30 @@ const ITEMS: Record<string, Handler> = {
     return readTranscript(projectOf(query), id, offset, limit, dir);
   },
   memory: (query, dir, name) => ({ name, content: readMemoryFile(projectOf(query), name, dir) }),
+  skills: (_query, dir, id) => readClaudeSkill(decodeURIComponent(id), dir),
 };
 
 const parts = (path: string): string[] => path.slice(PREFIX.length + 1).split('/').filter(Boolean);
 
+const seenIn = (body: Record<string, unknown>): string | null | undefined =>
+  'seenAt' in body ? (typeof body.seenAt === 'string' ? body.seenAt : null) : undefined;
+
 async function writeAnswer(req: IncomingMessage, path: string, dir: string): Promise<unknown> {
   const [head = '', item = ''] = parts(path);
-  if (head !== 'settings' || item === '') throw new ApiError('method not allowed', 405);
+  if ((head !== 'settings' && head !== 'skills') || item === '') throw new ApiError('method not allowed', 405);
   const body = await readJsonBody(req, BODY_MAX);
   if (!isRecord(body) || typeof body.text !== 'string') throw new ApiError('text is required', 400);
-  const seenAt = 'seenAt' in body ? (typeof body.seenAt === 'string' ? body.seenAt : null) : undefined;
-  return writeClaudeSettings(item, body.text, seenAt, dir);
+  if (head === 'skills') return writeClaudeSkill(decodeURIComponent(item), body.text, seenIn(body), dir);
+  return writeClaudeSettings(item, body.text, seenIn(body), dir);
+}
+
+async function created(req: IncomingMessage, path: string, dir: string): Promise<unknown> {
+  const rest = parts(path);
+  if (rest.length !== 1 || rest[0] !== 'skills') throw new ApiError('method not allowed', 405);
+  const body = await readJsonBody(req, BODY_MAX);
+  if (!isRecord(body) || typeof body.name !== 'string') throw new ApiError('name is required', 400);
+  const scope = typeof body.scope === 'string' ? body.scope : undefined;
+  return createClaudeSkill(body.name, scope, typeof body.text === 'string' ? body.text : undefined, dir);
 }
 
 const LOGIN = 'login';
@@ -94,7 +119,9 @@ async function loginAnswer(req: IncomingMessage, id: string, deps: ClaudeApiDeps
 
 function removed(rest: string[], query: URLSearchParams, dir: string): unknown {
   const [head = '', item = ''] = rest;
-  if (rest.length !== 2 || head !== 'sessions') throw new ApiError('method not allowed', 405);
+  if (rest.length !== 2) throw new ApiError('method not allowed', 405);
+  if (head === 'skills') return { deleted: deleteClaudeSkill(decodeURIComponent(item), dir) };
+  if (head !== 'sessions') throw new ApiError('method not allowed', 405);
   deleteClaudeSession(projectOf(query), item, dir);
   return { deleted: item };
 }
@@ -132,6 +159,7 @@ export function handleClaudeRequest(
       const [head = '', item = ''] = parts(path);
       if (head === LOGIN) return loginAnswer(req, item, deps);
       if (req.method === 'PUT') return writeAnswer(req, path, dir);
+      if (req.method === 'POST') return created(req, path, dir);
       return answer(req.method ?? 'GET', path, new URLSearchParams(search), dir);
     })
     .then((body) => {

package/runtime/node_modules/@metro-labs/daemon/src/claude/skills.ts

@@ -0,0 +1,154 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { claudeDir, listClaudeProjects } from './files.js';
+
+export const SKILL_MAX = 256 * 1024;
+export const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const USER_SCOPE = 'user';
+const FILE = 'SKILL.md';
+const DEFAULT_MODE = 0o644;
+const SUMMARY_MAX = 300;
+
+export type SkillScope = 'user' | 'project';
+
+export interface ClaudeSkill {
+  id: string;
+  name: string;
+  title: string;
+  description: string;
+  scope: SkillScope;
+  where: string;
+  path: string;
+  editable: boolean;
+  updatedAt: string | null;
+}
+
+const frontmatterField = (text: string, field: string): string => {
+  const head = text.startsWith('---') ? text.slice(3, text.indexOf('\n---', 3)) : '';
+  for (const line of head.split('\n')) {
+    const at = line.indexOf(':');
+    if (at > 0 && line.slice(0, at).trim() === field) return line.slice(at + 1).trim().replace(/^["']|["']$/g, '').slice(0, SUMMARY_MAX);
+  }
+  return '';
+};
+
+function entryOf(id: string, name: string, scope: SkillScope, where: string, path: string): ClaudeSkill {
+  const stat = statSync(path);
+  const editable = stat.size <= SKILL_MAX;
+  const text = editable ? readFileSync(path, 'utf8') : '';
+  return {
+    id,
+    name,
+    title: frontmatterField(text, 'name') || name,
+    description: frontmatterField(text, 'description'),
+    scope,
+    where,
+    path,
+    editable,
+    updatedAt: stat.mtime.toISOString(),
+  };
+}
+
+function skillsIn(root: string, prefix: string, scope: SkillScope, where: string): ClaudeSkill[] {
+  if (!existsSync(root)) return [];
+  const out: ClaudeSkill[] = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !SKILL_NAME_RE.test(entry.name)) continue;
+    const path = join(root, entry.name, FILE);
+    if (existsSync(path)) out.push(entryOf(`${prefix}:${entry.name}`, entry.name, scope, where, path));
+  }
+  return out;
+}
+
+export const userSkillsRoot = (dir: string): string => join(dir, 'skills');
+
+export interface SkillHome {
+  prefix: string;
+  scope: SkillScope;
+  where: string;
+  root: string;
+}
+
+export function skillHomes(dir = claudeDir()): SkillHome[] {
+  const homes: SkillHome[] = [{ prefix: USER_SCOPE, scope: USER_SCOPE, where: 'This machine', root: userSkillsRoot(dir) }];
+  for (const project of listClaudeProjects(dir)) {
+    const cwd = project.cwd;
+    if (cwd === null || !existsSync(cwd)) continue;
+    homes.push({ prefix: project.id, scope: 'project', where: cwd, root: join(cwd, '.claude', 'skills') });
+  }
+  return homes;
+}
+
+export function listClaudeSkills(dir = claudeDir()): ClaudeSkill[] {
+  const out = skillHomes(dir).flatMap((home) => skillsIn(home.root, home.prefix, home.scope, home.where));
+  return out.sort((a, b) => (b.updatedAt ?? '').localeCompare(a.updatedAt ?? '') || a.name.localeCompare(b.name));
+}
+
+function found(id: string, dir: string): ClaudeSkill {
+  const skill = listClaudeSkills(dir).find((entry) => entry.id === id);
+  if (skill === undefined) throw new ApiError('no such skill', 404);
+  return skill;
+}
+
+export function readClaudeSkill(id: string, dir = claudeDir()): ClaudeSkill & { text: string } {
+  const skill = found(id, dir);
+  return { ...skill, text: skill.editable ? readFileSync(skill.path, 'utf8') : '' };
+}
+
+function writeAtomic(path: string, text: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.metro-${String(process.pid)}`;
+  writeFileSync(tmp, text, { mode: DEFAULT_MODE });
+  renameSync(tmp, path);
+}
+
+function assertText(text: string): void {
+  if (text.length > SKILL_MAX) throw new ApiError('that is more text than a skill may hold', 413);
+  if (text.trim() === '') throw new ApiError('a skill needs some text', 400);
+}
+
+export function writeClaudeSkill(
+  id: string,
+  text: string,
+  seenAt: string | null | undefined,
+  dir = claudeDir(),
+): ClaudeSkill {
+  const skill = found(id, dir);
+  if (!skill.editable) throw new ApiError('that skill is too large to edit here', 409);
+  assertText(text);
+  if (seenAt !== undefined && seenAt !== skill.updatedAt)
+    throw new ApiError('that skill changed on disk since you opened it; reload it before saving', 409);
+  writeAtomic(skill.path, text);
+  return entryOf(skill.id, skill.name, skill.scope, skill.where, skill.path);
+}
+
+export const skillTemplate = (name: string): string =>
+  ['---', `name: ${name}`, 'description: what this skill does, and when Claude should reach for it', '---', '', `# ${name}`, '', 'Write the instructions here.', ''].join('\n');
+
+export function createClaudeSkill(
+  name: string,
+  scope: string | undefined,
+  text: string | undefined,
+  dir = claudeDir(),
+): ClaudeSkill {
+  if (typeof name !== 'string' || !SKILL_NAME_RE.test(name))
+    throw new ApiError('a skill name is lowercase letters, digits and dashes, up to 64 characters', 400);
+  const prefix = scope === undefined || scope === '' ? USER_SCOPE : scope;
+  const home = skillHomes(dir).find((h) => h.prefix === prefix);
+  if (home === undefined) throw new ApiError('no such place to keep a skill', 404);
+  const path = join(home.root, name, FILE);
+  if (existsSync(path)) throw new ApiError('a skill by that name already lives there', 409);
+  const body = text === undefined || text.trim() === '' ? skillTemplate(name) : text;
+  assertText(body);
+  writeAtomic(path, body);
+  return entryOf(`${home.prefix}:${name}`, name, home.scope, home.where, path);
+}
+
+export function deleteClaudeSkill(id: string, dir = claudeDir()): string {
+  const skill = found(id, dir);
+  const folder = dirname(skill.path);
+  if (basename(folder) !== skill.name) throw new ApiError('that skill does not live in its own folder', 409);
+  rmSync(folder, { recursive: true, force: true });
+  return id;
+}

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

@@ -0,0 +1,199 @@
+import { watch, type FSWatcher } from 'node:fs';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import type { ToolResult } from '@metro-labs/core/stations/types';
+import { signInState } from './config.js';
+import type { RelayTarget } from './relay-target.js';
+import { localRelayTarget, readLocalConnectors, type LocalConnectorRow } from './store.js';
+import { UpstreamClient, type UpstreamTool } from './upstream.js';
+
+const SEP = '__';
+const SLUG_MAX = 24;
+const NAME_MAX = 64;
+const WATCH_DEBOUNCE_MS = 300;
+const CONNECTORS_FILE = 'connectors.json';
+
+export interface ConnectorToolView {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  annotations?: unknown;
+}
+
+interface Entry {
+  row: LocalConnectorRow;
+  stamp: string;
+  slug: string;
+  client: UpstreamClient;
+  tools: UpstreamTool[];
+}
+
+type TargetOf = (connectorId: string, force: boolean, dir: string) => Promise<RelayTarget>;
+
+export function slugOf(name: string): string {
+  const slug = name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, SLUG_MAX)
+    .replace(/_+$/, '');
+  return slug === '' ? 'connector' : slug;
+}
+
+const stampOf = (row: LocalConnectorRow): string =>
+  JSON.stringify([row.name, row.url, row.config.auth.kind, row.config.verified.at, row.config.oauth]);
+
+const toolName = (slug: string, tool: string): string => `${slug}${SEP}${tool}`.slice(0, NAME_MAX);
+
+const textBlock = (text: string): { type: 'text'; text: string } => ({ type: 'text', text });
+
+function blockOf(block: unknown): { type: 'text'; text: string } {
+  if (isRecord(block) && block.type === 'text' && typeof block.text === 'string') return textBlock(block.text);
+  const kind = isRecord(block) && typeof block.type === 'string' ? block.type : 'unknown';
+  return textBlock(`[${kind} block omitted by metro]`);
+}
+
+export function toToolResult(raw: unknown): ToolResult {
+  if (isRecord(raw) && Array.isArray(raw.content)) {
+    const content = raw.content.map(blockOf);
+    return raw.isError === true ? { content, isError: true } : { content };
+  }
+  return { content: [textBlock(JSON.stringify(raw ?? null))] };
+}
+
+function dedupeSlugs(entries: Map<string, Entry>): void {
+  const bySlug = new Map<string, Entry[]>();
+  for (const entry of entries.values()) bySlug.set(entry.slug, [...(bySlug.get(entry.slug) ?? []), entry]);
+  for (const group of bySlug.values()) {
+    if (group.length < 2) continue;
+    for (const entry of group) entry.slug = `${entry.slug}_${entry.row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}`;
+  }
+}
+
+export class ConnectorAggregate {
+  private entries = new Map<string, Entry>();
+  private watcher: FSWatcher | null = null;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private loading: Promise<void> | null = null;
+
+  constructor(
+    private readonly dir: string,
+    private readonly onChange: () => void,
+    private readonly targetOf: TargetOf = localRelayTarget,
+  ) {}
+
+  start(): void {
+    try {
+      this.watcher = watch(this.dir, (_event, file) => {
+        if (file === null || file === CONNECTORS_FILE) this.schedule();
+      });
+      this.watcher.on('error', (err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'connectors: watcher failed; tools refresh on the next daemon start');
+      });
+      this.watcher.unref();
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'connectors: could not watch the agents dir');
+    }
+    this.schedule(0);
+  }
+
+  stop(): void {
+    this.watcher?.close();
+    this.watcher = null;
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+  }
+
+  private schedule(ms = WATCH_DEBOUNCE_MS): void {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.reload().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'connectors: reload failed');
+      });
+    }, ms);
+    this.timer.unref();
+  }
+
+  reload(): Promise<void> {
+    this.loading ??= this.load().finally(() => {
+      this.loading = null;
+    });
+    return this.loading;
+  }
+
+  private async load(): Promise<void> {
+    const rows = readLocalConnectors(this.dir).filter((row) => signInState(row.config) !== 'disconnected');
+    const next = new Map<string, Entry>();
+    const jobs: Promise<void>[] = [];
+    for (const row of rows) {
+      const stamp = stampOf(row);
+      const kept = this.entries.get(row.id);
+      if (kept?.stamp === stamp && kept !== undefined) {
+        next.set(row.id, kept);
+        continue;
+      }
+      const entry: Entry = { row, stamp, slug: slugOf(row.name), client: new UpstreamClient((force) => this.targetOf(row.id, force, this.dir)), tools: [] };
+      next.set(row.id, entry);
+      jobs.push(this.fill(entry));
+    }
+    await Promise.all(jobs);
+    dedupeSlugs(next);
+    const before = this.signature();
+    this.entries = next;
+    if (this.signature() !== before) this.onChange();
+  }
+
+  private async fill(entry: Entry): Promise<void> {
+    try {
+      entry.tools = await entry.client.listTools();
+      log.info({ connector: entry.row.name, tools: entry.tools.length }, 'connectors: tools listed');
+    } catch (err) {
+      log.warn({ connector: entry.row.name, err: errMsg(err) }, 'connectors: tools not listed; the connector has no tools until it answers');
+    }
+  }
+
+  signature(): string {
+    return JSON.stringify([...this.entries.values()].map((e) => [e.row.id, e.slug, e.tools.map((t) => t.name)]).sort());
+  }
+
+  list(): ConnectorToolView[] {
+    const out: ConnectorToolView[] = [];
+    for (const entry of [...this.entries.values()].sort((a, b) => a.slug.localeCompare(b.slug)))
+      for (const tool of entry.tools)
+        out.push({
+          name: toolName(entry.slug, tool.name),
+          description: tool.description === '' ? `${entry.row.name}: ${tool.name}` : `${tool.description} (${entry.row.name})`,
+          inputSchema: tool.inputSchema,
+          ...(tool.annotations === undefined ? {} : { annotations: tool.annotations }),
+        });
+    return out;
+  }
+
+  private resolve(name: string): { entry: Entry; tool: UpstreamTool } | null {
+    const at = name.indexOf(SEP);
+    if (at <= 0) return null;
+    const slug = name.slice(0, at);
+    for (const entry of this.entries.values()) {
+      if (entry.slug !== slug) continue;
+      const tool = entry.tools.find((t) => toolName(slug, t.name) === name);
+      return tool === undefined ? null : { entry, tool };
+    }
+    return null;
+  }
+
+  owns(name: string): boolean {
+    return this.resolve(name) !== null;
+  }
+
+  async call(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+    const found = this.resolve(name);
+    if (found === null) return { content: [textBlock(`metro: no connector serves ${name}`)], isError: true };
+    try {
+      return toToolResult(await found.entry.client.callTool(found.tool.name, args));
+    } catch (err) {
+      log.warn({ connector: found.entry.row.name, tool: found.tool.name, err: errMsg(err) }, 'connectors: tool call failed');
+      return { content: [textBlock(`metro: connector ${found.entry.row.name} ${errMsg(err)}`)], isError: true };
+    }
+  }
+}

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

@@ -0,0 +1,172 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
+import type { RelayTarget } from './relay-target.js';
+
+const ACCEPT = 'application/json, text/event-stream';
+const PROTOCOL = '2025-11-25';
+const MAX_PAGES = 10;
+const LIST_MS = 15_000;
+const CALL_MS = 120_000;
+
+export interface UpstreamTool {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  annotations: unknown;
+}
+
+export type TargetOf = (force: boolean) => Promise<RelayTarget>;
+
+export class UpstreamRefused extends Error {}
+export class UpstreamFailed extends Error {}
+
+interface Live {
+  session: string | null;
+  protocol: string;
+}
+
+interface Answer {
+  status: number;
+  text: string;
+  contentType: string;
+  session: string | null;
+}
+
+function dataLines(text: string): string[] {
+  return text
+    .replace(/\r\n/g, '\n')
+    .split('\n')
+    .filter((line) => line.startsWith('data:'))
+    .map((line) => line.slice(5).trim());
+}
+
+function messageFor(answer: Answer, id: number): Record<string, unknown> | null {
+  const candidates = answer.contentType.includes('text/event-stream') ? dataLines(answer.text) : [answer.text];
+  for (const candidate of candidates) {
+    try {
+      const parsed: unknown = JSON.parse(candidate);
+      if (isRecord(parsed) && parsed.id === id) return parsed;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+function resultOf(answer: Answer, id: number): unknown {
+  const message = messageFor(answer, id);
+  if (message === null) throw new UpstreamFailed('answered without a result for the request');
+  if (isRecord(message.error)) {
+    const text = typeof message.error.message === 'string' ? message.error.message : JSON.stringify(message.error);
+    throw new UpstreamFailed(text);
+  }
+  return message.result;
+}
+
+const initializeBody = (id: number): unknown => ({
+  jsonrpc: '2.0',
+  id,
+  method: 'initialize',
+  params: { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: { name: 'metro', version: '0.1.0' } },
+});
+
+function toolOf(raw: unknown): UpstreamTool | null {
+  if (!isRecord(raw) || typeof raw.name !== 'string' || raw.name === '') return null;
+  return {
+    name: raw.name,
+    description: typeof raw.description === 'string' ? raw.description : '',
+    inputSchema: isRecord(raw.inputSchema) ? raw.inputSchema : { type: 'object' },
+    annotations: isRecord(raw.annotations) ? raw.annotations : undefined,
+  };
+}
+
+export class UpstreamClient {
+  private live: Live | null = null;
+  private seq = 0;
+
+  constructor(private readonly target: TargetOf) {}
+
+  forget(): void {
+    this.live = null;
+  }
+
+  async listTools(): Promise<UpstreamTool[]> {
+    const tools: UpstreamTool[] = [];
+    let cursor = '';
+    for (let page = 0; page < MAX_PAGES; page += 1) {
+      const result = await this.rpc('tools/list', cursor === '' ? {} : { cursor }, LIST_MS);
+      if (!isRecord(result)) break;
+      if (Array.isArray(result.tools)) for (const raw of result.tools) {
+        const tool = toolOf(raw);
+        if (tool !== null) tools.push(tool);
+      }
+      const next = result.nextCursor;
+      if (typeof next !== 'string' || next === '' || next === cursor) break;
+      cursor = next;
+    }
+    return tools;
+  }
+
+  callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+    return this.rpc('tools/call', { name, arguments: args }, CALL_MS);
+  }
+
+  private async post(body: unknown, headers: Record<string, string>, force: boolean, ms: number): Promise<Answer> {
+    const target = await this.target(force);
+    if (target.kind === 'missing') throw new UpstreamRefused('this connector no longer exists on the daemon');
+    if (target.kind === 'signin') throw new UpstreamRefused('this connector needs signing in again on its page');
+    let res: Response;
+    try {
+      res = await fetch(target.url, {
+        method: 'POST',
+        redirect: 'manual',
+        signal: AbortSignal.timeout(ms),
+        headers: { 'content-type': 'application/json', accept: ACCEPT, ...target.headers, ...headers },
+        body: JSON.stringify(body),
+      });
+    } catch (err) {
+      throw new UpstreamFailed(`could not be reached (${errMsg(err)})`);
+    }
+    const text = await res.text().catch(() => '');
+    return { status: res.status, text, contentType: res.headers.get('content-type') ?? '', session: res.headers.get('mcp-session-id') };
+  }
+
+  private async withCredentialLadder(body: unknown, headers: Record<string, string>, ms: number): Promise<Answer> {
+    const first = await this.post(body, headers, false, ms);
+    if (first.status !== 401 && first.status !== 403) return first;
+    const again = await this.post(body, headers, true, ms);
+    if (again.status === 401 || again.status === 403) throw new UpstreamRefused('rejected the credential; sign in again on its page');
+    return again;
+  }
+
+  private async ensureSession(): Promise<Live> {
+    if (this.live !== null) return this.live;
+    const id = ++this.seq;
+    const answer = await this.withCredentialLadder(initializeBody(id), {}, LIST_MS);
+    if (answer.status >= 300) throw new UpstreamFailed(`answered ${String(answer.status)} to initialize`);
+    const result = resultOf(answer, id);
+    const protocol = isRecord(result) && typeof result.protocolVersion === 'string' ? result.protocolVersion : PROTOCOL;
+    this.live = { session: answer.session, protocol };
+    await this.post({ jsonrpc: '2.0', method: 'notifications/initialized' }, this.sessionHeaders(this.live), false, LIST_MS).catch(() => undefined);
+    return this.live;
+  }
+
+  private sessionHeaders(live: Live): Record<string, string> {
+    const headers: Record<string, string> = { 'mcp-protocol-version': live.protocol };
+    if (live.session !== null && live.session !== '') headers['mcp-session-id'] = live.session;
+    return headers;
+  }
+
+  private async rpc(method: string, params: unknown, ms: number): Promise<unknown> {
+    const live = await this.ensureSession();
+    const id = ++this.seq;
+    const body = { jsonrpc: '2.0', id, method, params };
+    let answer = await this.withCredentialLadder(body, this.sessionHeaders(live), ms);
+    if (answer.status === 404 && live.session !== null) {
+      this.live = null;
+      answer = await this.withCredentialLadder(body, this.sessionHeaders(await this.ensureSession()), ms);
+    }
+    if (answer.status >= 300) throw new UpstreamFailed(`answered ${String(answer.status)}${answer.text === '' ? '' : `: ${answer.text.slice(0, 200)}`}`);
+    return resultOf(answer, id);
+  }
+}

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

@@ -5,7 +5,7 @@ import {
 } from '../stations/registry.js';
 import { listEndpoints } from '../net/tunnel.js';
 import { hookUrl } from '../stations/attach.js';
-import { agentIdForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
+import { agentIdForAccount, allowlistForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
 
 const accountId = (acc: unknown): string | undefined => {
   const id = (acc as { id?: unknown }).id;
@@ -23,7 +23,9 @@ function withAgentId(station: string, acc: unknown): unknown {
   const id = typeof rec.id === 'string' ? rec.id : undefined;
   if (id === undefined) return acc;
   const agentId = agentIdForAccount(station, id);
-  return agentId === undefined ? acc : { ...rec, agentId };
+  if (agentId === undefined) return acc;
+  const allowlist = allowlistForAccount(station, id);
+  return allowlist === undefined ? { ...rec, agentId } : { ...rec, agentId, allowlist };
 }
 
 export function attachAgentIds(

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

@@ -0,0 +1,31 @@
+import type { ToolResult } from '@metro-labs/core/stations/types';
+import { errResult } from './ctx.js';
+
+export interface ConnectorToolEntry {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  annotations?: unknown;
+}
+
+export interface ConnectorToolProvider {
+  list: () => ConnectorToolEntry[];
+  owns: (name: string) => boolean;
+  call: (name: string, args: Record<string, unknown>) => Promise<ToolResult>;
+}
+
+const NONE: ConnectorToolProvider = {
+  list: () => [],
+  owns: () => false,
+  call: (name) => Promise.resolve(errResult(`metro: no connector serves ${name}`)),
+};
+
+let provider: ConnectorToolProvider = NONE;
+
+export function setConnectorToolProvider(next: ConnectorToolProvider | null): void {
+  provider = next ?? NONE;
+}
+
+export const connectorToolList = (): ConnectorToolEntry[] => provider.list();
+export const isConnectorTool = (name: string): boolean => provider.owns(name);
+export const callConnectorTool = (name: string, args: Record<string, unknown>): Promise<ToolResult> => provider.call(name, args);

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

@@ -138,6 +138,10 @@ export function agentLiveness(): Map<string, AgentLiveness> {
   return activeRegistry?.liveness() ?? new Map<string, AgentLiveness>();
 }
 
+export function announceToolSchemaToAll(): void {
+  activeRegistry?.announceToolSchema();
+}
+
 export async function closeAgentSession(agentId: string): Promise<boolean> {
   const scopeKey = sessionScopeKey({ kind: 'agent', agentId });
   return (await activeRegistry?.closeScope(scopeKey)) ?? false;

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

@@ -61,6 +61,10 @@ export class SessionRegistry {
     return out;
   }
 
+  announceToolSchema(): void {
+    for (const session of this.byId.values()) session.announceToolSchema();
+  }
+
   forScope(scopeKey: string): McpSession | undefined {
     return this.byScope.get(scopeKey);
   }

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

@@ -165,7 +165,7 @@ export class McpSession {
     return this.issuedSchema !== toolSchemaSignature();
   }
 
-  private announceToolSchema(): void {
+  announceToolSchema(): void {
     if (!this.streamAttached) return;
     this.deliverSchemaNotice(
       () => this.server.sendToolListChanged(),

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

@@ -31,6 +31,7 @@ import {
   type RequestIdentity,
 } from './request-identity.js';
 import { str } from '@metro-labs/core/str';
+import { callConnectorTool, connectorToolList, isConnectorTool } from './connector-tools.js';
 
 const STATION_TOOLS = new Map<
   string,
@@ -62,11 +63,16 @@ const toolList = (): { tools: unknown[] } => ({
       })),
     ),
     LIST_ACCOUNTS_TOOL,
+    ...connectorToolList(),
   ],
 });
 
 let schemaSignature: string | undefined;
 
+export function invalidateToolSchema(): void {
+  schemaSignature = undefined;
+}
+
 export const toolSchemaSignature = (): string => {
   schemaSignature ??= createHash('sha256')
     .update(JSON.stringify(toolList()))
@@ -149,6 +155,7 @@ async function runTool(
   const name = req.params.name;
   const a = req.params.arguments ?? {};
 
+  if (isConnectorTool(name)) return callConnectorTool(name, a);
   const identity = currentIdentity();
   if (name !== 'list_accounts' && scopeDenied(identity, name, a))
     return errResult('metro: this account is outside your authorized scope');

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -1,6 +1,7 @@
 import { ApiError } from '@metro-labs/http/api-error';
 import { errMsg, log } from '@metro-labs/core/log';
 import { AttachSessions } from '../stations/attach-session.js';
+import { recentSenders } from '../agents/senders.js';
 import type { AgentApiDeps } from '../agents/api.js';
 import { ATTACHABLE, type AccountApiDeps } from '../agents/accounts-api.js';
 import type { SessionApis } from './session-apis.js';
@@ -33,6 +34,7 @@ import {
   localCreateAgent,
   localDeleteAgent,
   localDetachAccount,
+  localSetAllowlist,
   localImportAgent,
   localListAgents,
   localOwnedAgentOrThrow,
@@ -46,6 +48,7 @@ import type { StationName } from '@metro-labs/core/station-names';
 
 export interface LocalModeDeps {
   syncStations: (station: StationName) => Promise<void>;
+  reloadAgents: () => Promise<void>;
   restart: () => void;
   stop: () => void;
   closeAgentSession: (id: string) => Promise<boolean>;
@@ -98,6 +101,9 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     attachAccount: localAttachAccount,
     detachAccount: localDetachAccount,
     syncStations: deps.syncStations,
+    setAllowlist: localSetAllowlist,
+    recentSenders,
+    reloadAgents: deps.reloadAgents,
   };
 }
 

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.84"
+  "version": "0.1.0-beta.87"
 }