@stage-labs/metro 0.1.0-beta.20 → 0.1.0-beta.201

package/runtime/node_modules/@metro-labs/{mcp/src/db/agent-map.ts → daemon/src/agents/map.ts}

@@ -8,6 +8,8 @@ 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 {
   agentMap = map;
@@ -18,6 +20,28 @@ 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;
+}
+
+export const accountEnabled = (station: string, accountId: string): boolean => !disabledAccounts.has(mapKey(station, accountId));
+
 export function accountFromLine(
   line: string,
 ): { station: string; accountId: string } | undefined {
@@ -45,6 +69,19 @@ export function agentForLine(line: string): string | undefined {
   return id === undefined ? undefined : agentNames[id];
 }
 
+export interface KnownAccount {
+  station: string;
+  id: string;
+  agentId: string;
+}
+
+export function knownAccounts(): KnownAccount[] {
+  return Object.entries(agentMap).flatMap(([key, agentId]) => {
+    const cut = key.indexOf('/');
+    return cut === -1 ? [] : [{ station: key.slice(0, cut), id: key.slice(cut + 1), agentId }];
+  });
+}
+
 export function stationAgentIds(station: string): string[] {
   const prefix = `${station}/`;
   return Object.entries(agentMap)
@@ -52,11 +89,24 @@ 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;
 }
 
+export function senderPermitted(
+  allowlist: string[] | undefined,
+  from: string,
+  verified?: boolean,
+): boolean {
+  if (allowlist === undefined || allowlist.length === 0 || allowlist.includes('*')) return true;
+  return verified !== false && senderMatchesAllowlist(allowlist, from);
+}
+
 export function senderMatchesAllowlist(
   allowlist: string[],
   from: string,
@@ -66,6 +116,13 @@ export function senderMatchesAllowlist(
   const id = f.split('/').pop() ?? f;
   return allowlist.some((a) => {
     const v = a.toLowerCase();
-    return v === f || v === id;
+    return v === f || v === id || domainMatches(v, id);
   });
 }
+
+const EMAIL_RE = /^[^@\s/]+@([^@\s/]+)$/;
+
+function domainMatches(entry: string, id: string): boolean {
+  if (!entry.startsWith('@') || entry.length < 2) return false;
+  return EMAIL_RE.exec(id)?.[1] === entry.slice(1);
+}

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

@@ -0,0 +1,27 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from '@metro-labs/core/log';
+import { bodyField, readJsonBody, sendJson } from '@metro-labs/http/api-http';
+import type { StationName } from '@metro-labs/core/station-names';
+import { normalizePolicy, type ToolPolicy } from '../policy/policy.js';
+
+export type SetPolicy = (agentId: string, station: StationName, accountId: string, policy: ToolPolicy) => Promise<ToolPolicy>;
+
+export async function handlePolicy(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: { setPolicy: SetPolicy; reloadAgents: () => Promise<void> },
+  agentId: string,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  const wanted = normalizePolicy(bodyField(await readJsonBody(req), 'policy'));
+  const policy = await deps.setPolicy(agentId, target.station, target.accountId, wanted);
+  log.info({ agentId, station: target.station, account: target.accountId, policy }, 'account-api: tool policy set');
+  const activated = await deps.reloadAgents().then(
+    () => true,
+    (err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'account-api: policy reload failed, the change lands at the next boot');
+      return false;
+    },
+  );
+  sendJson(req, res, 200, { agentId, station: target.station, accountId: target.accountId, policy, activated });
+}

package/runtime/node_modules/@metro-labs/{mcp/src/db/agent-scope.ts → daemon/src/agents/scope.ts}

@@ -2,8 +2,8 @@ import {
   accountFromLine,
   agentIdForAccount,
   stationAgentIds,
-} from './agent-map.js';
-import { STATIONS } from './schema.js';
+} from './map.js';
+import { STATIONS } from '@metro-labs/core/station-names';
 
 const ACCOUNT_STATIONS = new Set<string>(STATIONS);
 

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

