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

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/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 { assertAgentId, daemonPlan, localUrl, readRunToken, runDaemon, runtimeDir, writeRunToken, } from './runtime.js';
 import { update } from './update.js';
 import { currentVersion } from './version.js';
@@ -11,8 +11,8 @@ 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]
@@ -40,7 +40,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 +50,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 +66,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 +96,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`);
 }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.22",
+  "version": "0.1.0-beta.23",
   "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

@@ -236,7 +236,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 +273,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 +329,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 +358,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.23"
 }