@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/schedule-detail.ts

@@ -0,0 +1,93 @@
+import { spawn } from 'node:child_process';
+import { readAsAgent } from './agent-fs.js';
+import { ApiError } from '@metro-labs/http/api-error';
+import { log } from '@metro-labs/core/log';
+import { listSchedules, realRunner, showProps, type Runner, type ScheduledJob } from './schedules.js';
+import { asUser, type AgentUser } from './user.js';
+
+const LOG_LINES = 80;
+const TAIL_BYTES = 64 * 1024;
+
+export interface JobDetail extends ScheduledJob {
+  definition: string;
+  logs: string;
+  logSource: string | null;
+  script: { path: string; text: string } | null;
+}
+
+const SCRIPT_MAX = 64 * 1024;
+
+function textFile(path: string): string | null {
+  const bytes = readAsAgent(path, SCRIPT_MAX + 1);
+  if (bytes === null || bytes.length > SCRIPT_MAX) return null;
+  const text = bytes.toString('utf8');
+  return text.includes('\u0000') ? null : text;
+}
+
+export function scriptOf(command: string): { path: string; text: string } | null {
+  const words = command.split(/\s+/).filter((w) => w.startsWith('/') && !w.includes('>')).slice(0, 3);
+  for (const path of [...words.filter((w) => w.endsWith('.md')), ...words]) {
+    const text = textFile(path);
+    if (text !== null) return { path, text };
+  }
+  return null;
+}
+
+function findJob(id: string, user: AgentUser | null, runner: Runner): ScheduledJob {
+  const job = listSchedules(user, runner).find((j) => j.id === id);
+  if (job === undefined) throw new ApiError('no such scheduled job', 404);
+  return job;
+}
+
+const serviceOf = (unit: string, runner: Runner): string => showProps(runner, unit, ['Unit']).Unit ?? unit.replace(/\.timer$/, '.service');
+
+export function logFileOf(command: string): string | null {
+  const m = /(?:^|\s)(?:>>|>)\s*(\/\S+)/.exec(command);
+  return m?.[1] ?? null;
+}
+
+function tail(path: string | null): string {
+  const bytes = path === null ? null : readAsAgent(path, TAIL_BYTES);
+  return bytes === null ? '' : bytes.toString('utf8').split('\n').slice(-LOG_LINES).join('\n');
+}
+
+function timerDetail(job: ScheduledJob, runner: Runner): JobDetail {
+  const unit = job.id.slice('timer:'.length);
+  const service = serviceOf(unit, runner);
+  return {
+    ...job,
+    definition: runner.run('systemctl', ['cat', unit, service, '--no-pager']).stdout,
+    logs: runner.run('journalctl', ['-u', service, '-n', String(LOG_LINES), '--no-pager', '-o', 'short-iso']).stdout,
+    logSource: `journalctl -u ${service}`,
+    script: scriptOf(job.command),
+  };
+}
+
+function cronDetail(job: ScheduledJob): JobDetail {
+  const file = logFileOf(job.command);
+  return {
+    ...job,
+    definition: `${job.schedule} ${job.command}`,
+    logs: tail(file),
+    logSource: file,
+    script: scriptOf(job.command),
+  };
+}
+
+export function scheduleDetail(id: string, user: AgentUser | null, runner: Runner = realRunner): JobDetail {
+  const job = findJob(id, user, runner);
+  return job.kind === 'timer' ? timerDetail(job, runner) : cronDetail(job);
+}
+
+export function runNow(id: string, user: AgentUser | null, runner: Runner = realRunner): JobDetail {
+  const job = findJob(id, user, runner);
+  if (job.kind === 'timer') runner.run('systemctl', ['start', '--no-block', serviceOf(job.id.slice('timer:'.length), runner)]);
+  else {
+    if (user === null) throw new ApiError('Claude Code does not run as its own user on this machine', 409);
+    const [file, args] = asUser(user, 'sh', ['-c', `cd "$HOME" && ${job.command}`]);
+    const child = spawn(file, args, { detached: true, stdio: 'ignore', cwd: '/' });
+    child.unref();
+  }
+  log.info({ job: job.name }, 'schedules: run now, from the page');
+  return scheduleDetail(id, user, runner);
+}

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/schedules-api.ts

