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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.195",
+  "version": "0.1.0-beta.197",
   "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.195",
+  "version": "0.1.0-beta.197",
   "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/agent-user/files-api.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { sessionRoute } from '@metro-labs/http/api-http';
+import { readAgentPath } from './files.js';
+import { agentUser } from './user.js';
+
+const PATH = '/api/files';
+
+const queryPath = (req: IncomingMessage): string => new URLSearchParams((req.url ?? '').split('?')[1] ?? '').get('path') ?? '';
+
+export function handleFilesRequest(req: IncomingMessage, res: ServerResponse): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET'] }, admin: true, label: 'files-api' }, () => Promise.resolve(readAgentPath(agentUser(), queryPath(req))));
+}

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

@@ -0,0 +1,117 @@
+import { spawnSync } from 'node:child_process';
+import { closeSync, openSync, readdirSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { asUser, type AgentUser } from './user.js';
+
+export type EntryKind = 'folder' | 'file' | 'other';
+
+export interface FileEntry {
+  name: string;
+  kind: EntryKind;
+  bytes: number;
+  modifiedAt: string;
+}
+
+export type FilesAnswer =
+  | { root: string; path: string; kind: 'folder'; entries: FileEntry[]; more: boolean }
+  | { root: string; path: string; kind: 'file'; bytes: number; modifiedAt: string; text: string | null; truncated: boolean };
+
+const MAX_ENTRIES = 2000;
+const PREVIEW_BYTES = 256 * 1024;
+const SNIFF_BYTES = 8192;
+
+const SCRIPT = [
+  'if [ -d "$1" ]; then',
+  '  printf "D\\0"; find -H "$1" -mindepth 1 -maxdepth 1 -printf "%y\\0%s\\0%T@\\0%f\\0"',
+  'elif [ -f "$1" ]; then',
+  '  printf "F\\0"; stat -L -c "%s %Y" -- "$1" | tr "\\n" "\\0"; head -c "$2" -- "$1"',
+  'else',
+  '  echo "no such file or folder" >&2; exit 2',
+  'fi',
+].join('\n');
+
+export function segmentsOf(path: string): string[] {
+  const parts = path.split('/').filter((part) => part !== '');
+  if (parts.some((part) => part === '.' || part === '..' || part.includes('\0')))
+    throw new ApiError('that path is not inside the home folder', 400);
+  return parts;
+}
+
+const stamp = (seconds: number): string => (Number.isFinite(seconds) && seconds > 0 ? new Date(seconds * 1000).toISOString() : '');
+
+const kindOf = (letter: string): EntryKind => (letter === 'd' ? 'folder' : letter === 'f' ? 'file' : 'other');
+
+const byKindThenName = (a: FileEntry, b: FileEntry): number =>
+  a.kind === 'folder' && b.kind !== 'folder' ? -1 : b.kind === 'folder' && a.kind !== 'folder' ? 1 : a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: 'base' });
+
+function preview(bytes: Buffer, size: number): { text: string | null; truncated: boolean } {
+  const binary = bytes.subarray(0, SNIFF_BYTES).includes(0);
+  return { text: binary ? null : bytes.subarray(0, PREVIEW_BYTES).toString('utf8'), truncated: size > PREVIEW_BYTES };
+}
+
+function folderAnswer(root: string, path: string, entries: FileEntry[]): FilesAnswer {
+  const sorted = entries.sort(byKindThenName);
+  return { root, path, kind: 'folder', entries: sorted.slice(0, MAX_ENTRIES), more: sorted.length > MAX_ENTRIES };
+}
+
+function parseListing(out: Buffer): FileEntry[] {
+  const fields = out.toString('utf8').split('\0');
+  const entries: FileEntry[] = [];
+  for (let at = 0; at + 3 < fields.length; at += 4)
+    entries.push({ kind: kindOf(fields[at] ?? ''), bytes: Number(fields[at + 1]), modifiedAt: stamp(Number(fields[at + 2])), name: fields[at + 3] ?? '' });
+  return entries;
+}
+
+function parseFile(root: string, path: string, out: Buffer): FilesAnswer {
+  const end = out.indexOf(0);
+  const [size = '0', mtime = '0'] = out.subarray(0, end).toString('utf8').trim().split(' ');
+  const bytes = Number(size);
+  return { root, path, kind: 'file', bytes, modifiedAt: stamp(Number(mtime)), ...preview(out.subarray(end + 1), bytes) };
+}
+
+function readAsAgent(user: AgentUser, path: string): FilesAnswer {
+  const target = join(user.home, ...segmentsOf(path));
+  const [file, argv] = asUser(user, 'sh', ['-c', SCRIPT, 'metro', target, String(PREVIEW_BYTES + 1)]);
+  const run = spawnSync(file, argv, { stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024, timeout: 20_000 });
+  if (run.error !== undefined) throw new ApiError(`could not read that path: ${run.error.message}`, 500);
+  if (run.status !== 0) throw new ApiError(run.stderr.toString('utf8').trim() || 'the agent cannot read that path', 404);
+  const out = run.stdout;
+  const body = out.subarray(2);
+  return out.subarray(0, 1).toString() === 'D' ? folderAnswer(user.home, path, parseListing(body)) : parseFile(user.home, path, body);
+}
+
+function readHead(target: string): Buffer {
+  const fd = openSync(target, 'r');
+  try {
+    const buffer = Buffer.alloc(PREVIEW_BYTES + 1);
+    return buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, 0));
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function readLocal(root: string, path: string): FilesAnswer {
+  const target = join(root, ...segmentsOf(path));
+  let stat;
+  try {
+    stat = statSync(target);
+  } catch {
+    throw new ApiError('no such file or folder', 404);
+  }
+  if (stat.isFile()) return { root, path, kind: 'file', bytes: stat.size, modifiedAt: stat.mtime.toISOString(), ...preview(readHead(target), stat.size) };
+  const entries = readdirSync(target, { withFileTypes: true }).map((entry): FileEntry => {
+    const inner = join(target, entry.name);
+    try {
+      const s = statSync(inner);
+      return { name: entry.name, kind: s.isDirectory() ? 'folder' : s.isFile() ? 'file' : 'other', bytes: s.size, modifiedAt: s.mtime.toISOString() };
+    } catch {
+      return { name: entry.name, kind: 'other', bytes: 0, modifiedAt: '' };
+    }
+  });
+  return folderAnswer(root, path, entries);
+}
+
+export const readAgentPath = (user: AgentUser | null, path: string, localRoot = homedir()): FilesAnswer =>
+  user === null ? readLocal(localRoot, path) : readAsAgent(user, path);

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

