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

package/dist/service.js

@@ -0,0 +1,328 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, platform, userInfo } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { serveLockedBy } from './control.js';
+import { installRelease } from './root-release.js';
+import { realReleaseDeps } from './root-release-io.js';
+import { findBun } from './runtime.js';
+import { findTailscale, parseServeArgs, requireOwner } from './serve.js';
+import { currentVersion } from './version.js';
+const USAGE = 'usage: metro service install [--port <n>] [--owner <organization id>] [--user metro] | uninstall | status | root-upgrade <version> (root only)';
+const SERVICE = 'metro';
+const LABEL = 'box.metro.serve';
+const CARRIED = /^(METRO_.*|XDG_CACHE_HOME|PATH|HOME)$/;
+const OWN_PATHS = new Set(['METRO_AGENTS_DIR', 'METRO_RUNTIME_STORE']);
+const METRO_USER = 'metro';
+const USER_FLAG = /^--user=(.*)$/;
+const PLAIN_WORD = /^[A-Za-z0-9_/.:=+@,-]+$/;
+const carriedEnv = (env) => Object.entries(env)
+    .filter((entry) => CARRIED.test(entry[0]) && typeof entry[1] === 'string' && entry[1] !== '')
+    .sort(([a], [b]) => a.localeCompare(b));
+const cacheDir = (host) => {
+    const xdg = host.env.XDG_CACHE_HOME?.trim();
+    return xdg === undefined || xdg === '' ? join(host.home, '.cache') : xdg;
+};
+function unitWord(arg) {
+    const escaped = arg.replaceAll('%', '%%');
+    if (PLAIN_WORD.test(arg))
+        return escaped;
+    return `"${escaped.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+function unitText(service, target) {
+    return [
+        '[Unit]',
+        'Description=Metro daemon (metro serve)',
+        'After=network-online.target tailscaled.service',
+        'Wants=network-online.target',
+        '',
+        '[Service]',
+        ...service,
+        '',
+        '[Install]',
+        `WantedBy=${target}`,
+        '',
+    ].join('\n');
+}
+const RESTART = ['Restart=always', 'RestartSec=2', 'OOMPolicy=continue'];
+function systemdUnit(host, exec, target) {
+    const env = carriedEnv(host.env).map(([key, value]) => `Environment=${unitWord(`${key}=${value}`)}`);
+    return unitText([`ExecStart=${exec.map(unitWord).join(' ')}`, ...RESTART, `WorkingDirectory=${unitWord(host.home)}`, ...env], target);
+}
+const npmPrefix = (home) => join(home, '.npm-global');
+function runAsUnit(host, runAs, serveArgs) {
+    const prefix = npmPrefix(runAs.home);
+    const exec = [host.node, join(prefix, 'lib', 'node_modules', '@stage-labs', 'metro', 'dist', 'cli.js'), 'serve', ...serveArgs];
+    const env = carriedEnv(host.env)
+        .filter(([key]) => key.startsWith('METRO_') && !OWN_PATHS.has(key))
+        .map(([key, value]) => `Environment=${unitWord(`${key}=${value}`)}`);
+    return unitText([
+        `User=${runAs.name}`,
+        `Group=${runAs.name}`,
+        `ExecStart=${exec.map(unitWord).join(' ')}`,
+        ...RESTART,
+        'WorkingDirectory=/',
+        `Environment=HOME=${unitWord(runAs.home)}`,
+        `Environment=${unitWord(`PATH=${prefix}/bin:/usr/local/bin:/usr/bin:/bin`)}`,
+        `Environment=${unitWord(`NPM_CONFIG_PREFIX=${prefix}`)}`,
+        ...env,
+    ], 'multi-user.target');
+}
+const xml = (text) => text
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+function launchdPlist(host, exec, logFile) {
+    const env = carriedEnv(host.env).map(([key, value]) => `    <key>${xml(key)}</key><string>${xml(value)}</string>`);
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        '<dict>',
+        `  <key>Label</key><string>${LABEL}</string>`,
+        '  <key>ProgramArguments</key>',
+        '  <array>',
+        ...exec.map((arg) => `    <string>${xml(arg)}</string>`),
+        '  </array>',
+        '  <key>EnvironmentVariables</key>',
+        '  <dict>',
+        ...env,
+        '  </dict>',
+        `  <key>WorkingDirectory</key><string>${xml(host.home)}</string>`,
+        '  <key>RunAtLoad</key><true/>',
+        '  <key>KeepAlive</key><true/>',
+        `  <key>StandardOutPath</key><string>${xml(logFile)}</string>`,
+        `  <key>StandardErrorPath</key><string>${xml(logFile)}</string>`,
+        '</dict>',
+        '</plist>',
+        '',
+    ].join('\n');
+}
+const ROOT_HINT = `Metro running as root never starts Claude Code; install it as its own user:  metro service install --user ${METRO_USER}`;
+function systemdPlan(host, serveArgs, runAs) {
+    const exec = [host.node, host.cli, 'serve', ...serveArgs];
+    const system = host.uid === 0;
+    const ctl = system ? ['systemctl'] : ['systemctl', '--user'];
+    const file = system
+        ? `/etc/systemd/system/${SERVICE}.service`
+        : join(host.home, '.config', 'systemd', 'user', `${SERVICE}.service`);
+    return {
+        kind: 'systemd',
+        file,
+        content: runAs === undefined ? systemdUnit(host, exec, system ? 'multi-user.target' : 'default.target') : runAsUnit(host, runAs, serveArgs),
+        dirs: [],
+        install: [{ args: [...ctl, 'daemon-reload'] }, { args: [...ctl, 'enable', '--now', SERVICE] }],
+        uninstall: [{ args: [...ctl, 'disable', '--now', SERVICE], mayFail: true }],
+        reload: [{ args: [...ctl, 'daemon-reload'], mayFail: true }],
+        status: { args: [...ctl, 'is-active', SERVICE], mayFail: true },
+        hints: [
+            `Logs:  journalctl ${system ? '' : '--user '}-u ${SERVICE} -f`,
+            ...(system && runAs === undefined ? [ROOT_HINT] : []),
+            ...(system
+                ? []
+                : [`A user service stops with your login session; keep it up without one:  loginctl enable-linger ${host.user}`]),
+        ],
+    };
+}
+function launchdPlan(host, exec) {
+    const file = join(host.home, 'Library', 'LaunchAgents', `${LABEL}.plist`);
+    const domain = `gui/${String(host.uid)}`;
+    const logFile = join(cacheDir(host), 'metro', 'serve', 'service.log');
+    return {
+        kind: 'launchd',
+        file,
+        content: launchdPlist(host, exec, logFile),
+        dirs: [dirname(logFile)],
+        install: [
+            { args: ['launchctl', 'bootout', `${domain}/${LABEL}`], mayFail: true },
+            { args: ['launchctl', 'bootstrap', domain, file] },
+        ],
+        uninstall: [{ args: ['launchctl', 'bootout', `${domain}/${LABEL}`], mayFail: true }],
+        reload: [],
+        status: { args: ['launchctl', 'print', `${domain}/${LABEL}`], mayFail: true },
+        hints: [`Logs:  tail -f ${logFile}`],
+    };
+}
+export function servicePlan(host, serveArgs, runAs) {
+    const exec = [host.node, host.cli, 'serve', ...serveArgs];
+    if (runAs !== undefined && (host.platform !== 'linux' || host.uid !== 0))
+        throw new Error('--user installs a system service for another user: run it as root on Linux');
+    if (host.platform === 'linux')
+        return systemdPlan(host, serveArgs, runAs);
+    if (host.platform === 'darwin')
+        return launchdPlan(host, exec);
+    throw new Error(`metro service supports Linux (systemd) and macOS (launchd), not ${host.platform}`);
+}
+function splitUser(argv) {
+    const rest = [];
+    let user = null;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? '';
+        const inline = USER_FLAG.exec(arg);
+        if (inline === null && arg !== '--user') {
+            rest.push(arg);
+            continue;
+        }
+        user = inline?.[1] ?? argv[i + 1] ?? '';
+        if (inline === null)
+            i += 1;
+    }
+    return { user, rest };
+}
+function runAsOf(name, deps) {
+    if (name === null)
+        return undefined;
+    if (name !== METRO_USER)
+        throw new Error(`the root helper and its sudo rules are written for the user ${METRO_USER}; pass --user ${METRO_USER}, not '${name}'`);
+    const account = deps.account(name);
+    if (account === null)
+        throw new Error(`there is no user ${name} on this machine; create it first (useradd --system --create-home --home-dir /var/lib/${name} ${name})`);
+    return account;
+}
+async function refreshRoot(plan, deps) {
+    await deps.release(deps.version, 'root');
+    deps.out(`metro is already installed as a ${plan.kind} service (${plan.file}); its root side is current and follows every update by itself from now on, and the service keeps running`);
+    return 0;
+}
+function writeService(plan, deps) {
+    for (const dir of plan.dirs)
+        deps.mkdir(dir);
+    deps.write(plan.file, plan.content);
+    for (const command of plan.install)
+        deps.run(command);
+    deps.out(`Installed ${plan.file}: metro serve now starts at boot and after a crash, and the Server page on metro.box can stop, start and restart it.`);
+    for (const hint of plan.hints)
+        deps.out(hint);
+    return 0;
+}
+function install(argv, deps) {
+    const { user, rest: serveArgs } = splitUser(argv);
+    const args = parseServeArgs(serveArgs);
+    const runAs = runAsOf(user, deps);
+    const plan = servicePlan(deps.host, serveArgs, runAs);
+    if (deps.exists(plan.file) && runAs !== undefined)
+        return refreshRoot(plan, deps);
+    if (deps.exists(plan.file)) {
+        deps.out(`metro is already installed as a ${plan.kind} service (${plan.file}) and restarts on its own; metro service status says whether it is running. To change its arguments: metro service uninstall, then install again`);
+        return 0;
+    }
+    deps.preflight(args, runAs === undefined ? undefined : join(runAs.home, '.metro', 'agents'));
+    const pid = deps.running();
+    if (pid !== null)
+        throw new Error(`a metro serve is running on this machine (pid ${String(pid)}). Stop it first (metro stop), then install: the service takes over from there`);
+    if (runAs === undefined)
+        return writeService(plan, deps);
+    return deps.release(deps.version, 'root').then(() => writeService(plan, deps));
+}
+async function rootUpgrade(version, deps) {
+    if (deps.host.platform !== 'linux' || deps.host.uid !== 0)
+        throw new Error('metro service root-upgrade is for root on Linux; the metro-root-upgrade unit runs it');
+    await deps.release(version, 'metro');
+    return 0;
+}
+function uninstall(deps) {
+    const plan = servicePlan(deps.host, []);
+    if (!deps.exists(plan.file)) {
+        deps.out('metro is not installed as a service on this machine');
+        return 1;
+    }
+    for (const command of plan.uninstall)
+        deps.run(command);
+    deps.remove(plan.file);
+    for (const command of plan.reload)
+        deps.run(command);
+    deps.out(`Removed ${plan.file}; a running daemon was stopped, and metro serve no longer starts on its own`);
+    return 0;
+}
+function status(deps) {
+    const plan = servicePlan(deps.host, []);
+    if (!deps.exists(plan.file)) {
+        deps.out(`not installed (metro service install writes ${plan.file})`);
+        return 1;
+    }
+    const active = deps.run(plan.status).status === 0;
+    deps.out(active
+        ? `running as a ${plan.kind} service (${plan.file})`
+        : `installed as a ${plan.kind} service (${plan.file}), not running`);
+    return active ? 0 : 1;
+}
+function realHost() {
+    const who = userInfo();
+    return {
+        platform: platform(),
+        uid: who.uid,
+        user: who.username,
+        home: homedir(),
+        node: process.execPath,
+        cli: resolve(process.argv[1] ?? ''),
+        env: process.env,
+    };
+}
+export function serviceStopHint(host = realHost(), exists = existsSync) {
+    if (host.platform !== 'linux' && host.platform !== 'darwin')
+        return null;
+    const plan = servicePlan(host, []);
+    if (!exists(plan.file))
+        return null;
+    const keep = plan.kind === 'systemd'
+        ? `systemctl ${host.uid === 0 ? '' : '--user '}stop ${SERVICE}`
+        : `launchctl bootout gui/${String(host.uid)}/${LABEL}`;
+    return `metro runs as a ${plan.kind} service here (${plan.file}), so it starts again on its own in a moment. To keep it stopped:  ${keep}`;
+}
+function lookupAccount(name) {
+    const run = spawnSync('getent', ['passwd', name], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const home = run.status === 0 ? (run.stdout.trim().split(':')[5] ?? '') : '';
+    return home.startsWith('/') ? { name, home } : null;
+}
+function realDeps() {
+    return {
+        host: realHost(),
+        run: (command) => {
+            const [bin = '', ...args] = command.args;
+            const result = spawnSync(bin, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+            const code = result.status ?? 1;
+            if (code !== 0 && command.mayFail !== true) {
+                const said = [result.stderr, result.stdout, result.error?.message].find((t) => typeof t === 'string' && t.trim() !== '') ?? '';
+                throw new Error(`${command.args.join(' ')} failed (exit ${String(code)}): ${said.trim()}`);
+            }
+            return { status: code, output: `${result.stdout}${result.stderr}` };
+        },
+        running: serveLockedBy,
+        account: lookupAccount,
+        version: currentVersion(),
+        release: (version, trigger) => installRelease(version, trigger, realReleaseDeps()),
+        preflight: (args, agents) => {
+            requireOwner(args, agents);
+            findBun();
+            findTailscale();
+        },
+        mkdir: (dir) => {
+            mkdirSync(dir, { recursive: true });
+        },
+        write: (file, content) => {
+            mkdirSync(dirname(file), { recursive: true });
+            writeFileSync(file, content, { mode: 0o644 });
+        },
+        remove: (file) => {
+            rmSync(file, { force: true });
+        },
+        exists: existsSync,
+        out: (line) => {
+            process.stderr.write(`${line}\n`);
+        },
+    };
+}
+export function service(argv, deps = realDeps()) {
+    const [verb, ...rest] = argv;
+    if (verb === 'install')
+        return Promise.resolve(install(rest, deps));
+    if (verb === 'uninstall' && rest.length === 0)
+        return Promise.resolve(uninstall(deps));
+    if (verb === 'status' && rest.length === 0)
+        return Promise.resolve(status(deps));
+    if (verb === 'root-upgrade' && rest.length === 1)
+        return rootUpgrade(rest[0] ?? '', deps);
+    throw new Error(USAGE);
+}

package/dist/tail.js

@@ -1,5 +1,5 @@
-import { runConfigKey } from './api.js';
-import { assertAgentId, localUrl, readRunToken } from './runtime.js';
+import { localAgent } from './local.js';
+import { assertAgentId, localUrl } from './runtime.js';
 const BACKOFF_MS = [1_000, 2_000, 5_000];
 const STALL_MS = 90_000;
 export const backoffAt = (attempt) => BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)] ?? 5_000;
@@ -22,11 +22,10 @@ function keySource(agentId) {
         return { resolve: () => Promise.resolve(fromEnv), fixed: true };
     return {
         resolve: () => {
-            const token = readRunToken(agentId);
-            if (token === null)
-                throw new Error(`this machine is not authorized for ${agentId} — ` +
-                    `run 'metro start ${agentId}' once, or set METRO_AGENT_KEY`);
-            return runConfigKey(token);
+            const agent = localAgent();
+            if (agent === null || (agentId !== undefined && agent.id !== agentId))
+                throw new Error(`no agent ${agentId === undefined ? '' : `${agentId} `}on this machine — start metro serve, or set METRO_AGENT_KEY`);
+            return Promise.resolve(agent.key);
         },
         fixed: false,
     };
@@ -90,7 +89,7 @@ function note(state, message) {
     process.stderr.write(`metro: ${message}\n`);
 }
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function settle(end, source, key, agentId, state) {
+async function settle(end, source, key, state) {
     if (end === 'unauthorized') {
         if (source.fixed)
             throw new Error('the key in METRO_AGENT_KEY was refused by the local daemon');
@@ -98,13 +97,13 @@ async function settle(end, source, key, agentId, state) {
         return source.resolve();
     }
     if (end === 'unreachable')
-        note(state, `no metro daemon on ${localUrl()} — run 'metro start ${agentId}'`);
+        note(state, `no metro daemon on ${localUrl()} — run 'metro serve'`);
     else
         note(state, 'stream ended — reconnecting');
     return key;
 }
 export async function tailEvents(argv) {
-    const agentId = assertAgentId(argv[0]);
+    const agentId = argv[0] === undefined ? undefined : assertAgentId(argv[0]);
     const source = keySource(agentId);
     let key = await source.resolve();
     const state = { last: '' };
@@ -113,7 +112,7 @@ export async function tailEvents(argv) {
         const end = await streamOnce(key);
         if (end === 'ended')
             attempt = 0;
-        key = await settle(end, source, key, agentId, state);
+        key = await settle(end, source, key, state);
         await delay(backoffAt(attempt));
         attempt += 1;
     }

package/dist/update.js

@@ -9,7 +9,19 @@ export function installArgs(manager, version) {
         ? ['add', '--global', spec]
         : ['install', '--global', spec];
 }
-export async function update() {
+export const checkReport = (current, latest) => ({
+    current,
+    latest,
+    newer: latest !== '' && isNewer(latest, current),
+});
+async function updateCheck() {
+    return checkReport(currentVersion(), await publishedVersion());
+}
+export async function update(argv = []) {
+    if (argv.includes('--check')) {
+        process.stdout.write(`${JSON.stringify(await updateCheck())}\n`);
+        return 0;
+    }
     const current = currentVersion();
     const newest = await publishedVersion();
     if (newest === '') {

package/hooks/guard.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { policyVerdict } from './policy.mjs';
+
+if (process.env.METRO_SESSION === 'memory') process.exit(0);
+
+const BLOCKING = new Set(['AskUserQuestion', 'ExitPlanMode', 'EnterPlanMode']);
+const ORCHESTRATION = new Set([
+  'Agent',
+  'Workflow',
+  'ToolSearch',
+  'Skill',
+  'ScheduleWakeup',
+  'Monitor',
+  'CronCreate',
+  'CronList',
+  'CronDelete',
+  'TaskCreate',
+  'TaskGet',
+  'TaskList',
+  'TaskOutput',
+  'TaskStop',
+  'TaskUpdate',
+]);
+const IMAGE = /\.(png|jpe?g|gif|webp|bmp)$/i;
+const MCP = /^mcp__/;
+const METRO_MCP = /^mcp__metro__/;
+const CONNECTOR_CALL = 'mcp__metro__tool_call';
+
+const connectorWork = (tool) =>
+  `A connector call is work, not orchestration: ${tool} reads somebody's files, mail or records, and its answer can be long enough to crowd out the chat you are here to follow. Only metro's own tools run on this thread. Delegate it to a subagent with the Agent tool (run_in_background: true; the worker reaches every connector) and relay what it finds.`;
+
+function answer(decision, reason) {
+  process.stdout.write(
+    `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: decision, permissionDecisionReason: reason } })}\n`,
+  );
+}
+
+function ownerPolicy(tool, input, subagent) {
+  const verdict = policyVerdict(tool, input);
+  if (verdict === null) return null;
+  const { where } = verdict;
+  if (verdict.access === 'deny') return { decision: 'deny', reason: `Blocked by the owner's policy for ${verdict.owner} (${verdict.tool}).` };
+  if (subagent) return { decision: 'ask', reason: `The owner asked to approve ${where}.` };
+  return {
+    decision: 'deny',
+    reason: `${where} needs the owner's approval, and waiting for it here would stop the whole session. Run this exact call from a background worker (Agent, run_in_background: true): the worker waits for the owner's answer while you keep answering.`,
+  };
+}
+
+function verdict(payload, input) {
+  const tool = typeof payload.tool_name === 'string' ? payload.tool_name : '';
+  if (BLOCKING.has(tool))
+    return `${tool} blocks the session waiting on the terminal, and nobody is watching it. Decide with your best judgement and state the assumption, or ask over chat with the metro tools and keep working in the meantime.`;
+  if (typeof payload.agent_id === 'string' && payload.agent_id !== '') return null;
+  if (tool === 'Agent' && input.run_in_background === false)
+    return 'A foreground subagent blinds the main thread: it cannot see or acknowledge inbound metro messages until the agent finishes. Re-issue the identical Agent call with run_in_background: true, then wait for the task notification.';
+  if (ORCHESTRATION.has(tool)) return null;
+  if (tool === CONNECTOR_CALL) return connectorWork(tool);
+  if (METRO_MCP.test(tool)) return null;
+  if (MCP.test(tool)) return connectorWork(tool);
+  if (tool === 'Read' && typeof input.file_path === 'string' && IMAGE.test(input.file_path)) return null;
+  return `The main thread is orchestrator-only, so ${tool === '' ? 'this tool' : tool} is not available here. Delegate the work to a subagent with the Agent tool (run_in_background: true; the worker agent has full tool access) or to a Workflow, and report the result over metro.`;
+}
+
+let payload = {};
+try {
+  payload = JSON.parse(readFileSync(0, 'utf8'));
+} catch {
+  payload = {};
+}
+const shaped = payload !== null && typeof payload === 'object' ? payload : {};
+const input = shaped.tool_input !== null && typeof shaped.tool_input === 'object' ? shaped.tool_input : {};
+const reason = verdict(shaped, input);
+const policy = reason === null && typeof shaped.tool_name === 'string' ? ownerPolicy(shaped.tool_name, input, typeof shaped.agent_id === 'string' && shaped.agent_id !== '') : null;
+if (reason !== null) answer('deny', reason);
+else if (policy !== null) answer(policy.decision, policy.reason);