@@ -0,0 +1,27 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { bodyField, readJsonBody, sessionRoute } from '@metro-labs/http/api-http';
+import { listSchedules } from './schedules.js';
+import { runNow, scheduleDetail } from './schedule-detail.js';
+import { agentUser } from './user.js';
+
+const PATH = '/api/schedules';
+
+const queryId = (req: IncomingMessage): string | null => new URLSearchParams((req.url ?? '').split('?')[1] ?? '').get('id');
+
+async function answer(req: IncomingMessage): Promise<unknown> {
+  const user = agentUser();
+  if (req.method === 'GET') {
+    const id = queryId(req);
+    return id === null ? { agentUser: user?.name ?? null, jobs: listSchedules(user) } : { job: scheduleDetail(id, user) };
+  }
+  const body = await readJsonBody(req);
+  const id = bodyField(body, 'id');
+  if (typeof id !== 'string' || id === '') throw new ApiError('id is required', 400);
+  if (bodyField(body, 'action') !== 'run') throw new ApiError('action must be run', 400);
+  return { job: runNow(id, user) };
+}
+
+export function handleSchedulesRequest(req: IncomingMessage, res: ServerResponse): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET', 'POST'] }, admin: true, label: 'schedules-api' }, () => answer(req));
+}

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/schedules.ts