@@ -0,0 +1,86 @@
+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()));
+    }),
+  );
+}
+
+const known = (profile: unknown): boolean =>
+  isRecord(profile) && ['name', 'display_name', 'about', 'avatar', 'address'].some((key) => filled(profile[key]) !== undefined);
+
+export async function unconfirmedSenders(deps: SenderCardDeps, station: StationName, accountId: string, ids: string[]): Promise<string[]> {
+  if (stationByName(station)?.readsProfiles !== true || ids.length === 0) return [];
+  const seen = new Set(deps.recentSenders(station, accountId).map((s) => s.id.toLowerCase()));
+  const checks = await Promise.all(
+    ids.map(async (id) => (seen.has(id.toLowerCase()) || known(await lookup(deps, station, accountId, id)) ? null : id)),
+  );
+  return checks.filter((id): id is string => id !== null);
+}
+
+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/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/approvals/api.ts

@@ -0,0 +1,55 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { apiFailure, apiSession, bodyField, cors, readJsonBody, sendJson } from '@metro-labs/http/api-http';
+import { answerPrompt, pendingPrompts, type Behavior, type PendingPrompt } from './pending.js';
+
+const PREFIX = '/api/approvals';
+const ID_RE = /^[a-km-z]{5}$/;
+
+const approvalView = (p: PendingPrompt): Record<string, unknown> => ({
+  id: p.requestId,
+  tool: p.tool,
+  description: p.description,
+  preview: p.preview,
+  line: p.line ?? null,
+  requestedAt: new Date(p.at).toISOString(),
+});
+
+function decisionOf(body: unknown): Behavior {
+  const value = bodyField(body, 'decision');
+  if (value !== 'allow' && value !== 'deny') throw new ApiError("decision is 'allow' or 'deny'", 400);
+  return value;
+}
+
+async function answer(req: IncomingMessage, id: string | undefined, subject: string): Promise<unknown> {
+  if (id === undefined) {
+    if (req.method !== 'GET') throw new ApiError('method not allowed', 405);
+    return { approvals: pendingPrompts().map(approvalView) };
+  }
+  if (req.method !== 'POST') throw new ApiError('method not allowed', 405);
+  if (!ID_RE.test(id)) throw new ApiError('no such approval', 404);
+  const decision = decisionOf(await readJsonBody(req));
+  const answered = await answerPrompt(id, decision, 'page', subject);
+  if (answered === undefined) throw new ApiError('no such approval', 404);
+  return { approval: approvalView(answered), decision };
+}
+
+export function handleApprovalsRequest(req: IncomingMessage, res: ServerResponse): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PREFIX && !path.startsWith(`${PREFIX}/`)) return false;
+  const rest = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  if (rest.length > 1) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  apiSession(req)
+    .then(async (session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      sendJson(req, res, 200, await answer(req, rest[0], session.subject));
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, 'approvals-api');
+    });
+  return true;
+}

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

@@ -0,0 +1,2 @@
+export const NEEDS_APPROVAL = (where: string, tool: string): string =>
+  `Needs the owner's approval for ${where} (${tool}). Make this exact call from a background worker so Claude Code asks the owner in chat, and wait for the answer. An approval given only in the terminal does not count.`;

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