@@ -0,0 +1,57 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { log } from '@metro-labs/core/log';
+import { writeHomeText } from './home-fs.js';
+import { listSchedules, realRunner, showProps, type Runner } from './schedules.js';
+import type { AgentUser } from './user.js';
+
+const UNIT_DIR = '/etc/systemd/system';
+const DROP_IN = '11-metro-vault.conf';
+const BEGIN = '# metro vault: begin';
+const END = '# metro vault: end';
+
+export const jobEnvFile = (user: AgentUser): string => join(user.home, '.metro', 'vault.env');
+
+export function withCronEnv(lines: string[], env: Record<string, string>): string[] {
+  const start = lines.indexOf(BEGIN);
+  const stop = lines.indexOf(END);
+  const rest = start >= 0 && stop > start ? [...lines.slice(0, start), ...lines.slice(stop + 1)] : lines;
+  const kept = rest.filter((l) => l !== '');
+  const block = Object.entries(env).map(([k, v]) => `${k}=${v}`);
+  return block.length === 0 ? kept : [BEGIN, ...block, END, ...kept];
+}
+
+function setCronEnv(user: AgentUser, env: Record<string, string>, runner: Runner): void {
+  const out = runner.run('crontab', ['-l', '-u', user.name]);
+  const lines = out.status === 0 ? out.stdout.split('\n') : [];
+  const next = withCronEnv(lines, env);
+  if (next.join('\n') === lines.filter((l) => l !== '').join('\n')) return;
+  runner.run('crontab', ['-u', user.name, '-'], next.length === 0 ? '' : `${next.join('\n')}\n`);
+}
+
+function setTimerEnv(user: AgentUser, on: boolean, runner: Runner): void {
+  let changed = false;
+  for (const job of listSchedules(user, runner)) {
+    if (job.kind !== 'timer' || job.runsAs !== user.name) continue;
+    const unit = job.id.slice('timer:'.length);
+    const service = showProps(runner, unit, ['Unit']).Unit ?? unit.replace(/\.timer$/, '.service');
+    const file = join(UNIT_DIR, `${service}.d`, DROP_IN);
+    if (on) {
+      mkdirSync(join(UNIT_DIR, `${service}.d`), { recursive: true });
+      writeFileSync(file, `[Service]\nEnvironmentFile=-${jobEnvFile(user)}\n`, { mode: 0o644 });
+      changed = true;
+    } else if (existsSync(file)) {
+      rmSync(file, { force: true });
+      changed = true;
+    }
+  }
+  if (changed) runner.run('systemctl', ['daemon-reload']);
+}
+
+export function exportJobEnv(user: AgentUser, env: Record<string, string>, runner: Runner = realRunner): void {
+  const on = Object.keys(env).length > 0;
+  writeHomeText(jobEnvFile(user), Object.entries(env).map(([k, v]) => `${k}=${v}\n`).join(''), 0o644);
+  setCronEnv(user, env, runner);
+  setTimerEnv(user, on, runner);
+  log.info({ on, keys: Object.keys(env).length }, "vault: the agent's scheduled jobs use the vault settings");
+}

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

@@ -42,6 +42,14 @@ 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 function agentEnv(user: AgentUser, extra: Record<string, string> = {}): Record<string, string> {
   return {
     HOME: user.home,
@@ -51,6 +59,7 @@ export function agentEnv(user: AgentUser, extra: Record<string, string> = {}): R
     LANG: process.env.LANG ?? 'C.UTF-8',
     TERM: process.env.TERM ?? 'xterm-256color',
     PATH: AGENT_PATH.map((p) => (p.startsWith('/') ? p : join(user.home, p))).join(':'),
+    ...extraEnv,
     ...extra,
   };
 }

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

