@stage-labs/metro 0.1.0-beta.193 → 0.1.0-beta.195

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.193",
+  "version": "0.1.0-beta.195",
   "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/marketplace/plugin/.claude-plugin/plugin.json

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

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

@@ -0,0 +1,55 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { StationName } from '@metro-labs/core/station-names';
+import { ApiError } from '@metro-labs/http/api-error';
+import { bodyField, readJsonBody, sendJson } from '@metro-labs/http/api-http';
+import { stationByName } from '../stations/registry.js';
+import type { AccountRoute } from './account-routes.js';
+import { handleSenderCards, type SenderCardDeps } from './sender-cards.js';
+
+interface Target {
+  station: StationName;
+  accountId: string;
+}
+
+export interface LookupDeps extends SenderCardDeps {
+  resolveSender: (station: StationName, accountId: string, query: string) => Promise<unknown>;
+}
+
+type Lookup = (req: IncomingMessage, res: ServerResponse, deps: LookupDeps, target: Target) => Promise<void>;
+
+function lookupQuery(req: IncomingMessage): string {
+  const params = new URLSearchParams((req.url ?? '').split('?')[1] ?? '');
+  return (params.get('q') ?? '').trim();
+}
+
+async function handleResolve(req: IncomingMessage, res: ServerResponse, deps: LookupDeps, target: Target): Promise<void> {
+  if (stationByName(target.station)?.resolvesSenders !== true)
+    throw new ApiError(`metro cannot look a sender up on ${target.station}`, 400);
+  const query = lookupQuery(req);
+  if (query === '') throw new ApiError('a number to look up is required', 400);
+  sendJson(req, res, 200, await deps.resolveSender(target.station, target.accountId, query));
+}
+
+async function handleName(req: IncomingMessage, res: ServerResponse, deps: LookupDeps, target: Target): Promise<void> {
+  if (stationByName(target.station)?.claimsName !== true)
+    throw new ApiError(`${target.station} accounts have no name to claim`, 400);
+  if (req.method === 'GET') {
+    sendJson(req, res, 200, await deps.accountCall(target.station, 'name', { account: target.accountId }));
+    return;
+  }
+  const label = bodyField(await readJsonBody(req), 'label');
+  if (typeof label !== 'string' || label.trim() === '') throw new ApiError('a label is required', 400);
+  sendJson(req, res, 200, await deps.accountCall(target.station, 'claim_name', { account: target.accountId, label }));
+}
+
+function handleRecent(req: IncomingMessage, res: ServerResponse, deps: LookupDeps, target: Target): Promise<void> {
+  sendJson(req, res, 200, { senders: deps.recentSenders(target.station, target.accountId) });
+  return Promise.resolve();
+}
+
+export const LOOKUPS: Partial<Record<AccountRoute['kind'], Lookup>> = {
+  profiles: handleSenderCards,
+  resolve: handleResolve,
+  name: handleName,
+  senders: handleRecent,
+};

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

@@ -12,6 +12,7 @@ export type AccountRoute =
   | { kind: 'resolve'; station: StationName; accountId: string }
   | { kind: 'enabled'; station: StationName; accountId: string }
   | { kind: 'policy'; station: StationName; accountId: string }
+  | { kind: 'profiles'; station: StationName; accountId: string }
   | { kind: 'name'; station: StationName; accountId: string };
 
 const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
@@ -24,10 +25,11 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   resolve: ['GET'],
   enabled: ['PUT'],
   policy: ['PUT'],
+  profiles: ['GET'],
   name: ['GET', 'POST'],
 };
 
-const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy'] as const;
+const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy', 'profiles'] as const;
 
 type SubRoute = (typeof SUB_ROUTES)[number];
 

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

@@ -1,17 +1,15 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from '@metro-labs/core/log';
-import { normalizeAllowlist } from './allowlist.js';
+import { normalizeAllowlist, normalizeApprovers } from './allowlist.js';
+import { approversForAccount } from './map.js';
+import { isRecord } from '@metro-labs/core/is-record';
 import type { RecentSender } from './senders.js';
 import { ApiError } from '@metro-labs/http/api-error';
-import {
-  apiFailure,
-  bodyField,
-  readJsonBody,
-  sendJson,
-} from '@metro-labs/http/api-http';
+import { apiFailure, bodyField, readJsonBody, sendJson } from '@metro-labs/http/api-http';
 import { type AccountRef } from './account-attach.js';
 import { type AccountRoute } from './account-routes.js';
 import { handlePolicy, type SetPolicy } from './policy-route.js';