@@ -0,0 +1,149 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { previewMatches } from './preview.js';
+
+export type Behavior = 'allow' | 'deny';
+
+export type AnsweredVia = 'chat' | 'page' | 'expiry';
+
+export interface PendingPrompt {
+  requestId: string;
+  tool: string;
+  description: string;
+  preview: string;
+  line: string | undefined;
+  at: number;
+}
+
+interface Held extends PendingPrompt {
+  owner: object;
+  send: (behavior: Behavior) => Promise<void>;
+  tell: ((text: string) => Promise<void>) | undefined;
+}
+
+const PENDING_MAX = 500;
+const SWEEP_MS = 60_000;
+const DEFAULT_TTL_H = 24;
+const HOUR_MS = 3_600_000;
+
+const held = new Map<string, Held>();
+
+interface Grant {
+  tool: string;
+  preview: string;
+  at: number;
+}
+
+const GRANT_TTL_MS = 10 * 60_000;
+const GRANTS_MAX = 200;
+let grants: Grant[] = [];
+
+function grant(entry: Held, now = Date.now()): void {
+  grants = [...grants.filter((g) => now - g.at < GRANT_TTL_MS), { tool: entry.tool, preview: entry.preview, at: now }].slice(-GRANTS_MAX);
+}
+
+export function takeGrant(toolMatches: (tool: string) => boolean, args: Record<string, unknown>, now = Date.now()): boolean {
+  const at = grants.findIndex((g) => now - g.at < GRANT_TTL_MS && toolMatches(g.tool) && previewMatches(g.preview, args));
+  if (at < 0) return false;
+  grants = grants.filter((_, i) => i !== at);
+  return true;
+}
+
+export function approvalTtlMs(env: NodeJS.ProcessEnv = process.env): number {
+  const hours = Number(env.METRO_APPROVAL_TTL_H);
+  return (Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_TTL_H) * HOUR_MS;
+}
+
+const shown = ({ requestId, tool, description, preview, line, at }: Held): PendingPrompt => ({
+  requestId,
+  tool,
+  description,
+  preview,
+  line,
+  at,
+});
+
+export function holdPrompt(
+  prompt: PendingPrompt,
+  owner: object,
+  send: (behavior: Behavior) => Promise<void>,
+  tell?: (text: string) => Promise<void>,
+): void {
+  held.set(prompt.requestId, { ...prompt, owner, send, tell });
+  while (held.size > PENDING_MAX) {
+    const oldest = held.keys().next();
+    if (oldest.done) break;
+    held.delete(oldest.value);
+  }
+}
+
+export const pendingPrompts = (): PendingPrompt[] => [...held.values()].map(shown).sort((a, b) => b.at - a.at);
+
+export const promptLine = (requestId: string): string | undefined => held.get(requestId)?.line;
+
+function chatNotice(via: AnsweredVia, behavior: Behavior): string | undefined {
+  if (via === 'expiry') return 'Expired, denied.';
+  if (via === 'page') return behavior === 'allow' ? 'Approved on the page.' : 'Denied on the page.';
+  return undefined;
+}
+
+async function tellChat(entry: Held, via: AnsweredVia, behavior: Behavior): Promise<void> {
+  const text = chatNotice(via, behavior);
+  if (text === undefined || entry.tell === undefined) return;
+  await entry.tell(text).catch((err: unknown) => {
+    log.warn({ requestId: entry.requestId, err: errMsg(err) }, 'approvals: the chat could not be told the answer');
+  });
+}
+
+export async function answerPrompt(
+  requestId: string,
+  behavior: Behavior,
+  via: AnsweredVia,
+  who: string = via,
+): Promise<PendingPrompt | undefined> {
+  const entry = held.get(requestId);
+  if (entry === undefined) return undefined;
+  held.delete(requestId);
+  if (behavior === 'allow' && via !== 'expiry') grant(entry);
+  log.info({ requestId, tool: entry.tool, behavior, by: who === via ? via : `${via} ${who}` }, 'approvals: a Claude Code permission prompt answered');
+  await entry.send(behavior);
+  await tellChat(entry, via, behavior);
+  return shown(entry);
+}
+
+export function forgetPromptsOf(owner: object): void {
+  for (const [id, entry] of held) if (entry.owner === owner) held.delete(id);
+}
+
+export function settlePromptsFor(name: string, args: Record<string, unknown>): void {
+  for (const [id, entry] of held)
+    if (entry.tool.endsWith(`__${name}`) && previewMatches(entry.preview, args)) {
+      held.delete(id);
+      log.info({ requestId: id, tool: entry.tool }, 'approvals: the call ran, so the prompt was answered in Claude Code');
+    }
+}
+
+export async function expirePrompts(now = Date.now(), ttl = approvalTtlMs()): Promise<number> {
+  const overdue = [...held.values()].filter((entry) => now - entry.at >= ttl);
+  for (const entry of overdue)
+    await answerPrompt(entry.requestId, 'deny', 'expiry').catch((err: unknown) => {
+      log.warn({ requestId: entry.requestId, err: errMsg(err) }, 'approvals: the expiry answer could not be sent');
+    });
+  return overdue.length;
+}
+
+export function startPromptExpiry(): () => void {
+  const timer = setInterval(() => {
+    expirePrompts().catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'approvals: the expiry sweep failed');
+    });
+  }, SWEEP_MS);
+  timer.unref();
+  return () => {
+    clearInterval(timer);
+  };
+}
+
+export function forgetAllPrompts(): void {
+  held.clear();
+  grants = [];
+}

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