@@ -0,0 +1,144 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { isRecord } from '@metro-labs/core/is-record';
+import type { AgentUser } from './user.js';
+import { helperRun, type RunResult } from './unit-files.js';
+
+const UNIT_DIR = '/etc/systemd/system';
+const OWN_UNITS = /^metro(-claude-\d+)?\.(service|scope)$/;
+
+type JobKind = 'timer' | 'cron-agent';
+
+export interface ScheduledJob {
+  id: string;
+  kind: JobKind;
+  name: string;
+  schedule: string;
+  command: string;
+  runsAs: string;
+  next: string | null;
+  last: string | null;
+  lastResult: string | null;
+}
+
+export interface Runner {
+  run: (file: string, args: string[], input?: string) => RunResult;
+}
+
+export const realRunner: Runner = {
+  run: (file, args, input) => {
+    const viaHelper = helperRun(file, args, input);
+    if (viaHelper !== null) return viaHelper;
+    const done = spawnSync(file, args, { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'pipe'], timeout: 20_000 });
+    return { status: done.error === undefined ? done.status : null, stdout: done.stdout ?? '', stderr: done.stderr ?? '' };
+  },
+};
+
+const stamp = (micros: unknown): string | null =>
+  typeof micros === 'number' && micros > 0 ? new Date(micros / 1000).toISOString() : null;
+
+export function showProps(runner: Runner, unit: string, props: string[]): Record<string, string> {
+  const out = runner.run('systemctl', ['show', unit, '--no-pager', ...props.map((p) => `-p${p}`)]).stdout;
+  const found: Record<string, string> = {};
+  for (const line of out.split('\n')) {
+    const at = line.indexOf('=');
+    if (at > 0) found[line.slice(0, at)] = line.slice(at + 1);
+  }
+  return found;
+}
+
+function execArgv(execStart: string): string[] {
+  const m = /argv\[\]=(.*?) ;/.exec(execStart);
+  return m?.[1] === undefined ? [] : m[1].split(' ').filter((a) => a !== '');
+}
+
+export const calendarOf = (timers: string): string =>
+  /OnCalendar=([^;]*?) ;/.exec(timers)?.[1]?.trim() ?? /(OnUnitActiveUSec|OnBootUSec|OnActiveUSec)=([^;]*?) ;/.exec(timers)?.[0]?.replace(/ ;$/, '') ?? '';
+
+function listTimers(runner: Runner): Record<string, unknown>[] {
+  try {
+    const raw: unknown = JSON.parse(runner.run('systemctl', ['list-timers', '--all', '--output=json', '--no-pager']).stdout);
+    return Array.isArray(raw) ? raw.filter(isRecord) : [];
+  } catch {
+    return [];
+  }
+}
+
+const text = (v: unknown): string => (typeof v === 'string' ? v : '');
+const orRoot = (user: string | undefined): string => (user === undefined || user === '' ? 'root' : user);
+
+function timerJob(runner: Runner, t: Record<string, unknown>): ScheduledJob | null {
+  const unit = text(t.unit);
+  const service = text(t.activates);
+  if (unit === '' || service === '' || OWN_UNITS.test(service)) return null;
+  const timer = showProps(runner, unit, ['FragmentPath', 'TimersCalendar', 'TimersMonotonic']);
+  if (!text(timer.FragmentPath).startsWith(`${UNIT_DIR}/`)) return null;
+  const svc = showProps(runner, service, ['ExecStart', 'User', 'Result']);
+  const command = execArgv(text(svc.ExecStart)).join(' ');
+  return {
+    id: `timer:${unit}`,
+    kind: 'timer',
+    name: unit.replace(/\.timer$/, ''),
+    schedule: calendarOf(`${text(timer.TimersCalendar)} ${text(timer.TimersMonotonic)}`),
+    command,
+    runsAs: orRoot(svc.User),
+    next: stamp(t.next),
+    last: stamp(t.last),
+    lastResult: svc.Result ?? null,
+  };
+}
+
+const timerJobs = (runner: Runner): ScheduledJob[] =>
+  listTimers(runner).flatMap((t) => {
+    const job = timerJob(runner, t);
+    return job === null ? [] : [job];
+  });
+
+export interface CronLine {
+  schedule: string;
+  command: string;
+}
+
+export function parseCronLine(line: string): CronLine | null {
+  const text = line.trim();
+  if (text === '' || text.startsWith('#') || /^[A-Za-z_][A-Za-z0-9_]*=/.test(text)) return null;
+  if (text.startsWith('@')) {
+    const [at = '', ...rest] = text.split(/\s+/);
+    return rest.length === 0 ? null : { schedule: at, command: rest.join(' ') };
+  }
+  const parts = text.split(/\s+/);
+  if (parts.length < 6) return null;
+  return { schedule: parts.slice(0, 5).join(' '), command: parts.slice(5).join(' ') };
+}
+
+const lineId = (kind: JobKind, line: string): string => `${kind}:${createHash('sha256').update(line.trim()).digest('hex').slice(0, 16)}`;
+
+function crontabOf(runner: Runner, user: string): string[] {
+  const out = runner.run('crontab', ['-l', '-u', user]);
+  return out.status === 0 ? out.stdout.split('\n') : [];
+}
+
+function cronJobs(runner: Runner, user: string, kind: JobKind): ScheduledJob[] {
+  return crontabOf(runner, user).flatMap((line): ScheduledJob[] => {
+    const parsed = parseCronLine(line);
+    if (parsed === null) return [];
+    return [{
+      id: lineId(kind, line),
+      kind,
+      name: parsed.command.split(/\s+/)[0]?.split('/').pop() ?? 'cron',
+      schedule: parsed.schedule,
+      command: parsed.command,
+      runsAs: user,
+      next: null,
+      last: null,
+      lastResult: null,
+    }];
+  });
+}
+
+function allJobs(user: AgentUser | null, runner: Runner): ScheduledJob[] {
+  return [...timerJobs(runner), ...(user === null ? [] : cronJobs(runner, user.name, 'cron-agent'))];
+}
+
+export const listSchedules = (user: AgentUser | null, runner: Runner = realRunner): ScheduledJob[] =>
+  allJobs(user, runner).filter((job) => job.runsAs !== 'root');

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/unit-files.ts

