@stage-labs/metro 0.1.0-beta.22 → 0.1.0-beta.24

package/dist/api.js

@@ -65,6 +65,34 @@ async function post(path, body) {
     const detail = isRecord(parsed) ? parsed.error : undefined;
     throw new Error(typeof detail === 'string' ? detail : `metro answered ${String(res.status)}`);
 }
+export class RuntimeRevoked extends Error {
+}
+export function keyOfRunConfig(body) {
+    const agent = isRecord(body) ? body.agent : undefined;
+    const key = isRecord(agent) ? agent.key : undefined;
+    if (typeof key !== 'string' || key === '')
+        throw new Error('this agent has no key — reset it on its page in the web UI');
+    return key;
+}
+export async function runConfigKey(token) {
+    if (!carriesSecretsSafely(metroUrl()))
+        throw new Error(`refusing to send this machine's authorization to ${metroUrl()} in the clear — use https, or a loopback address`);
+    let res;
+    try {
+        res = await fetch(`${metroUrl()}/api/run/config`, {
+            headers: { authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+    }
+    catch {
+        throw new Error(`could not reach ${metroUrl()}`);
+    }
+    if (res.status === 401 || res.status === 403 || res.status === 409)
+        throw new RuntimeRevoked('this machine no longer holds the agent — authorize it again from the agent page');
+    if (!res.ok)
+        throw new Error(`metro answered ${String(res.status)}`);
+    return keyOfRunConfig(await res.json());
+}
 export async function claimCode(code) {
     const body = await post('/api/cli/claim', { code });
     if (!isRecord(body) ||

package/dist/cli.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { hostname } from 'node:os';
 import { claimCode, claimRuntime, mcpServers, NotSignedIn, whoisAuthorized, } from './api.js';
-import { askLine } from './prompt.js';
+import { askSecret } from './prompt.js';
 import { clearToken, credentialsPath, metroUrl, metroWebUrl, writeToken, } from './store.js';
-import { detach, probe, runningPid, stop, tail } from './control.js';
+import { detach, lockedBy, probe, runningPid, stopAll, tail } from './control.js';
+import { tailEvents } from './tail.js';
 import { assertAgentId, daemonPlan, localUrl, readRunToken, runDaemon, runtimeDir, writeRunToken, } from './runtime.js';
 import { update } from './update.js';
 import { currentVersion } from './version.js';
@@ -11,12 +12,14 @@ const USAGE = `metro — the command line for your MCP connectors
 
   metro start <agent-id> [--detach]
                   run that agent's stations on this machine
-  metro stop <agent-id>
-                  stop the daemon started with --detach
+  metro stop [agent-id]
+                  stop every metro daemon on this machine, however it was started
   metro status <agent-id>
                   is it running, and is it healthy
   metro logs <agent-id> [-f]
                   show the detached daemon's log
+  metro tail <agent-id>
+                  follow this machine's inbound events, one JSON line each
   metro login     authorize a connector collection with a code from the web UI
   metro logout    forget this machine's sign-in
   metro whoami    print the account and collection this machine may read
@@ -40,7 +43,7 @@ function hostLabel() {
 }
 async function authorizeRuntime(agentId) {
     process.stderr.write(`Authorize this machine at ${metroWebUrl()}/#/authorize/${agentId}\n`);
-    const code = (await askLine('Paste the code: ')).trim();
+    const code = (await askSecret('Paste the code (input is hidden): ')).trim();
     if (code === '')
         throw new Error('no code given');
     const claimed = await claimRuntime(code, hostLabel());
@@ -50,8 +53,9 @@ async function authorizeRuntime(agentId) {
 }
 async function start(argv) {
     const agentId = assertAgentId(argv[0]);
-    if (runningPid(agentId) !== null)
-        throw new Error(`metro is already running for ${agentId} — stop it first`);
+    if (runningPid(agentId) !== null || lockedBy() !== null)
+        throw new Error('a metro daemon is already running on this machine. ' +
+            'Stop it first: metro stop');
     const dir = runtimeDir();
     const token = readRunToken(agentId) ?? (await authorizeRuntime(agentId));
     const detached = argv.includes('--detach');
@@ -65,10 +69,15 @@ async function start(argv) {
     return 0;
 }
 async function stopDaemon(argv) {
-    const agentId = assertAgentId(argv[0]);
-    const stopped = await stop(agentId);
-    process.stderr.write(stopped ? `Stopped metro for ${agentId}\n` : `metro is not running for ${agentId}\n`);
-    return stopped ? 0 : 1;
+    const agentId = argv[0] === undefined ? undefined : assertAgentId(argv[0]);
+    const stopped = await stopAll(agentId);
+    if (stopped.length === 0) {
+        process.stderr.write('no metro daemon is running on this machine\n');
+        return 1;
+    }
+    for (const d of stopped)
+        process.stderr.write(`Stopped metro (pid ${String(d.pid)}, via ${d.via})\n`);
+    return 0;
 }
 async function status(argv) {
     const agentId = assertAgentId(argv[0]);
@@ -90,7 +99,7 @@ function logs(argv) {
 }
 async function login() {
     process.stderr.write(`Choose a connector collection at ${metroWebUrl()}/#/authorize\n`);
-    const { token, email, collection } = await claimCode(await askLine('Paste the code here: '));
+    const { token, email, collection } = await claimCode(await askSecret('Paste the code here (input is hidden): '));
     writeToken(token);
     process.stderr.write(`Authorized '${collection}' for ${email}. Stored in ${credentialsPath()}\n`);
 }
@@ -117,6 +126,7 @@ const COMMANDS = {
     stop: () => stopDaemon(process.argv.slice(3)),
     status: () => status(process.argv.slice(3)),
     logs: () => logs(process.argv.slice(3)),
+    tail: () => tailEvents(process.argv.slice(3)),
     mcp: async () => {
         process.stdout.write(`${await mcpServers()}\n`);
         return 0;

package/dist/control.js

@@ -1,5 +1,5 @@
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { execFileSync, spawn } from 'node:child_process';
+import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 const STATE = () => join(homedir(), '.metro');
@@ -58,22 +58,78 @@ export function detach(opts) {
     writePid(opts.agentId, pid);
     return pid;
 }
-export async function stop(agentId, waitMs = 10_000) {
-    const pid = runningPid(agentId);
-    if (pid === null)
-        return false;
+async function stopPid(pid, waitMs) {
     process.kill(pid, 'SIGTERM');
     const until = Date.now() + waitMs;
     while (Date.now() < until) {
-        if (!isAlive(pid)) {
-            clearPid(agentId);
-            return true;
-        }
+        if (!isAlive(pid))
+            return;
         await new Promise((r) => setTimeout(r, 100));
     }
     process.kill(pid, 'SIGKILL');
-    clearPid(agentId);
-    return true;
+}
+const lockPath = () => process.env.METRO_STATE_DIR?.trim()
+    ? join(process.env.METRO_STATE_DIR.trim(), '.tail-lock')
+    : join(homedir(), '.cache', 'metro', '.tail-lock');
+function commandOf(pid) {
+    try {
+        return execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return '';
+    }
+}
+const looksLikeMetro = (command) => command.includes('server.ts') || command.includes('metro');
+export function lockedBy() {
+    let pid;
+    try {
+        pid = Number(readFileSync(lockPath(), 'utf8').trim());
+    }
+    catch {
+        return null;
+    }
+    if (!Number.isInteger(pid) || pid <= 0 || !isAlive(pid))
+        return null;
+    return looksLikeMetro(commandOf(pid)) ? pid : null;
+}
+function trackedAgents(agentId) {
+    const tracked = new Set();
+    if (agentId !== undefined)
+        tracked.add(agentId);
+    try {
+        for (const name of readdirSync(STATE())) {
+            const found = /^run-(.+)\.pid$/.exec(name);
+            if (found?.[1] !== undefined)
+                tracked.add(found[1]);
+        }
+    }
+    catch {
+        return tracked;
+    }
+    return tracked;
+}
+export async function stopAll(agentId, waitMs = 10_000) {
+    const stopped = [];
+    const seen = new Set();
+    for (const id of trackedAgents(agentId)) {
+        const pid = runningPid(id);
+        if (pid === null || seen.has(pid))
+            continue;
+        seen.add(pid);
+        await stopPid(pid, waitMs);
+        clearPid(id);
+        stopped.push({ pid, via: id });
+    }
+    const holder = lockedBy();
+    if (holder !== null && !seen.has(holder)) {
+        await stopPid(holder, waitMs);
+        rmSync(lockPath(), { force: true });
+        stopped.push({ pid: holder, via: 'the machine lock' });
+    }
+    return stopped;
 }
 export function tail(agentId, follow) {
     const path = logPath(agentId);

package/dist/prompt.js

@@ -1,4 +1,6 @@
 import { createInterface } from 'node:readline';
+const CTRL_C = '\u0003';
+const BACKSPACE = '\u007f';
 export function askLine(question) {
     const rl = createInterface({ input: process.stdin, output: process.stderr });
     return new Promise((resolve) => {
@@ -8,3 +10,52 @@ export function askLine(question) {
         });
     });
 }
+export function feedSecret(value, chunk) {
+    let out = value;
+    for (const ch of chunk) {
+        if (ch === CTRL_C)
+            return { kind: 'cancelled' };
+        if (ch === '\r' || ch === '\n')
+            return { kind: 'done', value: out };
+        if (ch === BACKSPACE || ch === '\b') {
+            out = out.slice(0, -1);
+            continue;
+        }
+        if (ch >= ' ')
+            out += ch;
+    }
+    return { kind: 'more', value: out };
+}
+export function askSecret(question) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY)
+        return askLine(question);
+    process.stderr.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    return new Promise((resolve, reject) => {
+        let value = '\u0003';
+        const finish = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.off('data', onData);
+            process.stderr.write('\n');
+        };
+        const onData = (chunk) => {
+            const step = feedSecret(value, chunk);
+            if (step.kind === 'cancelled') {
+                finish();
+                reject(new Error('cancelled'));
+                return;
+            }
+            if (step.kind === 'done') {
+                finish();
+                resolve(step.value.trim());
+                return;
+            }
+            value = step.value;
+        };
+        stdin.on('data', onData);
+    });
+}

package/dist/tail.js

@@ -0,0 +1,120 @@
+import { runConfigKey } from './api.js';
+import { assertAgentId, localUrl, readRunToken } 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;
+export function sseDataLines(buffer, chunk) {
+    const lines = (buffer + chunk).split('\n');
+    const rest = lines.pop() ?? '';
+    const events = [];
+    for (const raw of lines) {
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+        if (!line.startsWith('data:'))
+            continue;
+        const value = line.slice(5);
+        events.push(value.startsWith(' ') ? value.slice(1) : value);
+    }
+    return { rest, events };
+}
+function keySource(agentId) {
+    const fromEnv = process.env.METRO_AGENT_KEY?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        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);
+        },
+        fixed: false,
+    };
+}
+const armStall = (control) => setTimeout(() => {
+    control.abort();
+}, STALL_MS);
+async function connect(key, signal) {
+    try {
+        return await fetch(`${localUrl()}/api/tail`, {
+            headers: { authorization: `Bearer ${key}` },
+            signal,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function pump(body, control, stall) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return 'ended';
+            clearTimeout(stall.timer);
+            stall.timer = armStall(control);
+            const out = sseDataLines(buffer, decoder.decode(value, { stream: true }));
+            buffer = out.rest;
+            for (const event of out.events)
+                process.stdout.write(`${event}\n`);
+        }
+    }
+    catch {
+        return 'ended';
+    }
+}
+async function streamOnce(key) {
+    const control = new AbortController();
+    const stall = { timer: armStall(control) };
+    try {
+        const res = await connect(key, control.signal);
+        if (res === null)
+            return 'unreachable';
+        if (res.status === 401)
+            return 'unauthorized';
+        if (!res.ok || res.body === null)
+            return 'unreachable';
+        return await pump(res.body, control, stall);
+    }
+    finally {
+        clearTimeout(stall.timer);
+    }
+}
+function note(state, message) {
+    if (state.last === message)
+        return;
+    state.last = message;
+    process.stderr.write(`metro: ${message}\n`);
+}
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function settle(end, source, key, agentId, state) {
+    if (end === 'unauthorized') {
+        if (source.fixed)
+            throw new Error('the key in METRO_AGENT_KEY was refused by the local daemon');
+        note(state, 'key refused — fetching the current one');
+        return source.resolve();
+    }
+    if (end === 'unreachable')
+        note(state, `no metro daemon on ${localUrl()} — run 'metro start ${agentId}'`);
+    else
+        note(state, 'stream ended — reconnecting');
+    return key;
+}
+export async function tailEvents(argv) {
+    const agentId = assertAgentId(argv[0]);
+    const source = keySource(agentId);
+    let key = await source.resolve();
+    const state = { last: '' };
+    let attempt = 0;
+    for (;;) {
+        const end = await streamOnce(key);
+        if (end === 'ended')
+            attempt = 0;
+        key = await settle(end, source, key, agentId, state);
+        await delay(backoffAt(attempt));
+        attempt += 1;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.22",
+  "version": "0.1.0-beta.24",
   "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/node_modules/@metro-labs/mcp/src/daemon/boot.ts

@@ -144,11 +144,9 @@ async function applyStations(removed: StationName[]): Promise<void> {
 
 async function syncLocal(): Promise<void> {
   if (localSource === null) return;
-  const before = new Set(supervisor.running());
-  const { active, removed } = await reloadFrom(localSource);
+  const { removed, changed } = await reloadFrom(localSource);
   await applyStations(removed);
-  for (const station of active)
-    if (before.has(station)) supervisor.requestReload(station);
+  for (const station of changed) supervisor.requestReload(station);
 }
 
 async function stopLocalStations(): Promise<void> {

package/runtime/node_modules/@metro-labs/mcp/src/db/materialize.ts

@@ -181,10 +181,6 @@ async function loadAgents(): Promise<LoadedAgent[]> {
 
   const out: LoadedAgent[] = [];
   for (const a of agentRows) {
-    if (a.runtimeId !== null) {
-      out.push({ id: a.id, name: a.name, accounts: [], key: null });
-      continue;
-    }
     const acctRows = await db
       .select()
       .from(stations)
@@ -198,7 +194,7 @@ async function loadAgents(): Promise<LoadedAgent[]> {
         allowlist: r.allowlist,
         config: r.config as Record<string, unknown>,
       })),
-      key: a.key,
+      key: a.runtimeId === null ? a.key : null,
     });
   }
   return out;
@@ -236,7 +232,12 @@ export const isLocalRuntime = (): boolean =>
 export const stationRunsHere = (station: StationName): boolean =>
   isLocalRuntime() || !MOVABLE_STATIONS.has(station);
 
-function writeStations(list: LoadedAgent[]): Map<StationName, number> {
+interface WrittenStations {
+  active: Map<StationName, number>;
+  changed: StationName[];
+}
+
+function writeStations(list: LoadedAgent[]): WrittenStations {
   mkdirSync(METRO_DIR, { recursive: true });
   mkdirSync(TRAINS_DIR, { recursive: true });
 
@@ -268,29 +269,36 @@ function writeStations(list: LoadedAgent[]): Map<StationName, number> {
   carryTokenStores(list.flatMap((agent) => agent.accounts));
 
   const active = new Map<StationName, number>();
+  const changed: StationName[] = [];
   for (const [station, accts] of byStation) {
     const records = accts.map((a) => ({ id: a.id, ...trainConfig(a.config) }));
-    writeSecure(accountFilePath(station), JSON.stringify(records, null, 2));
+    const path = accountFilePath(station);
+    const content = JSON.stringify(records, null, 2);
+    if (currentText(path) !== content) {
+      writeSecure(path, content);
+      changed.push(station);
+    }
     const { trainImport } = STATION_TARGETS[station];
     if (trainImport !== null)
       writeIfChanged(trainStubPath(station), `import '${trainImport}';\n`);
     active.set(station, accts.length);
   }
-  return active;
+  return { active, changed };
 }
 
+const BLANKED = '[]\n';
+
 function pruneStations(present: Map<StationName, number>): StationName[] {
   const removed: StationName[] = [];
   for (const station of Object.keys(STATION_TARGETS) as StationName[]) {
     if (present.has(station)) continue;
     const hasTrain = STATION_TARGETS[station].trainImport !== null;
     const stub = trainStubPath(station);
-    if (
-      (!hasTrain || !existsSync(stub)) &&
-      !existsSync(accountFilePath(station))
-    )
-      continue;
-    writeSecure(accountFilePath(station), '[]\n');
+    const stubGone = !hasTrain || !existsSync(stub);
+    const file = currentText(accountFilePath(station));
+    const fileInert = file === null || file === BLANKED;
+    if (stubGone && fileInert) continue;
+    if (!fileInert) writeSecure(accountFilePath(station), BLANKED);
     if (hasTrain) rmSync(stub, { force: true });
     removed.push(station);
   }
@@ -317,14 +325,15 @@ export function localAgentKey(): string | null {
 
 async function loadAndWrite(
   source: StationSource,
-): Promise<{ active: Map<StationName, number>; agents: number }> {
+): Promise<WrittenStations & { agents: number }> {
   const list = await source();
   applyKeyMap(list);
-  return { active: writeStations(list), agents: list.length };
+  return { ...writeStations(list), agents: list.length };
 }
 
 export async function materializeFrom(source: StationSource): Promise<void> {
   const { active, agents: found } = await loadAndWrite(source);
+
   if (found === 0) throw new Error('no agents found — nothing to materialize');
   log.info(
     { stations: stationLabels(active), agents: found },
@@ -345,18 +354,20 @@ export async function materializeFromDb(): Promise<void> {
 export interface ReloadedStations {
   active: StationName[];
   removed: StationName[];
+  changed: StationName[];
 }
 
 export async function reloadFrom(
   source: StationSource,
 ): Promise<ReloadedStations> {
-  const { active } = await loadAndWrite(source);
+  const { active, changed } = await loadAndWrite(source);
   const removed = pruneStations(active);
-  log.info(
-    { stations: stationLabels(active), removed },
-    'reloaded station accounts',
-  );
-  return { active: [...active.keys()], removed };
+  if (removed.length > 0 || changed.length > 0)
+    log.info(
+      { stations: stationLabels(active), removed, changed },
+      'reloaded station accounts',
+    );
+  return { active: [...active.keys()], removed, changed };
 }
 
 export async function reloadAccountsFromDb(): Promise<ReloadedStations> {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.22"
+  "version": "0.1.0-beta.24"
 }