@@ -10,6 +10,7 @@ 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 { unconfirmedSenders } from './sender-cards.js';
 import { stationByName } from '../stations/registry.js';
 import type { StationName } from '@metro-labs/core/station-names';
 import {
@@ -243,6 +244,9 @@ async function handleAllowlist(
   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 before = new Set(approversForAccount(target.station, target.accountId).map((a) => a.toLowerCase()));
+  const unknown = await unconfirmedSenders(deps, target.station, target.accountId, approvers.filter((a) => !before.has(a.toLowerCase())));
+  if (unknown.length > 0) throw new ApiError(`${target.station} does not know ${unknown.join(', ')}. Check the id, or have them write to the agent once, then try again.`, 400);
   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, {

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

@@ -64,6 +64,18 @@ export async function senderCards(deps: SenderCardDeps, station: StationName, ac
   );
 }
 
+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,

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

@@ -25,6 +25,7 @@ import { loadConnectorPolicies, readLocalConnectors } from '../connectors/store.
 import { ensureMetroPlugin } from '../claude/plugin-install.js';
 import { provisionAgentUser } from '../agent-user/provision.js';
 import { convertRootJobs } from '../agent-user/schedules.js';
+import { applyVault } from '../vault/index.js';
 import { agentUser as currentAgentUser } from '../agent-user/user.js';
 import { ensureServiceOomPolicy } from '../claude/memory.js';
 import { unwatchSession, watchSession } from '../claude/session.js';
@@ -164,6 +165,8 @@ async function startClaude(): Promise<void> {
   if (agentUser === 'ready') {
     const switched = convertRootJobs(currentAgentUser());
     if (switched > 0) log.info({ switched }, "schedules: jobs that pointed into root's home now run as the agent user");
+    const vault = (await applyVault()).status;
+    if (vault.enabled) log.info({ running: vault.running, problem: vault.problem }, 'vault: the agent reaches the internet through the vault');
   }
   ensureMetroPlugin()
     .then((outcome) => {

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

@@ -12,13 +12,13 @@ import { claudeDir, listClaudeProjects } from './files.js';
 import { claudeAccount, claudeInstalled } from './login.js';
 import { trustFolder } from './onboarding.js';
 import { inSessionScope } from './memory.js';
-import { agentUser, agentUserExpected, agentViewDir, asAgent, claudeHome } from '../agent-user/user.js';
+import { agentExtraEnv, agentUser, agentUserExpected, agentViewDir, asAgent, claudeHome } from '../agent-user/user.js';
 
 function sessionEnv(): Record<string, string> {
   const user = agentUser();
   if (user === null) return {};
   const port = process.env.METRO_WEBHOOK_PORT?.trim() ?? '';
-  return { METRO_AGENTS_DIR: agentViewDir(user), ...(port === '' ? {} : { METRO_WEBHOOK_PORT: port }) };
+  return { ...agentExtraEnv(), METRO_AGENTS_DIR: agentViewDir(user), ...(port === '' ? {} : { METRO_WEBHOOK_PORT: port }) };
 }
 
 export const SESSION_NAME = 'metro';

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

@@ -13,7 +13,7 @@ export const GET_PROFILE_TOOL: ToolDef = {
     '(`metro://<station>/<account>/user/<id>`) and get what their network says about them: ' +
     '{id, name, display_name, about, avatar, address}. XMTP answers the Basename ' +
     '(<label>.stage.base.eth), its name, description and avatar records, and the wallet address; ' +
-    'WhatsApp the about line and the picture; Telegram the handle, the name and the bio; Discord ' +
+    'WhatsApp the phone number, the name they last used, the about line and the picture; Telegram the handle, the name and the bio; Discord ' +
     'the username, the global name and the avatar. Fields the network does not have are absent. ' +
     'The answer is cached for ten minutes, so ask when you want to know someone, not on every message.',
   inputSchema: {

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

@@ -196,6 +196,8 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     updateApi: { restart: deps.restart },
     controlApi: { restart: deps.restart, stop: deps.stop },
     schedulesApi: true,
+    filesApi: true,
+    vaultApi: true,
     ownerApi: { setOwner: (owner) => setLocalOwner(owner) },
     machineApi: {},
     modelApi: {},

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

@@ -18,6 +18,8 @@ import { handleModelRequest, type ModelApiDeps } from '../gateway/model-api.js';
 import type { GatewayDeps } from '../gateway/gateway.js';
 import { handleTerminalRequest, type TerminalApiDeps } from '../terminal/api.js';
 import { handleSchedulesRequest } from '../agent-user/schedules-api.js';
+import { handleFilesRequest } from '../agent-user/files-api.js';
+import { handleVaultRequest } from '../vault/api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
@@ -25,6 +27,8 @@ export interface SessionApis {
   updateApi?: UpdateApiDeps;
   controlApi?: ControlApiDeps;
   schedulesApi?: true;
+  filesApi?: true;
+  vaultApi?: true;
   ownerApi?: OwnerApiDeps;
   machineApi?: MachineApiDeps;
   modelApi?: ModelApiDeps;
@@ -52,6 +56,8 @@ export function handleSessionApis(
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
     ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),
     ...when(apis.schedulesApi, () => handleSchedulesRequest(req, res)),
+    ...when(apis.filesApi, () => handleFilesRequest(req, res)),
+    ...when(apis.vaultApi, () => handleVaultRequest(req, res)),
     ...when(apis.ownerApi, (d) => handleOwnerRequest(req, res, d)),
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
     ...when(apis.modelApi, (d) => handleModelRequest(req, res, d)),

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

@@ -0,0 +1,45 @@
+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 { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import { sessionRunning, stopSession } from '../claude/session.js';
+import { agentUser } from '../agent-user/user.js';
+import { applyVault, vaultStatus } from './index.js';
+import { recentRequests } from './proxy.js';
+import { addSecret, readVault, removeSecret, setVaultEnabled, updateSecret, type SecretInput } from './store.js';
+
+const PATH = '/api/vault';
+
+function view(): unknown {
+  return { ...vaultStatus(), secrets: readVault().secrets, recent: recentRequests().slice(0, 100) };
+}
+
+const inputOf = (body: unknown): SecretInput => (isRecord(body) ? { name: body.name, env: body.env, hosts: body.hosts, value: body.value } : {});
+
+function change(body: unknown): void {
+  const action = bodyField(body, 'action');
+  const id = bodyField(body, 'id');
+  if (action === 'enable' || action === 'disable') {
+    if (agentUser() === null) throw new ApiError('the vault needs Claude Code running as its own user (a Linux box)', 409);
+    setVaultEnabled(action === 'enable');
+  } else if (action === 'add') addSecret(inputOf(body));
+  else if (action === 'update' && typeof id === 'string') updateSecret(id, inputOf(body));
+  else if (action === 'remove' && typeof id === 'string') removeSecret(id);
+  else throw new ApiError('action must be enable, disable, add, update or remove', 400);
+}
+
+async function answer(req: IncomingMessage): Promise<unknown> {
+  if (req.method === 'GET') return view();
+  change(await readJsonBody(req));
+  const { envChanged } = await applyVault();
+  if (envChanged && sessionRunning()) {
+    stopSession();
+    log.info('vault: the Claude session restarts to pick up the new environment');
+  }
+  return view();
+}
+
+export function handleVaultRequest(req: IncomingMessage, res: ServerResponse): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET', 'POST'] }, admin: true, label: 'vault-api' }, () => answer(req));
+}

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

@@ -0,0 +1,51 @@
+import { caDir, ports, valueFile, vaultDir } from './paths.js';
+import type { VaultSecret } from './store.js';
+import { join } from 'node:path';
+
+export const MANAGEMENT_KEY_ENV = 'IRON_MANAGEMENT_API_KEY';
+
+function secretEntry(secret: VaultSecret, dir: string): Record<string, unknown> {
+  return {
+    source: { type: 'file', path: valueFile(secret.id, dir) },
+    replace: { proxy_value: secret.env, match_headers: [], match_query: true },
+    rules: secret.hosts.map((host) => ({ host })),
+  };
+}
+
+export function proxyConfig(secrets: VaultSecret[], dir = vaultDir()): Record<string, unknown> {
+  const p = ports();
+  const local = (port: number): string => `127.0.0.1:${String(port)}`;
+  return {
+    dns: { enabled: false },
+    proxy: {
+      tunnel_listen: local(p.tunnel),
+      http_listen: local(p.http),
+      https_listen: local(p.https),
+      upstream_response_header_timeout: '10m',
+    },
+    tls: { mode: 'mitm', ca_cert: join(caDir(dir), 'ca.crt'), ca_key: join(caDir(dir), 'ca.key') },
+    transforms: secrets.length === 0 ? [] : [{ name: 'secrets', config: { secrets: secrets.map((s) => secretEntry(s, dir)) } }],
+    metrics: { listen: local(p.metrics) },
+    management: { listen: local(p.management), api_key_env: MANAGEMENT_KEY_ENV },
+    log: { level: 'info' },
+  };
+}
+
+export function proxyEnvFor(caFile: string, bundle: string, secrets: VaultSecret[]): Record<string, string> {
+  const url = `http://127.0.0.1:${String(ports().tunnel)}`;
+  const skip = 'localhost,127.0.0.1,::1';
+  return {
+    HTTP_PROXY: url,
+    HTTPS_PROXY: url,
+    http_proxy: url,
+    https_proxy: url,
+    NO_PROXY: skip,
+    no_proxy: skip,
+    NODE_EXTRA_CA_CERTS: caFile,
+    SSL_CERT_FILE: bundle,
+    REQUESTS_CA_BUNDLE: bundle,
+    CURL_CA_BUNDLE: bundle,
+    GIT_SSL_CAINFO: bundle,
+    ...Object.fromEntries(secrets.map((s) => [s.env, s.env])),
+  };
+}

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

@@ -0,0 +1,39 @@
+import { spawnSync } from 'node:child_process';
+
+const CHAIN = 'METRO_AGENT';
+const TOOLS = ['iptables', 'ip6tables'] as const;
+
+export interface FirewallRunner {
+  run: (file: string, args: string[]) => number | null;
+}
+
+const realRunner: FirewallRunner = { run: (file, args) => spawnSync(file, ['-w', ...args], { stdio: 'ignore' }).status };
+
+export const chainRules = (): string[][] => [
+  ['-A', CHAIN, '-o', 'lo', '-j', 'ACCEPT'],
+  ['-A', CHAIN, '-m', 'conntrack', '--ctstate', 'ESTABLISHED,RELATED', '-j', 'ACCEPT'],
+  ['-A', CHAIN, '-p', 'udp', '--dport', '53', '-j', 'ACCEPT'],
+  ['-A', CHAIN, '-p', 'tcp', '--dport', '53', '-j', 'ACCEPT'],
+  ['-A', CHAIN, '-p', 'tcp', '-j', 'REJECT', '--reject-with', 'tcp-reset'],
+  ['-A', CHAIN, '-j', 'REJECT'],
+];
+
+const jump = (uid: number): string[] => ['OUTPUT', '-m', 'owner', '--uid-owner', String(uid), '-j', CHAIN];
+
+export function applyFirewall(uid: number, runner: FirewallRunner = realRunner): void {
+  for (const tool of TOOLS) {
+    runner.run(tool, ['-N', CHAIN]);
+    if (runner.run(tool, ['-F', CHAIN]) !== 0) throw new Error(`${tool} refused to prepare the ${CHAIN} chain`);
+    for (const rule of chainRules()) if (runner.run(tool, rule) !== 0) throw new Error(`${tool} refused a rule: ${rule.join(' ')}`);
+    if (runner.run(tool, ['-C', ...jump(uid)]) !== 0 && runner.run(tool, ['-I', ...jump(uid)]) !== 0)
+      throw new Error(`${tool} refused to send the agent's traffic to ${CHAIN}`);
+  }
+}
+
+export function removeFirewall(uid: number, runner: FirewallRunner = realRunner): void {
+  for (const tool of TOOLS) {
+    for (let i = 0; i < 10 && runner.run(tool, ['-C', ...jump(uid)]) === 0; i += 1) runner.run(tool, ['-D', ...jump(uid)]);
+    runner.run(tool, ['-F', CHAIN]);
+    runner.run(tool, ['-X', CHAIN]);
+  }
+}

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

@@ -0,0 +1,96 @@
+import { writeFileSync } from 'node:fs';
+import { errMsg, log } from '@metro-labs/core/log';
+import { ensureSecureDir } from '@metro-labs/core/secure-fs';
+import { agentExtraEnv, agentUser, asAgent, setAgentExtraEnv, type AgentUser } from '../agent-user/user.js';
+import { spawnSync } from 'node:child_process';
+import { exportJobEnv } from '../agent-user/job-env.js';
+import { proxyConfig, proxyEnvFor } from './config.js';
+import { applyFirewall, removeFirewall } from './firewall.js';
+import { ensureAuthority, ensureProxyBinary } from './install.js';
+import { configFile, PROXY_VERSION, SYSTEM_BUNDLE, TRUSTED_CA, vaultDir } from './paths.js';
+import { proxyError, proxyRunning, runProxy, stopProxy } from './proxy.js';
+import { hasValue, readVault } from './store.js';
+import { trustBrowsers, trustSystem, untrustSystem } from './trust.js';
+
+export interface VaultStatus {
+  available: boolean;
+  enabled: boolean;
+  running: boolean;
+  version: string;
+  problem: string | null;
+  browsers: string | null;
+}
+
+const memory: { problem: string | null; browsers: string | null } = { problem: null, browsers: null };
+
+function pushTmuxEnv(before: Record<string, string>, after: Record<string, string>): void {
+  const has = spawnSync(...asAgent('tmux', ['list-sessions']), { stdio: 'ignore' }).status === 0;
+  if (!has) return;
+  for (const key of Object.keys(before)) if (!(key in after)) spawnSync(...asAgent('tmux', ['set-environment', '-gu', key]), { stdio: 'ignore' });
+  for (const [key, value] of Object.entries(after)) spawnSync(...asAgent('tmux', ['set-environment', '-g', key, value]), { stdio: 'ignore' });
+}
+
+const sameEnv = (a: Record<string, string>, b: Record<string, string>): boolean =>
+  JSON.stringify(Object.entries(a).sort()) === JSON.stringify(Object.entries(b).sort());
+
+function setEnv(next: Record<string, string>): boolean {
+  const before = agentExtraEnv();
+  if (sameEnv(before, next)) return false;
+  setAgentExtraEnv(next);
+  pushTmuxEnv(before, next);
+  return true;
+}
+
+function exportForJobs(user: AgentUser, env: Record<string, string>): void {
+  try {
+    exportJobEnv(user, env);
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'vault: could not give the scheduled jobs the vault settings');
+  }
+}
+
+async function turnOn(user: AgentUser, dir: string): Promise<Record<string, string>> {
+  const bin = await ensureProxyBinary(dir);
+  const ca = ensureAuthority(bin, dir);
+  const secrets = readVault(dir).secrets.filter((s) => hasValue(s.id, dir));
+  ensureSecureDir(dir);
+  writeFileSync(configFile(dir), JSON.stringify(proxyConfig(secrets, dir), null, 2), { mode: 0o600 });
+  trustSystem(ca);
+  memory.browsers = trustBrowsers(user);
+  await runProxy(bin, configFile(dir));
+  applyFirewall(user.uid);
+  return proxyEnvFor(TRUSTED_CA, SYSTEM_BUNDLE, secrets);
+}
+
+function turnOff(user: AgentUser): void {
+  removeFirewall(user.uid);
+  stopProxy();
+  untrustSystem();
+}
+
+export async function applyVault(user: AgentUser | null = agentUser(), dir = vaultDir()): Promise<{ status: VaultStatus; envChanged: boolean }> {
+  if (user === null) return { status: vaultStatus(null, dir), envChanged: false };
+  const enabled = readVault(dir).enabled;
+  try {
+    const env = enabled ? await turnOn(user, dir) : (turnOff(user), {});
+    memory.problem = null;
+    const envChanged = setEnv(env);
+    if (envChanged || enabled) exportForJobs(user, env);
+    return { status: vaultStatus(user, dir), envChanged };
+  } catch (err) {
+    memory.problem = errMsg(err);
+    log.warn({ err: memory.problem }, 'vault: could not apply the vault');
+    return { status: vaultStatus(user, dir), envChanged: false };
+  }
+}
+
+export function vaultStatus(user: AgentUser | null = agentUser(), dir = vaultDir()): VaultStatus {
+  return {
+    available: user !== null,
+    enabled: user !== null && readVault(dir).enabled,
+    running: proxyRunning(),
+    version: PROXY_VERSION,
+    problem: memory.problem ?? (readVault(dir).enabled ? proxyError() : null),
+    browsers: memory.browsers,
+  };
+}

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

@@ -0,0 +1,56 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { chmodSync, copyFileSync, existsSync, mkdtempSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ensureSecureDir } from '@metro-labs/core/secure-fs';
+import { binDir, caDir, PROXY_VERSION, proxyBin, vaultDir } from './paths.js';
+
+const RELEASES = `https://github.com/ironsh/iron-proxy/releases/download/v${PROXY_VERSION}`;
+
+export const archiveName = (arch = process.arch): string => `iron-proxy_${PROXY_VERSION}_linux_${arch === 'arm64' ? 'arm64' : 'amd64'}.tar.gz`;
+
+export function expectedSum(checksums: string, file: string): string | null {
+  const line = checksums.split('\n').find((l) => l.trim().endsWith(` ${file}`));
+  const sum = line?.trim().split(/\s+/)[0];
+  return sum !== undefined && /^[0-9a-f]{64}$/.test(sum) ? sum : null;
+}
+
+async function download(url: string): Promise<Buffer> {
+  const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(120_000) });
+  if (!res.ok) throw new Error(`${url} answered ${String(res.status)}`);
+  return Buffer.from(await res.arrayBuffer());
+}
+
+export async function ensureProxyBinary(dir = vaultDir()): Promise<string> {
+  const bin = proxyBin(dir);
+  if (existsSync(bin)) return bin;
+  const file = archiveName();
+  const [archive, checksums] = await Promise.all([download(`${RELEASES}/${file}`), download(`${RELEASES}/checksums.txt`)]);
+  const want = expectedSum(checksums.toString('utf8'), file);
+  const got = createHash('sha256').update(archive).digest('hex');
+  if (want === null || want !== got) throw new Error(`the iron-proxy download does not match its checksum (${file})`);
+  const work = mkdtempSync(join(tmpdir(), 'metro-iron-'));
+  try {
+    writeFileSync(join(work, file), archive);
+    const untar = spawnSync('tar', ['-xzf', file, 'iron-proxy'], { cwd: work, encoding: 'utf8' });
+    if (untar.status !== 0) throw new Error(`could not unpack iron-proxy: ${untar.stderr.trim()}`);
+    ensureSecureDir(binDir(dir));
+    copyFileSync(join(work, 'iron-proxy'), `${bin}.part`);
+    chmodSync(`${bin}.part`, 0o755);
+    renameSync(`${bin}.part`, bin);
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+  return bin;
+}
+
+export function ensureAuthority(bin: string, dir = vaultDir()): string {
+  const cert = join(caDir(dir), 'ca.crt');
+  if (existsSync(cert) && existsSync(join(caDir(dir), 'ca.key'))) return cert;
+  ensureSecureDir(caDir(dir));
+  const made = spawnSync(bin, ['generate-ca', '-outdir', caDir(dir), '-name', 'Metro vault', '-expiry-hours', '87600', '-alg', 'rsa4096'], { encoding: 'utf8' });
+  if (made.status !== 0) throw new Error(`could not create the vault certificate: ${made.stderr.trim()}`);
+  chmodSync(join(caDir(dir), 'ca.key'), 0o600);
+  return cert;
+}

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

@@ -0,0 +1,26 @@
+import { join } from 'node:path';
+import { agentsDir } from '../agents/files.js';
+
+export const PROXY_VERSION = '0.50.0';
+
+const basePort = (): number => {
+  const raw = Number(process.env.METRO_VAULT_PORT);
+  return Number.isInteger(raw) && raw > 1024 && raw < 65000 ? raw : 8421;
+};
+
+export const ports = (): { tunnel: number; http: number; https: number; management: number; metrics: number } => {
+  const base = basePort();
+  return { tunnel: base, http: base + 1, https: base + 2, management: base + 3, metrics: base + 4 };
+};
+
+export const vaultDir = (dir = agentsDir()): string => join(dir, 'vault');
+export const stateFile = (dir = vaultDir()): string => join(dir, 'vault.json');
+export const valuesDir = (dir = vaultDir()): string => join(dir, 'values');
+export const valueFile = (id: string, dir = vaultDir()): string => join(valuesDir(dir), id);
+export const caDir = (dir = vaultDir()): string => join(dir, 'ca');
+export const binDir = (dir = vaultDir()): string => join(dir, 'bin');
+export const proxyBin = (dir = vaultDir()): string => join(binDir(dir), `iron-proxy-${PROXY_VERSION}`);
+export const configFile = (dir = vaultDir()): string => join(dir, 'iron-proxy.json');
+
+export const TRUSTED_CA = '/usr/local/share/ca-certificates/metro-vault.crt';
+export const SYSTEM_BUNDLE = '/etc/ssl/certs/ca-certificates.crt';

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

@@ -0,0 +1,148 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { basename } from 'node:path';
+import { createInterface } from 'node:readline';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import { MANAGEMENT_KEY_ENV } from './config.js';
+import { ports } from './paths.js';
+
+export interface ProxyRequest {
+  at: string;
+  method: string;
+  host: string;
+  path: string;
+  status: number | null;
+  action: string;
+  swapped: string[];
+}
+
+const RECENT_MAX = 200;
+const BACKOFF_MAX_MS = 30_000;
+
+const recent: ProxyRequest[] = [];
+const state: { child: ChildProcess | null; wanted: { bin: string; config: string } | null; key: string; backoff: number; lastError: string | null; startedAt: number } = {
+  child: null,
+  wanted: null,
+  key: randomBytes(24).toString('hex'),
+  backoff: 1000,
+  lastError: null,
+  startedAt: 0,
+};
+
+const text = (v: unknown): string => (typeof v === 'string' ? v : '');
+
+function swappedIds(transforms: unknown): string[] {
+  if (!Array.isArray(transforms)) return [];
+  return transforms.flatMap((t) => {
+    const swapped = isRecord(t) && isRecord(t.annotations) && Array.isArray(t.annotations.swapped) ? t.annotations.swapped : [];
+    return swapped.flatMap((s) => (isRecord(s) && typeof s.secret === 'string' ? [basename(s.secret)] : []));
+  });
+}
+
+export function requestOf(line: string): ProxyRequest | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed) || parsed.msg !== 'request' || !isRecord(parsed.audit)) return null;
+  const audit = parsed.audit;
+  if (audit.method === 'CONNECT') return null;
+  return {
+    at: text(parsed.time),
+    method: text(audit.method),
+    host: text(audit.host),
+    path: text(audit.path),
+    status: typeof audit.status_code === 'number' ? audit.status_code : null,
+    action: text(audit.action),
+    swapped: swappedIds(parsed.request_transforms),
+  };
+}
+
+function noteLine(line: string): void {
+  const request = requestOf(line);
+  if (request !== null) {
+    recent.push(request);
+    if (recent.length > RECENT_MAX) recent.shift();
+    return;
+  }
+  if (/"level":"(WARN|ERROR)"/.test(line)) log.warn({ line: line.slice(0, 500) }, 'vault: iron-proxy');
+}
+
+function launch(): void {
+  const wanted = state.wanted;
+  if (wanted === null || state.child !== null) return;
+  const child = spawn(wanted.bin, ['-config', wanted.config], { stdio: ['ignore', 'pipe', 'pipe'], env: { PATH: process.env.PATH ?? '/usr/bin:/bin', [MANAGEMENT_KEY_ENV]: state.key } });
+  state.child = child;
+  state.startedAt = Date.now();
+  for (const stream of [child.stdout, child.stderr]) if (stream !== null) createInterface({ input: stream }).on('line', noteLine);
+  child.on('error', (err) => {
+    state.lastError = errMsg(err);
+  });
+  child.on('exit', (code) => {
+    state.child = null;
+    if (state.wanted === null) return;
+    state.lastError = `iron-proxy stopped (exit ${String(code)})`;
+    log.warn({ code, retryInMs: state.backoff }, 'vault: iron-proxy stopped, starting it again');
+    const wait = state.backoff;
+    state.backoff = Date.now() - state.startedAt > 60_000 ? 1000 : Math.min(state.backoff * 2, BACKOFF_MAX_MS);
+    setTimeout(launch, wait).unref();
+  });
+}
+
+async function reload(): Promise<boolean> {
+  try {
+    const res = await fetch(`http://127.0.0.1:${String(ports().management)}/v1/reload`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${state.key}` },
+      signal: AbortSignal.timeout(10_000),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function listening(): Promise<boolean> {
+  try {
+    await fetch(`http://127.0.0.1:${String(ports().management)}/v1/reload`, { method: 'GET', signal: AbortSignal.timeout(2_000) });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitListening(ms = 10_000): Promise<boolean> {
+  const until = Date.now() + ms;
+  while (Date.now() < until) {
+    if (await listening()) return true;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return false;
+}
+
+export async function runProxy(bin: string, config: string): Promise<void> {
+  const fresh = state.child === null;
+  state.wanted = { bin, config };
+  if (fresh) launch();
+  else if (await reload()) {
+    state.lastError = null;
+    return;
+  } else {
+    state.child?.kill('SIGTERM');
+    await new Promise((r) => setTimeout(r, state.backoff + 500));
+  }
+  if (!(await waitListening())) throw new Error(state.lastError ?? 'iron-proxy did not start');
+  state.lastError = null;
+}
+
+export function stopProxy(): void {
+  state.wanted = null;
+  state.child?.kill('SIGTERM');
+}
+
+export const proxyRunning = (): boolean => state.child !== null;
+export const proxyError = (): string | null => state.lastError;
+export const recentRequests = (): ProxyRequest[] => [...recent].reverse();

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

@@ -0,0 +1,130 @@
+import { existsSync, rmSync } from 'node:fs';
+import { ApiError } from '@metro-labs/http/api-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import { newId } from '@metro-labs/core/ids';
+import { ensureSecureDir, readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { stateFile, valueFile, valuesDir, vaultDir } from './paths.js';
+
+export interface VaultSecret {
+  id: string;
+  name: string;
+  env: string;
+  hosts: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface VaultState {
+  version: 1;
+  enabled: boolean;
+  secrets: VaultSecret[];
+}
+
+export interface SecretInput {
+  name?: unknown;
+  env?: unknown;
+  hosts?: unknown;
+  value?: unknown;
+}
+
+const ENV_RE = /^[A-Z][A-Z0-9_]{2,63}$/;
+const HOST_RE = /^(\*\.)?[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/;
+const RESERVED_ENV = new Set(['HOME', 'PATH', 'USER', 'SHELL', 'LANG', 'TERM', 'LOGNAME', 'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'ALL_PROXY']);
+const MAX_SECRETS = 100;
+const MAX_HOSTS = 20;
+const MAX_VALUE = 16 * 1024;
+
+const str = (v: unknown): string => (typeof v === 'string' ? v : '');
+
+function secretOf(raw: unknown): VaultSecret | null {
+  if (!isRecord(raw) || typeof raw.id !== 'string' || !ENV_RE.test(str(raw.env))) return null;
+  const hosts = Array.isArray(raw.hosts) ? raw.hosts.filter((h): h is string => typeof h === 'string' && HOST_RE.test(h)) : [];
+  return { id: raw.id, name: str(raw.name) || str(raw.env), env: str(raw.env), hosts, createdAt: str(raw.createdAt), updatedAt: str(raw.updatedAt) };
+}
+
+export function readVault(dir = vaultDir()): VaultState {
+  const raw = readJson<unknown>(stateFile(dir), null);
+  if (!isRecord(raw)) return { version: 1, enabled: false, secrets: [] };
+  const secrets = Array.isArray(raw.secrets) ? raw.secrets.map(secretOf).filter((s): s is VaultSecret => s !== null) : [];
+  return { version: 1, enabled: raw.enabled === true, secrets };
+}
+
+export function writeVault(state: VaultState, dir = vaultDir()): void {
+  ensureSecureDir(dir);
+  writeSecure(stateFile(dir), `${JSON.stringify(state, null, 2)}\n`);
+}
+
+export function normalizeName(raw: unknown): string {
+  const name = str(raw).trim();
+  if (name === '' || name.length > 80) throw new ApiError('a name of 1 to 80 characters is required', 400);
+  return name;
+}
+
+export function normalizeEnv(raw: unknown): string {
+  const env = str(raw).trim();
+  if (!ENV_RE.test(env) || RESERVED_ENV.has(env))
+    throw new ApiError('the variable name must be capital letters, digits and _, 3 to 64 long, like OPENAI_API_KEY', 400);
+  return env;
+}
+
+export function normalizeHosts(raw: unknown): string[] {
+  if (!Array.isArray(raw)) throw new ApiError('hosts must be a list of websites, like api.openai.com', 400);
+  const hosts = [...new Set(raw.map((h) => str(h).trim().toLowerCase().replace(/^https?:\/\//, '').replace(/\/.*$/, '')).filter((h) => h !== ''))];
+  if (hosts.length === 0 || hosts.length > MAX_HOSTS) throw new ApiError(`a secret needs 1 to ${String(MAX_HOSTS)} websites`, 400);
+  const bad = hosts.find((h) => !HOST_RE.test(h));
+  if (bad !== undefined) throw new ApiError(`'${bad}' is not a website name; write it as api.example.com or *.example.com`, 400);
+  return hosts;
+}
+
+export function normalizeValue(raw: unknown): string {
+  const value = str(raw).trim();
+  if (value === '' || value.length > MAX_VALUE) throw new ApiError('a value of 1 to 16384 characters is required', 400);
+  return value;
+}
+
+function saveValue(id: string, value: string, dir: string): void {
+  ensureSecureDir(valuesDir(dir));
+  writeSecure(valueFile(id, dir), value);
+}
+
+export function addSecret(input: SecretInput, dir = vaultDir(), now = new Date()): VaultSecret {
+  const state = readVault(dir);
+  if (state.secrets.length >= MAX_SECRETS) throw new ApiError(`at most ${String(MAX_SECRETS)} secrets`, 400);
+  const env = normalizeEnv(input.env);
+  if (state.secrets.some((s) => s.env === env)) throw new ApiError(`${env} is already a secret`, 409);
+  const at = now.toISOString();
+  const secret: VaultSecret = { id: newId(), name: normalizeName(input.name ?? env), env, hosts: normalizeHosts(input.hosts), createdAt: at, updatedAt: at };
+  saveValue(secret.id, normalizeValue(input.value), dir);
+  writeVault({ ...state, secrets: [...state.secrets, secret] }, dir);
+  return secret;
+}
+
+export function updateSecret(id: string, input: SecretInput, dir = vaultDir(), now = new Date()): VaultSecret {
+  const state = readVault(dir);
+  const found = state.secrets.find((s) => s.id === id);
+  if (found === undefined) throw new ApiError('no such secret', 404);
+  const next: VaultSecret = {
+    ...found,
+    ...(input.name === undefined ? {} : { name: normalizeName(input.name) }),
+    ...(input.hosts === undefined ? {} : { hosts: normalizeHosts(input.hosts) }),
+    updatedAt: now.toISOString(),
+  };
+  if (input.value !== undefined) saveValue(id, normalizeValue(input.value), dir);
+  writeVault({ ...state, secrets: state.secrets.map((s) => (s.id === id ? next : s)) }, dir);
+  return next;
+}
+
+export function removeSecret(id: string, dir = vaultDir()): void {
+  const state = readVault(dir);
+  if (!state.secrets.some((s) => s.id === id)) throw new ApiError('no such secret', 404);
+  writeVault({ ...state, secrets: state.secrets.filter((s) => s.id !== id) }, dir);
+  rmSync(valueFile(id, dir), { force: true });
+}
+
+export function setVaultEnabled(enabled: boolean, dir = vaultDir()): VaultState {
+  const next = { ...readVault(dir), enabled };
+  writeVault(next, dir);
+  return next;
+}
+
+export const hasValue = (id: string, dir = vaultDir()): boolean => existsSync(valueFile(id, dir));

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

@@ -0,0 +1,51 @@
+import { spawnSync } from 'node:child_process';
+import { copyFileSync, chmodSync, existsSync, readFileSync, rmSync } from 'node:fs';
+import { errMsg, log } from '@metro-labs/core/log';
+import { asUser, type AgentUser } from '../agent-user/user.js';
+import { TRUSTED_CA } from './paths.js';
+
+const has = (bin: string): boolean => spawnSync('sh', ['-c', `command -v ${bin}`], { stdio: 'ignore' }).status === 0;
+
+export function trustSystem(caFile: string): void {
+  const same = existsSync(TRUSTED_CA) && readFileSync(TRUSTED_CA, 'utf8') === readFileSync(caFile, 'utf8');
+  if (same) return;
+  copyFileSync(caFile, TRUSTED_CA);
+  chmodSync(TRUSTED_CA, 0o644);
+  const run = spawnSync('update-ca-certificates', [], { encoding: 'utf8' });
+  if (run.status !== 0) throw new Error(`update-ca-certificates failed: ${run.stderr.trim()}`);
+}
+
+export function untrustSystem(): void {
+  if (!existsSync(TRUSTED_CA)) return;
+  rmSync(TRUSTED_CA, { force: true });
+  spawnSync('update-ca-certificates', ['--fresh'], { stdio: 'ignore' });
+}
+
+const NSS_SCRIPT = [
+  'set -e',
+  'db="$HOME/.pki/nssdb"',
+  'mkdir -p "$db"',
+  '[ -f "$db/cert9.db" ] || certutil -d "sql:$db" -N --empty-password',
+  'certutil -d "sql:$db" -D -n "Metro vault" >/dev/null 2>&1 || true',
+  'certutil -d "sql:$db" -A -t "C,," -n "Metro vault" -i "$1"',
+].join('\n');
+
+function ensureCertutil(): boolean {
+  if (has('certutil')) return true;
+  if (!has('apt-get')) return false;
+  const run = spawnSync('apt-get', ['install', '-y', '-q', 'libnss3-tools'], { stdio: 'ignore', timeout: 180_000, env: { ...process.env, DEBIAN_FRONTEND: 'noninteractive' } });
+  return run.status === 0 && has('certutil');
+}
+
+export function trustBrowsers(user: AgentUser): string | null {
+  try {
+    if (!ensureCertutil()) return 'certutil is missing, so browsers the agent starts will not trust the vault (apt-get install libnss3-tools)';
+    const [file, argv] = asUser(user, 'sh', ['-c', NSS_SCRIPT, 'metro', TRUSTED_CA]);
+    const run = spawnSync(file, argv, { encoding: 'utf8', timeout: 30_000 });
+    if (run.status !== 0) return `browsers will not trust the vault: ${run.stderr.trim()}`;
+    return null;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'vault: could not add the certificate for browsers');
+    return errMsg(err);
+  }
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/client.ts

@@ -17,6 +17,7 @@ import type { ProfileChange } from '@metro-labs/core/stations/profile';
 import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
 import { toInbound, toReaction, type ReactionEvent, type SelfRef } from './parse.js';
 import { baileysLogger } from './logger.js';
+import { makeNameBook, phoneOf, type NameBook } from './names.js';
 import { useAccountAuthState } from './auth-state.js';
 import { knownKey, makeKeyCache, targetKey, type KeyCache } from './keys.js';
 import { makeOutbox, type Outbox } from './outbox.js';
@@ -68,6 +69,7 @@ interface State {
   keys: KeyCache;
   outbox: Outbox;
   acks: AckWatch;
+  names: NameBook;
 }
 
 type SendOpts = Parameters<WASocket['sendMessage']>[2];
@@ -94,9 +96,13 @@ function bindInbound(st: State, sock: WASocket): void {
     for (const m of messages) {
       if (m.key.fromMe) continue;
       const inbound = toInbound(st.account.id, m, selfRef(st, sock));
+      if (inbound) st.names.note(inbound.senderJid, inbound.pushName);
       if (inbound) st.handlers.onMessage(inbound, m);
     }
   });
+  sock.ev.on('contacts.upsert', (contacts) => {
+    for (const c of contacts) st.names.note(c.id, c.name ?? c.notify);
+  });
   sock.ev.on('messages.reaction', (events: ReactionEvent[]) => {
     if (!st.handlers) return;
     for (const event of events) {
@@ -270,6 +276,22 @@ function mediaContent(m: WAMedia): SendContent {
   };
 }
 
+async function readProfile(st: State, jid: string): Promise<SenderProfile> {
+  const sock = await ready(st);
+  const [statuses, avatar] = await Promise.all([sock.fetchStatus(jid).catch(() => undefined), sock.profilePictureUrl(jid, 'image').catch(() => undefined)]);
+  const about = nonEmpty((statuses?.[0]?.status as { status?: unknown } | undefined)?.status);
+  const picture = nonEmpty(avatar);
+  const phone = phoneOf(jid.endsWith('@lid') ? await sock.signalRepository.lidMapping.getPNForLID(jid).catch(() => null) : jid);
+  const name = st.names.get(jid);
+  return {
+    id: jid,
+    ...(name === undefined ? {} : { display_name: name }),
+    ...(phone === undefined ? {} : { name: phone, address: phone }),
+    ...(about === undefined ? {} : { about }),
+    ...(picture === undefined ? {} : { avatar: picture }),
+  };
+}
+
 export function createClient(account: WhatsAppAccount): WAClient {
   const st: State = {
     account,
@@ -278,18 +300,12 @@ export function createClient(account: WhatsAppAccount): WAClient {
     keys: makeKeyCache(),
     outbox: makeOutbox(),
     acks: makeAckWatch(),
+    names: makeNameBook(),
   };
   resetGate(st);
-  const senders = makeProfileCache<SenderProfile>(
-    async (jid) => {
-      const sock = await ready(st);
-      const [statuses, avatar] = await Promise.all([sock.fetchStatus(jid).catch(() => undefined), sock.profilePictureUrl(jid, 'image').catch(() => undefined)]);
-      const about = nonEmpty((statuses?.[0]?.status as { status?: unknown } | undefined)?.status);
-      const picture = nonEmpty(avatar);
-      return { id: jid, ...(about === undefined ? {} : { about }), ...(picture === undefined ? {} : { avatar: picture }) };
-    },
-    { onError: (jid, err) => process.stderr.write(`whatsapp[${st.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`) },
-  );
+  const senders = makeProfileCache<SenderProfile>((jid) => readProfile(st, jid), {
+    onError: (jid, err) => process.stderr.write(`whatsapp[${st.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`),
+  });
   return {
     account,
     self() {

package/runtime/node_modules/@metro-labs/whatsapp/src/names.ts

@@ -0,0 +1,28 @@
+const MAX_NAMES = 2000;
+
+export interface NameBook {
+  note(jid: string | null | undefined, name: string | null | undefined): void;
+  get(jid: string): string | undefined;
+}
+
+export function makeNameBook(): NameBook {
+  const names = new Map<string, string>();
+  return {
+    note(jid, name) {
+      const clean = name?.trim() ?? '';
+      if (!jid || clean === '') return;
+      names.delete(jid);
+      names.set(jid, clean);
+      if (names.size > MAX_NAMES) {
+        const oldest = names.keys().next().value;
+        if (oldest !== undefined) names.delete(oldest);
+      }
+    },
+    get: (jid) => names.get(jid),
+  };
+}
+
+export const phoneOf = (jid: string | null | undefined): string | undefined => {
+  const digits = /^(\d{6,})(?::\d+)?@s\.whatsapp\.net$/.exec(jid ?? '')?.[1];
+  return digits === undefined ? undefined : `+${digits}`;
+};

package/runtime/runtime.json

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