@@ -0,0 +1,43 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { mustHelper, rootHelper } from '../metro-user/privilege.js';
+import { agentUser, asUser } from './user.js';
+
+const UNIT_DIR = '/etc/systemd/system';
+
+export interface RunResult {
+  status: number | null;
+  stdout: string;
+  stderr?: string;
+}
+
+export function writeDropIn(service: string, name: string, text: string): void {
+  mustHelper(['dropin-write', service, name], text);
+}
+
+export function removeDropIn(service: string, name: string): boolean {
+  if (!existsSync(join(UNIT_DIR, `${service}.d`, name))) return false;
+  mustHelper(['dropin-remove', service, name]);
+  return true;
+}
+
+function agentCrontab(args: string[], input?: string): RunResult {
+  const at = args.indexOf('-u');
+  const rest = at < 0 ? args : args.filter((_, i) => i !== at && i !== at + 1);
+  const [file, argv] = asUser(agentUser(), 'crontab', rest);
+  const run = spawnSync(file, argv, { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'pipe'], timeout: 20_000 });
+  return { status: run.error === undefined ? run.status : null, stdout: run.stdout ?? '', stderr: run.stderr ?? '' };
+}
+
+function systemctl(args: string[]): { status: number | null; stdout: string } | null {
+  if (args[0] === 'daemon-reload') return { status: rootHelper(['daemon-reload']).status, stdout: '' };
+  if (args[0] === 'start') return { status: rootHelper(['start-job', args[args.length - 1] ?? '']).status, stdout: '' };
+  return null;
+}
+
+export function helperRun(file: string, args: string[], input?: string): RunResult | null {
+  if (file === 'crontab') return agentCrontab(args, input);
+  if (file === 'systemctl') return systemctl(args);
+  return null;
+}

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