+import { LOOKUPS } from './account-lookups.js';
 import { stationByName } from '../stations/registry.js';
 import type { StationName } from '@metro-labs/core/station-names';
 import {
@@ -68,6 +66,7 @@ export interface AccountApiDeps {
     station: StationName,
     accountId: string,
     allowlist: string[],
+    approvers?: string[],
   ) => Promise<string[]>;
   setPolicy: SetPolicy;
   recentSenders: (station: StationName, accountId: string) => RecentSender[];
@@ -89,46 +88,7 @@ export interface AccountApiDeps {
   ) => Promise<boolean>;
 }
 
-export const ATTACHABLE: string[] = [
-  ...ATTACHABLE_STATIONS,
-  ...INTERACTIVE_STATIONS,
-];
-
-function lookupQuery(req: IncomingMessage): string {
-  const params = new URLSearchParams((req.url ?? '').split('?')[1] ?? '');
-  return (params.get('q') ?? '').trim();
-}
-
-async function handleResolve(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  target: { station: StationName; accountId: string },
-): Promise<void> {
-  if (stationByName(target.station)?.resolvesSenders !== true)
-    throw new ApiError(`metro cannot look a sender up on ${target.station}`, 400);
-  const query = lookupQuery(req);
-  if (query === '') throw new ApiError('a number to look up is required', 400);
-  const found = await deps.resolveSender(target.station, target.accountId, query);
-  sendJson(req, res, 200, found);
-}
-
-async function handleName(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  target: { station: StationName; accountId: string },
-): Promise<void> {
-  if (stationByName(target.station)?.claimsName !== true)
-    throw new ApiError(`${target.station} accounts have no name to claim`, 400);
-  if (req.method === 'GET') {
-    sendJson(req, res, 200, await deps.accountCall(target.station, 'name', { account: target.accountId }));
-    return;
-  }
-  const label = bodyField(await readJsonBody(req), 'label');
-  if (typeof label !== 'string' || label.trim() === '') throw new ApiError('a label is required', 400);
-  sendJson(req, res, 200, await deps.accountCall(target.station, 'claim_name', { account: target.accountId, label }));
-}
+export const ATTACHABLE: string[] = [...ATTACHABLE_STATIONS, ...INTERACTIVE_STATIONS];
 
 async function activate(
   deps: AccountApiDeps,
@@ -279,14 +239,18 @@ async function handleAllowlist(
   agentId: string,
   target: { station: StationName; accountId: string },
 ): Promise<void> {
-  const wanted = normalizeAllowlist(bodyField(await readJsonBody(req), 'allowlist'));
-  const allowlist = await deps.setAllowlist(agentId, target.station, target.accountId, wanted);
+  const body = await readJsonBody(req);
+  const wanted = normalizeAllowlist(bodyField(body, 'allowlist'));
+  const asked = isRecord(body) && 'approvers' in body ? body.approvers : approversForAccount(target.station, target.accountId);
+  const approvers = normalizeApprovers(asked, wanted);
+  const allowlist = await deps.setAllowlist(agentId, target.station, target.accountId, wanted, approvers);
   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,
+    approvers,
     activated: await applied(deps),
   });
 }
@@ -346,6 +310,18 @@ async function handleStep(
   sendJson(req, res, 200, view);
 }
 
+async function dispatchAttach(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  agentId: string,
+  route: Extract<AccountRoute, { kind: 'start' | 'session' | 'step' }>,
+): Promise<void> {
+  if (route.kind === 'start') return handleStart(req, res, deps, agentId);
+  if (route.kind === 'session') return handleSession(req, res, deps, { agentId }, route.attachId);
+  return handleStep(req, res, deps, { agentId }, route.attachId);
+}
+
 async function dispatchRoute(
   req: IncomingMessage,
   res: ServerResponse,
@@ -353,27 +329,12 @@ async function dispatchRoute(
   agentId: string,
   route: AccountRoute,
 ): Promise<void> {
-  if (route.kind === 'start')
-    return handleStart(req, res, deps, agentId);
-  if (route.kind === 'session')
-    return handleSession(
-      req,
-      res,
-      deps,
-      { agentId },
-      route.attachId,
-    );
-  if (route.kind === 'step')
-    return handleStep(req, res, deps, { agentId }, route.attachId);
+  if (route.kind === 'start' || route.kind === 'session' || route.kind === 'step') return dispatchAttach(req, res, deps, agentId, route);
   if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, agentId, route);
   if (route.kind === 'enabled') return handleEnabled(req, res, deps, agentId, route);
   if (route.kind === 'policy') return handlePolicy(req, res, deps, agentId, route);
-  if (route.kind === 'resolve') return handleResolve(req, res, deps, route);
-  if (route.kind === 'name') return handleName(req, res, deps, route);
-  if (route.kind === 'senders') {
-    sendJson(req, res, 200, { senders: deps.recentSenders(route.station, route.accountId) });
-    return;
-  }
+  const lookup = LOOKUPS[route.kind];
+  if (lookup !== undefined && 'station' in route) return lookup(req, res, deps, route);
   return handleDetach(req, res, deps, agentId, route);
 }
 

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