package/hooks/policy.mjs

@@ -0,0 +1,74 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const METRO_TOOL = /^mcp__metro__(.+)$/;
+const RANK = { allow: 0, ask: 1, deny: 2 };
+const LINE_FIELD = { get_profile: 'from' };
+const STATION_ARG = new Set(['create_group', 'set_profile']);
+
+const isRecord = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const text = (v) => (typeof v === 'string' ? v : '');
+const agentsDir = () => process.env.METRO_AGENTS_DIR?.trim() || join(homedir(), '.metro', 'agents');
+
+function readSnapshot() {
+  try {
+    const parsed = JSON.parse(readFileSync(join(agentsDir(), 'policy.json'), 'utf8'));
+    return isRecord(parsed) && parsed.version === 1 ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+const fromLine = (line, override) => {
+  const parts = line.split('/');
+  return line.startsWith('metro://') && parts[2] && parts[3] ? [{ station: parts[2], account: override || parts[3] }] : [];
+};
+
+function stationOfAccount(snap, account) {
+  const hits = Object.entries(isRecord(snap.stations) ? snap.stations : {}).filter(
+    ([, ids]) => Array.isArray(ids) && ids.includes(account),
+  );
+  return hits.length === 1 ? hits[0][0] : undefined;
+}
+
+function targets(snap, name, input) {
+  if (Array.isArray(snap.ungated) && snap.ungated.includes(name)) return [];
+  const account = text(input.account);
+  if (name === 'list_channels') {
+    const station = stationOfAccount(snap, account);
+    return station === undefined ? [] : [{ station, account }];
+  }
+  const line = text(input[LINE_FIELD[name] ?? 'line']);
+  if (line) return fromLine(line, name in LINE_FIELD || name === 'list_members' ? '' : account);
+  const owners = isRecord(snap.owners) ? snap.owners : {};
+  const station = (STATION_ARG.has(name) ? text(input.station) : text(owners[name])) || (account ? stationOfAccount(snap, account) : undefined);
+  if (!station) return [];
+  if (account) return [{ station, account }];
+  const ids = isRecord(snap.stations) && Array.isArray(snap.stations[station]) ? snap.stations[station] : [];
+  return ids.map((id) => ({ station, account: id }));
+}
+
+function decide(policy, name, group) {
+  if (!isRecord(policy)) return 'allow';
+  const byTool = isRecord(policy.tools) && Object.hasOwn(policy.tools, name) ? policy.tools[name] : undefined;
+  const access = byTool ?? policy[group] ?? 'allow';
+  return access in RANK ? access : 'allow';
+}
+
+export function policyVerdict(toolName, input) {
+  const name = METRO_TOOL.exec(toolName)?.[1];
+  if (name === undefined) return null;
+  const snap = readSnapshot();
+  if (snap === null) return null;
+  const tools = isRecord(snap.tools) ? snap.tools : {};
+  const group = tools[name] === 'read' ? 'read' : 'write';
+  const accounts = isRecord(snap.accounts) ? snap.accounts : {};
+  let verdict = null;
+  for (const target of targets(snap, name, input)) {
+    const access = decide(accounts[`${target.station}/${target.account}`], name, group);
+    if (access !== 'allow' && (verdict === null || RANK[access] > RANK[verdict.access]))
+      verdict = { access, tool: name, owner: target.station, where: `${name} on ${target.station} (${target.account})` };
+  }
+  return verdict;
+}

package/hooks/session-start.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const given = (value) => (typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined);
+const claudeDir = given(process.env.CLAUDE_CONFIG_DIR) ?? join(given(process.env.HOME) ?? homedir(), '.claude');
+const SKILL = join(claudeDir, 'skills', 'metro', 'SKILL.md');
+const FALLBACK = join(dirname(dirname(fileURLToPath(import.meta.url))), 'skills', 'METRO.md');
+
+const body = (text) => text.replace(/^---[\s\S]*?\n---\n/, '').trim();
+
+function guidance() {
+  for (const path of [SKILL, FALLBACK]) {
+    if (!existsSync(path)) continue;
+    try {
+      const text = body(readFileSync(path, 'utf8'));
+      if (text !== '') return text;
+    } catch {
+      continue;
+    }
+  }
+  return '';
+}
+
+const text = process.env.METRO_SESSION === 'memory' ? '' : guidance();
+if (text !== '')
+  process.stdout.write(
+    `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: `This machine runs as a metro agent. Standing rules, kept in the metro skill:\n\n${text}` } })}\n`,
+  );

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.31",
-  "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.",
+  "version": "0.1.0-beta.310",
+  "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -18,7 +18,9 @@
   },
   "files": [
     "dist",
-    "runtime"
+    "hooks",
+    "runtime",
+    "skills"
   ],
   "publishConfig": {
     "access": "public",
@@ -30,31 +32,10 @@
     "test": "tsc --noEmit && node scripts/stage-runtime.mjs && bun test test/"
   },
   "devDependencies": {
-    "@stage-labs/config": "0.1.0-beta.2",
+    "@stage-labs/config": "0.1.0-beta.3",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",
     "typescript": "^5"
-  },
-  "dependencies": {
-    "@discordjs/voice": "^0.19.2",
-    "@modelcontextprotocol/sdk": "^1.12.0",
-    "@mtcute/bun": "0.30.1",
-    "@xmtp/content-type-primitives": "^3.0.1",
-    "@xmtp/content-type-reaction": "^2.0.2",
-    "@xmtp/content-type-remote-attachment": "^2.0.4",
-    "@xmtp/content-type-reply": "^2.0.3",
-    "@xmtp/content-type-wallet-send-calls": "^2.0.0",
-    "@xmtp/node-bindings": "1.9.1",
-    "@xmtp/node-sdk": "^6.0.0",
-    "baileys": "7.0.0-rc14",
-    "discord.js": "^14.26.4",
-    "drizzle-orm": "^0.44.0",
-    "pino": "^9.5.0",
-    "pino-pretty": "^13.1.3",
-    "postgres": "^3.4.5",
-    "prism-media": "^1.3.5",
-    "viem": "^2.52.2",
-    "zod": "^3.23.8"
   }
 }