@@ -0,0 +1,91 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { runningAsMetro } from '../metro-user/privilege.js';
+
+export const AGENT_NAME = 'agent';
+const AGENT_PATH = ['.local/bin', '/usr/local/sbin', '/usr/local/bin', '/usr/sbin', '/usr/bin', '/sbin', '/bin'];
+
+export interface AgentUser {
+  name: string;
+  uid: number;
+  gid: number;
+  home: string;
+}
+
+export interface UserHost {
+  metro: boolean;
+  lookup: (name: string) => AgentUser | null;
+}
+
+function lookupUser(name: string): AgentUser | null {
+  const run = spawnSync('getent', ['passwd', name], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  if (run.error !== undefined || run.status !== 0) return null;
+  const [, , uid = '', gid = '', , home = ''] = run.stdout.trim().split(':');
+  const u = Number(uid);
+  const g = Number(gid);
+  return Number.isInteger(u) && u > 0 && Number.isInteger(g) && home.startsWith('/') ? { name, uid: u, gid: g, home } : null;
+}
+
+const realHost = (): UserHost => ({ metro: runningAsMetro(), lookup: lookupUser });
+
+export const agentUserExpected = (host: UserHost = realHost()): boolean => host.metro;
+
+let cached: AgentUser | null = null;
+
+export function agentUser(host: UserHost = realHost()): AgentUser | null {
+  if (!agentUserExpected(host)) return null;
+  cached ??= host.lookup(AGENT_NAME);
+  return cached;
+}
+
+export function forgetAgentUser(): void {
+  cached = null;
+}
+
+let extraEnv: Record<string, string> = {};
+
+export function setAgentExtraEnv(env: Record<string, string>): void {
+  extraEnv = { ...env };
+}
+
+export const agentExtraEnv = (): Record<string, string> => ({ ...extraEnv });
+
+export const agentPath = (user: AgentUser): string => AGENT_PATH.map((p) => (p.startsWith('/') ? p : join(user.home, p))).join(':');
+
+function agentEnv(user: AgentUser, extra: Record<string, string> = {}): Record<string, string> {
+  return {
+    HOME: user.home,
+    USER: user.name,
+    LOGNAME: user.name,
+    SHELL: '/bin/bash',
+    LANG: process.env.LANG ?? 'C.UTF-8',
+    TERM: process.env.TERM ?? 'xterm-256color',
+    PATH: agentPath(user),
+    ...extraEnv,
+    ...extra,
+  };
+}
+
+export function asUser(user: AgentUser | null, file: string, args: readonly string[], extra: Record<string, string> = {}): [string, string[]] {
+  if (user === null) return [file, [...args]];
+  const env = Object.entries(agentEnv(user, extra)).map(([k, v]) => `${k}=${v}`);
+  return ['sudo', ['-n', '-u', user.name, '--', 'env', '-i', ...env, file, ...args]];
+}
+
+export const asAgent = (file: string, args: readonly string[], extra: Record<string, string> = {}): [string, string[]] =>
+  asUser(agentUser(), file, args, extra);
+
+export const agentCommand = (command: readonly string[], extra: Record<string, string> = {}): string[] => {
+  const [file = '', ...args] = command;
+  const [bin, argv] = asAgent(file, args, extra);
+  return [bin, ...argv];
+};
+
+export function claudeBin(user = agentUser()): string {
+  return user === null ? 'claude' : join(user.home, '.local', 'bin', 'claude');
+}
+
+export const claudeHome = (user = agentUser()): string | null => (user === null ? null : user.home);
+
+export const agentMarketplaceDir = (user: AgentUser): string => join(user.home, '.metro', 'marketplace');
+export const agentViewDir = (user: AgentUser): string => join(user.home, '.metro', 'agents');

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/view.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { agentsDir } from '../agents/files.js';
+import { removeHome, writeHomeText } from './home-fs.js';
+import { closeMetroHome } from './metro-home.js';
+import { agentUser, agentViewDir, type AgentUser } from './user.js';
+
+const COPIED = ['policy.json', 'claude-setup.json', 'system-prompt.md'] as const;
+const SYNC_MS = 5_000;
+
+const readText = (path: string): string | null => {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return null;
+  }
+};
+
+const readRecord = (path: string): Record<string, unknown> | null => {
+  const text = readText(path);
+  if (text === null) return null;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+
+const json = (value: unknown): string => `${JSON.stringify(value, null, 2)}\n`;
+
+function agentFile(dir: string): string | null {
+  const file = readRecord(join(dir, 'agent.json'));
+  if (file === null || typeof file.id !== 'string' || typeof file.key !== 'string') return null;
+  return json({ version: 1, id: file.id, key: file.key });
+}
+
+function modelFile(dir: string): string | null {
+  const cfg = readRecord(join(dir, 'model.json'));
+  if (cfg === null || !Array.isArray(cfg.connections)) return null;
+  const connections = cfg.connections.filter(isRecord).map((c) => ({ id: c.id, provider: c.provider, model: c.model }));
+  return json({ version: 2, route: cfg.route, connections });
+}
+
+export function viewFiles(dir = agentsDir()): Map<string, string | null> {
+  const files = new Map<string, string | null>([
+    ['agent.json', agentFile(dir)],
+    ['model.json', modelFile(dir)],
+  ]);
+  for (const name of COPIED) files.set(name, existsSync(join(dir, name)) ? readText(join(dir, name)) : null);
+  return files;
+}
+
+const written = new Map<string, string | null>();
+
+export function syncAgentView(user: AgentUser | null = agentUser(), dir = agentsDir()): number {
+  if (user === null) return 0;
+  const target = agentViewDir(user);
+  let changed = 0;
+  for (const [name, text] of viewFiles(dir)) {
+    const path = join(target, name);
+    if (written.has(path) && written.get(path) === text) continue;
+    if (text === null) removeHome(path, false, user);
+    else writeHomeText(path, text, 0o600, undefined, user);
+    written.set(path, text);
+    changed += 1;
+  }
+  return changed;
+}
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+export function watchAgentView(everyMs = SYNC_MS): void {
+  if (timer !== null) return;
+  const tick = (): void => {
+    try {
+      const changed = syncAgentView();
+      if (changed > 0) log.info({ changed }, 'agent-user: refreshed the Metro files the agent may read');
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'agent-user: could not refresh the Metro files the agent may read');
+    }
+    try {
+      closeMetroHome();
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'agent-user: could not close the metro home');
+    }
+  };
+  tick();
+  timer = setInterval(tick, everyMs);
+  timer.unref();
+}

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

