@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -0,0 +1,142 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { AGENT_NAME_RE, ID_RE } from '@metro-labs/core/ids';
+import { STATIONS, type StationName } from '@metro-labs/core/station-names';
+import type { LoadedAccount, LoadedAgent, StationSource } from '../stations/materialize.js';
+import { isRecord } from '@metro-labs/core/is-record';
+import { parsePolicy } from '../policy/policy.js';
+
+const AGENT_FILE = 'agent.json';
+
+const KEY_RE = /^[A-Za-z0-9_-]{16,128}$/;
+const STATION_NAMES = new Set<string>(STATIONS);
+
+export class AgentFileError extends Error {}
+
+export interface AgentFile {
+  version: 1;
+  id: string;
+  name: string | null;
+  key: string | null;
+  stations: LoadedAccount[];
+}
+
+export const agentFilePath = (dir = agentsDir()): string => join(dir, AGENT_FILE);
+
+export function agentsDir(): string {
+  const explicit = process.env.METRO_AGENTS_DIR?.trim();
+  return explicit !== undefined && explicit !== ''
+    ? explicit
+    : join(homedir(), '.metro', 'agents');
+}
+
+function fail(path: string, reason: string): never {
+  throw new AgentFileError(`${path}: ${reason}`);
+}
+
+function isStationName(value: unknown): value is StationName {
+  return typeof value === 'string' && STATION_NAMES.has(value);
+}
+
+function allowlistOf(raw: unknown, path: string, where: string): string[] | null {
+  if (raw === null || raw === undefined) return null;
+  if (!Array.isArray(raw)) fail(path, `${where}.allowlist is not a list of strings`);
+  const list = raw.filter((entry): entry is string => typeof entry === 'string');
+  if (list.length !== raw.length)
+    fail(path, `${where}.allowlist is not a list of strings`);
+  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`);
+  const { station, id, config } = raw;
+  if (!isStationName(station)) fail(path, `${where}.station is not a known station`);
+  if (typeof id !== 'string' || !ID_RE.test(id))
+    fail(path, `${where}.id is not an 11-character id`);
+  if (!isRecord(config)) fail(path, `${where}.config is not an object`);
+  const policy = parsePolicy(raw.policy, `${path} ${where}`);
+  return {
+    station,
+    id,
+    allowlist: allowlistOf(raw.allowlist, path, where),
+    ...approversOf(raw.approvers),
+    enabled: raw.enabled !== false,
+    ...(policy === undefined ? {} : { policy }),
+    config,
+  };
+}
+
+function optionalMatch(
+  value: unknown,
+  re: RegExp,
+  path: string,
+  what: string,
+): string | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value !== 'string' || !re.test(value)) fail(path, what);
+  return value;
+}
+
+function nameOf(raw: unknown, path: string): string | null {
+  if (raw === undefined || raw === null) return null;
+  if (typeof raw !== 'string' || !AGENT_NAME_RE.test(raw)) fail(path, 'name is not a valid agent name');
+  return raw;
+}
+
+export function parseAgentFile(raw: string, path: string): AgentFile {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    fail(path, 'is not valid JSON');
+  }
+  if (!isRecord(parsed)) fail(path, 'is not a JSON object');
+  if (parsed.version !== 1) fail(path, 'version must be 1');
+  const { id, name, stations } = parsed;
+  if (typeof id !== 'string' || !ID_RE.test(id))
+    fail(path, 'id is not an 11-character id');
+  const label = nameOf(name, path);
+  const key = optionalMatch(parsed.key, KEY_RE, path, 'key is not an agent key');
+  if (!Array.isArray(stations)) fail(path, 'stations is not a list');
+  return {
+    version: 1,
+    id,
+    name: label,
+    key,
+    stations: stations.map((s, i) => stationOf(s, path, i)),
+  };
+}
+
+export function readAgentFile(path: string): AgentFile {
+  let raw: string;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch {
+    fail(path, 'cannot be read');
+  }
+  return parseAgentFile(raw, path);
+}
+
+export function listAgentFiles(dir = agentsDir()): string[] {
+  const fixed = agentFilePath(dir);
+  return existsSync(fixed) ? [fixed] : [];
+}
+
+export function loadFileAgents(dir = agentsDir()): LoadedAgent[] {
+  return listAgentFiles(dir).map(readAgentFile).map((agent) => ({
+    id: agent.id,
+    name: agent.name ?? agent.id,
+    key: agent.key,
+    accounts: agent.stations,
+  }));
+}
+
+export const fileSource: StationSource = () => Promise.resolve(loadFileAgents());

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

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { ID_RE } from './ids.js';
+import { ID_RE } from '@metro-labs/core/ids';
 
 const digest = (token: string): string =>
   createHash('sha256').update(token).digest('hex');
@@ -25,16 +25,6 @@ export function registerKey(key: string, agentId: string): void {
   agentIdByKeyHash.set(digest(key), agentId);
 }
 
-export function unregisterAgentKey(agentId: string): void {
-  for (const [hash, id] of agentIdByKeyHash)
-    if (id === agentId) agentIdByKeyHash.delete(hash);
-}
-
-export function rotateAgentKey(agentId: string, key: string | null): void {
-  unregisterAgentKey(agentId);
-  if (key !== null) registerKey(key, agentId);
-}
-
 export function agentIdForKey(token: string): string | undefined {
   if (token === '') return undefined;
   return agentIdByKeyHash.get(digest(token));

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

@@ -0,0 +1,135 @@
+export type AgentMap = Record<string, string>;
+export type AgentNameMap = Record<string, string>;
+export type AllowlistMap = Record<string, string[]>;
+
+const mapKey = (station: string, accountId: string): string =>
+  `${station}/${accountId}`;
+
+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;
+  agentNames = names;
+}
+
+export const knownAgentIds = (): string[] => Object.keys(agentNames);
+
+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 lineReceives(line: string): boolean {
+  const a = accountFromLine(line);
+  return a === undefined || accountEnabled(a.station, a.accountId);
+}
+
+export function accountFromLine(
+  line: string,
+): { station: string; accountId: string } | undefined {
+  const parts = line.split('/');
+  const station = parts[2];
+  const accountId = parts[3];
+  if (!station || !accountId) return undefined;
+  return { station, accountId };
+}
+
+export function agentIdForAccount(
+  station: string,
+  accountId: string,
+): string | undefined {
+  return agentMap[mapKey(station, accountId)];
+}
+
+export function agentIdForLine(line: string): string | undefined {
+  const a = accountFromLine(line);
+  return a ? agentIdForAccount(a.station, a.accountId) : undefined;
+}
+
+export function agentForLine(line: string): string | undefined {
+  const id = agentIdForLine(line);
+  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)
+    .filter(([key]) => key.startsWith(prefix))
+    .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,
+): boolean {
+  if (allowlist.length === 0 || allowlist.includes('*')) return true;
+  const f = (from ?? '').toLowerCase();
+  const id = f.split('/').pop() ?? f;
+  return allowlist.some((a) => {
+    const v = a.toLowerCase();
+    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,94 @@
+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;
+  avatar?: 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);
+
+const AVATAR_DATA_MAX = 100_000;
+
+const shownAvatar = (avatar: string): boolean =>
+  avatar.startsWith('https://') || (avatar.startsWith('data:image/') && avatar.length <= AVATAR_DATA_MAX);
+
+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;
+  const avatar = filled(p.avatar);
+  return {
+    id,
+    ...(name === undefined ? {} : { name }),
+    ...(handle === undefined || handle === name ? {} : { handle }),
+    ...(avatar !== undefined && shownAvatar(avatar) ? { avatar } : {}),
+  };
+}
+
+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/owner-line.ts

@@ -0,0 +1,45 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+
+export interface OwnerLine {
+  line: string;
+  from: string;
+}
+
+let file: string | undefined;
+let known: OwnerLine | undefined;
+let saved: string | undefined;
+
+const textOf = (owner: OwnerLine): string => JSON.stringify({ line: owner.line, from: owner.from });
+
+function parse(raw: unknown): OwnerLine | undefined {
+  if (!isRecord(raw) || typeof raw.line !== 'string' || typeof raw.from !== 'string') return undefined;
+  return raw.line.startsWith('metro://') && raw.from.startsWith('metro://') ? { line: raw.line, from: raw.from } : undefined;
+}
+
+export function setOwnerLineFile(path: string): void {
+  file = path;
+  known = parse(readJson<unknown>(path, null, { warn: 'approvals: the owner chat file is not valid JSON, so it was ignored' }));
+  saved = known === undefined ? undefined : textOf(known);
+}
+
+export const ownerLine = (): OwnerLine | undefined => known;
+
+export function noteOwnerLine(line: string, from: string): void {
+  known = { line, from };
+  const next = textOf(known);
+  if (file === undefined || next === saved) return;
+  try {
+    writeSecure(file, `${next}\n`);
+    saved = next;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'approvals: the owner chat could not be saved, so it is kept in memory only');
+  }
+}
+
+export function forgetOwnerLine(): void {
+  file = undefined;
+  known = undefined;
+  saved = undefined;
+}