@@ -0,0 +1,66 @@
+import { isDeepStrictEqual } from 'node:util';
+import { isRecord } from '@metro-labs/core/is-record';
+
+export const ELIDED = '\u0000';
+
+const CODE_POINTS = /(?:\\n|\n)⋯ \d+ code points elided ⋯(?:\\n|\n)/g;
+const FIELD_BLOCK = /[\s,]*(?:\\n|\n)?\s*⋯[^]*$/;
+
+export interface ReadPreview {
+  input: Record<string, unknown> | undefined;
+  partial: boolean;
+}
+
+function parsedRecord(text: string): Record<string, unknown> | undefined {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function readPreview(preview: string): ReadPreview {
+  const text = preview.replace(CODE_POINTS, '\\u0000');
+  const whole = parsedRecord(text);
+  if (whole !== undefined) return { input: whole, partial: false };
+  if (!text.includes('⋯')) return { input: undefined, partial: false };
+  const head = text.replace(FIELD_BLOCK, '').replace(/[\s,]*$/, '');
+  const input = parsedRecord(`${head}}`) ?? parsedRecord(head);
+  return { input, partial: input !== undefined };
+}
+
+export const shownValue = (text: string): string => text.split(ELIDED).join('…');
+
+function stringMatches(shown: string, real: string): boolean {
+  if (!shown.includes(ELIDED)) return shown === real;
+  const [first = '', ...rest] = shown.split(ELIDED);
+  const last = rest.pop() ?? '';
+  if (!real.startsWith(first) || !real.endsWith(last)) return false;
+  let at = first.length;
+  for (const part of rest) {
+    const found = real.indexOf(part, at);
+    if (found < 0) return false;
+    at = found + part.length;
+  }
+  return at <= real.length - last.length;
+}
+
+function valueMatches(shown: unknown, real: unknown): boolean {
+  if (typeof shown === 'string') return typeof real === 'string' && stringMatches(shown, real);
+  if (Array.isArray(shown))
+    return Array.isArray(real) && shown.length === real.length && shown.every((v, i) => valueMatches(v, real[i]));
+  if (isRecord(shown)) return isRecord(real) && recordMatches(shown, real, false);
+  return isDeepStrictEqual(shown, real);
+}
+
+function recordMatches(shown: Record<string, unknown>, real: Record<string, unknown>, partial: boolean): boolean {
+  const keys = Object.keys(shown);
+  if (!partial && keys.length !== Object.keys(real).length) return false;
+  return keys.every((key) => key in real && valueMatches(shown[key], real[key]));
+}
+
+export function previewMatches(preview: string, args: Record<string, unknown>): boolean {
+  const { input, partial } = readPreview(preview);
+  return input !== undefined && recordMatches(input, args, partial);
+}