@@ -0,0 +1,19 @@
+import { STATIONS, type StationName } from '@metro-labs/core/station-names';
+
+const ACCOUNT_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+
+export interface AccountRef {
+  agentId: string;
+  station: StationName;
+  accountId: string;
+}
+
+export function isStationName(raw: unknown): raw is StationName {
+  return (
+    typeof raw === 'string' && (STATIONS as readonly string[]).includes(raw)
+  );
+}
+
+export function parseAccountId(raw: string): string | null {
+  return ACCOUNT_ID_RE.test(raw) ? raw : null;
+}

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;
+}
+
+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('something 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

@@ -0,0 +1,76 @@
+import { isStationName, parseAccountId } from './account-attach.js';
+import type { StationName } from '@metro-labs/core/station-names';
+import { ATTACH_ID_RE } from '../stations/attach-session.js';
+
+export type AccountRoute =
+  | { kind: 'start' }
+  | { kind: 'session'; attachId: string }
+  | { kind: 'step'; attachId: string }
+  | { kind: 'account'; station: StationName; accountId: string }
+  | { kind: 'allowlist'; station: StationName; accountId: string }
+  | { kind: 'senders'; station: StationName; accountId: string }
+  | { 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[]> = {
+  start: ['POST'],
+  session: ['GET', 'DELETE'],
+  step: ['POST'],
+  account: ['DELETE'],
+  allowlist: ['PUT'],
+  senders: ['GET'],
+  resolve: ['GET'],
+  enabled: ['PUT'],
+  policy: ['PUT'],
+  profiles: ['GET'],
+  name: ['GET', 'POST'],
+};
+
+const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy', 'profiles'] as const;
+
+type SubRoute = (typeof SUB_ROUTES)[number];
+
+const isSubRoute = (value: string | undefined): value is SubRoute =>
+  SUB_ROUTES.some((sub) => sub === value);
+
+function twoSegmentRoute(head: string, tail: string): AccountRoute | null {
+  if (ATTACH_ID_RE.test(head))
+    return tail === 'step' ? { kind: 'step', attachId: head } : null;
+  if (!isStationName(head)) return null;
+  const accountId = parseAccountId(tail);
+  return accountId === null ? null : { kind: 'account', station: head, accountId };
+}
+
+function accountSubRoute(
+  head: string,
+  tail: string,
+  sub: string | undefined,
+): AccountRoute | null {
+  if (!isStationName(head) || !isSubRoute(sub)) return null;
+  const accountId = parseAccountId(tail);
+  return accountId === null ? null : { kind: sub, station: head, accountId };
+}
+
+export function accountRoute(rest: string[]): AccountRoute | null {
+  const [head, tail] = rest;
+  if (head === undefined) return null;
+  if (rest.length === 1)
+    return head === 'start'
+      ? { kind: 'start' }
+      : 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);
+}
+
+export function accountRouteAllows(
+  route: AccountRoute,
+  method: string | undefined,
+): boolean {
+  return ROUTE_METHODS[route.kind].includes(method ?? '');
+}