@@ -29,6 +29,19 @@ function senderId(entry: unknown): string {
   return value.startsWith('@') ? domainEntry(value) : value;
 }
 
+export function normalizeApprovers(raw: unknown, allowlist: string[]): string[] {
+  if (raw === undefined) return [];
+  if (!Array.isArray(raw)) throw new ApiError('approvers must be a list of sender ids', 400);
+  const listed = new Set(allowlist.map((entry) => entry.toLowerCase()));
+  const seen = new Set<string>();
+  return raw.map(senderId).filter((value) => {
+    const key = value.toLowerCase();
+    if (!listed.has(key) || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
 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);

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

@@ -7,6 +7,7 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { parseId } from '@metro-labs/core/ids';
 import type { LoadedAccount, LoadedAgent, LoadedConnector } from '../stations/materialize.js';
 import { STATIONS } from '@metro-labs/core/station-names';
+import { approversOf } from './files.js';
 
 const AGENTS = '/api/agents';
 const RESTORE_PATH = `${AGENTS}/restore`;
@@ -60,6 +61,7 @@ function stationOf(raw: unknown): LoadedAccount {
     station: raw.station as LoadedAccount['station'],
     id: raw.id,
     allowlist,
+    ...approversOf(raw.approvers),
     enabled: raw.enabled !== false,
     ...(policy === undefined ? {} : { policy }),
     config: raw.config,

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

@@ -243,12 +243,15 @@ export async function localSetAllowlist(
   station: StationName,
   accountId: string,
   allowlist: string[],
+  approvers: string[] = [],
   dir = agentsDir(),
 ): Promise<string[]> {
   const stored = agentOrThrow(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;
+  if (approvers.length === 0) delete account.approvers;
+  else account.approvers = approvers;
   save(stored);
   return Promise.resolve(allowlist);
 }

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

@@ -49,6 +49,12 @@ function allowlistOf(raw: unknown, path: string, where: string): string[] | null
   return list;
 }
 
+export function approversOf(raw: unknown): { approvers?: string[] } {
+  if (!Array.isArray(raw)) return {};
+  const list = raw.filter((entry): entry is string => typeof entry === 'string' && entry !== '*' && entry.trim() !== '');
+  return list.length === 0 ? {} : { approvers: list };
+}
+
 function stationOf(raw: unknown, path: string, index: number): LoadedAccount {
   const where = `stations[${String(index)}]`;
   if (!isRecord(raw)) fail(path, `${where} is not an object`);
@@ -62,6 +68,7 @@ function stationOf(raw: unknown, path: string, index: number): LoadedAccount {
     station,
     id,
     allowlist: allowlistOf(raw.allowlist, path, where),
+    ...approversOf(raw.approvers),
     enabled: raw.enabled !== false,
     ...(policy === undefined ? {} : { policy }),
     config,

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

@@ -8,6 +8,7 @@ const mapKey = (station: string, accountId: string): string =>
 let agentMap: AgentMap = {};
 let agentNames: AgentNameMap = {};
 let allowlistMap: AllowlistMap = {};
+let approversMap: AllowlistMap = {};
 let disabledAccounts = new Set<string>();
 
 export function setAgentMap(map: AgentMap, names: AgentNameMap): void {
@@ -19,6 +20,22 @@ export function setAllowlistMap(map: AllowlistMap): void {
   allowlistMap = map;
 }
 
+export function setApproversMap(map: AllowlistMap): void {
+  approversMap = map;
+}
+
+export const approversForAccount = (station: string, accountId: string): string[] => approversMap[mapKey(station, accountId)] ?? [];
+
+export function approversForLine(line: string): string[] {
+  const a = accountFromLine(line);
+  return a ? approversForAccount(a.station, a.accountId) : [];
+}
+
+export const mayApprove = (line: string, from: string): boolean => {
+  const approvers = approversForLine(line);
+  return approvers.length > 0 && senderMatchesAllowlist(approvers, from);
+};
+
 export function setDisabledAccounts(ids: Set<string>): void {
   disabledAccounts = ids;
 }

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

@@ -0,0 +1,74 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { StationName } from '@metro-labs/core/station-names';
+import { errMsg, log } from '@metro-labs/core/log';
+import { sendJson } from '@metro-labs/http/api-http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { stationByName } from '../stations/registry.js';
+import { allowlistForAccount } from './map.js';
+import type { RecentSender } from './senders.js';
+
+export interface SenderCard {
+  id: string;
+  name?: string;
+  handle?: string;
+}
+
+export interface SenderCardDeps {
+  recentSenders: (station: StationName, accountId: string) => RecentSender[];
+  accountCall: (station: StationName, action: string, args: Record<string, unknown>) => Promise<unknown>;
+}
+
+const MAX_LOOKUPS = 50;
+const LOOKUP_MS = 8_000;
+
+const filled = (value: unknown): string | undefined => (typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined);
+
+function cardOf(id: string, profile: unknown, seenName: string | undefined): SenderCard {
+  const p = isRecord(profile) ? profile : {};
+  const display = filled(p.display_name);
+  const handle = filled(p.name);
+  const name = display ?? seenName ?? handle;
+  return {
+    id,
+    ...(name === undefined ? {} : { name }),
+    ...(handle === undefined || handle === name ? {} : { handle }),
+  };
+}
+
+async function lookup(deps: SenderCardDeps, station: StationName, accountId: string, user: string): Promise<unknown> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const late = new Promise<null>((resolve) => {
+    timer = setTimeout(() => {
+      resolve(null);
+    }, LOOKUP_MS);
+  });
+  try {
+    return await Promise.race([deps.accountCall(station, 'profile', { account: accountId, user }), late]);
+  } catch (err) {
+    log.info({ station, account: accountId, err: errMsg(err) }, 'account-api: could not read the profile of a listed sender');
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function senderCards(deps: SenderCardDeps, station: StationName, accountId: string): Promise<SenderCard[]> {
+  const ids = (allowlistForAccount(station, accountId) ?? []).filter((id) => id !== '*' && !id.startsWith('@'));
+  const seen = new Map(deps.recentSenders(station, accountId).map((s) => [s.id.toLowerCase(), filled(s.name)]));
+  const reads = stationByName(station)?.readsProfiles === true;
+  return Promise.all(
+    ids.map(async (id, at) => {
+      const profile = reads && at < MAX_LOOKUPS ? await lookup(deps, station, accountId, id) : null;
+      return cardOf(id, profile, seen.get(id.toLowerCase()));
+    }),
+  );
+}
+
+export async function handleSenderCards(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: SenderCardDeps,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  sendJson(req, res, 200, { senders: await senderCards(deps, target.station, target.accountId) });
+}

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

@@ -29,7 +29,7 @@ interface InboundDeps {
   getStations: () => Set<string>;
   senderAllowed: (from: string, line: string, verified?: boolean) => boolean;
   approves?: (station: string) => boolean;
-  answerPermission?: (requestId: string, behavior: 'allow' | 'deny', line: string) => Promise<boolean>;
+  answerPermission?: (requestId: string, behavior: 'allow' | 'deny', line: string, from: string) => Promise<boolean>;
 }
 
 const ATTACH_TIMEOUT_MS = 15_000;
@@ -253,7 +253,7 @@ export class InboundRelay {
     if (answer === undefined || base.evType !== 'msg' || !this.approves(base.station) || ev.senderVerified === false) return false;
     const m = PERMISSION_REPLY_RE.exec(base.text);
     if (m?.[1] === undefined || m[2] === undefined) return false;
-    return answer(m[2].toLowerCase(), m[1].toLowerCase().startsWith('y') ? 'allow' : 'deny', base.line);
+    return answer(m[2].toLowerCase(), m[1].toLowerCase().startsWith('y') ? 'allow' : 'deny', base.line, base.from);
   }
 
   private approves(station: string): boolean {

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

@@ -6,7 +6,7 @@ import {
 } from '../stations/registry.js';
 import { listEndpoints } from '../stations/webhook-endpoints.js';
 import { hookUrl, threemaCallbackUrl } from '../stations/attach.js';
-import { accountEnabled, agentIdForAccount, allowlistForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
+import { accountEnabled, agentIdForAccount, allowlistForAccount, approversForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
 
 const accountId = (acc: unknown): string | undefined => {
   const id = (acc as { id?: unknown }).id;
@@ -28,7 +28,9 @@ function withAgentId(station: string, acc: unknown): unknown {
   const allowlist = allowlistForAccount(station, id);
   const stored = storedPolicy({ kind: 'channel', station, account: id });
   const policy = stored === undefined ? {} : { policy: stored };
-  const tagged = allowlist === undefined ? { ...rec, agentId, ...policy } : { ...rec, agentId, allowlist, ...policy };
+  const approvers = approversForAccount(station, id);
+  const extra = approvers.length === 0 ? policy : { ...policy, approvers };
+  const tagged = allowlist === undefined ? { ...rec, agentId, ...extra } : { ...rec, agentId, allowlist, ...extra };
   return accountEnabled(station, id) ? tagged : { ...tagged, enabled: false };
 }
 

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

@@ -2,6 +2,7 @@ import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { z } from 'zod';
 import type { InboundRelay } from '../channels/inbound.js';
 import { holdPrompt, type Behavior } from '../approvals/pending.js';
+import { approversForLine } from '../agents/map.js';
 import { metroCall } from './ctx.js';
 import { promptBody } from './permission-prompt.js';
 
@@ -40,6 +41,10 @@ function relayLine(deps: PermissionRelayDeps, requestId: string): string | undef
     deps.log('permission_request: known line is outside the agent scope, held for the page only', requestId);
     return undefined;
   }
+  if (approversForLine(line).length === 0) {
+    deps.log('permission_request: nobody on that chat may approve, held for the page only', requestId);
+    return undefined;
+  }
   return line;
 }
 

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

@@ -4,7 +4,7 @@ import { InboundRelay } from '../channels/inbound.js';
 import { answerPrompt, forgetPromptsOf, promptLine } from '../approvals/pending.js';
 import { ChannelRelay, type ReplayLedger } from '../channels/relay.js';
 import { errMsg } from '@metro-labs/core/log';
-import { allowlistForLine, senderPermitted } from '../agents/map.js';
+import { allowlistForLine, mayApprove, senderPermitted } from '../agents/map.js';
 import { accountStationNames, stationByName } from '../stations/registry.js';
 import { eventInScope } from '../agents/scope.js';
 import { MCP_INSTRUCTIONS } from './instructions.js';
@@ -24,8 +24,8 @@ const senderAllowed = (from: string, line: string, verified?: boolean): boolean
 
 const approves = (station: string): boolean => stationByName(station)?.approvals !== false;
 
-async function answerPermission(requestId: string, behavior: 'allow' | 'deny', line: string): Promise<boolean> {
-  if (promptLine(requestId) !== line) return false;
+async function answerPermission(requestId: string, behavior: 'allow' | 'deny', line: string, from: string): Promise<boolean> {
+  if (promptLine(requestId) !== line || !mayApprove(line, from)) return false;
   return (await answerPrompt(requestId, behavior, 'chat', line)) !== undefined;
 }
 

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

@@ -14,6 +14,7 @@ import { trainsDir } from '../boot/paths.js';
 import {
   setAgentMap,
   setAllowlistMap,
+  setApproversMap,
   setDisabledAccounts,
   type AgentMap,
   type AgentNameMap,
@@ -32,6 +33,7 @@ export interface LoadedAccount {
   station: StationName;
   id: string;
   allowlist: string[] | null;
+  approvers?: string[];
   enabled?: boolean;
   policy?: ToolPolicy;
   config: Record<string, unknown>;
@@ -137,6 +139,11 @@ const channelPolicies = (list: LoadedAgent[]): [PolicyTarget, ToolPolicy][] =>
     ),
   );
 
+const approversOf = (list: LoadedAgent[]): Record<string, string[]> =>
+  Object.fromEntries(
+    list.flatMap((agent) => agent.accounts.flatMap((a) => (a.approvers === undefined ? [] : [[`${a.station}/${a.id}`, a.approvers]]))),
+  );
+
 function writeStations(list: LoadedAgent[]): WrittenStations {
   mkdirSync(METRO_DIR, { recursive: true });
   mkdirSync(trainsDir(), { recursive: true });
@@ -169,6 +176,7 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
   }
   setAgentMap(map, names);
   setAllowlistMap(allow);
+  setApproversMap(approversOf(list));
   setDisabledAccounts(disabled);
   setPolicies('channel', channelPolicies(list));
 

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.193"
+  "version": "0.1.0-beta.195"
 }