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

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

@@ -4,6 +4,7 @@ import { claimCode, claimRuntime, mcpServers, NotSignedIn, whoisAuthorized, } fr
 import { askSecret } from './prompt.js';
 import { clearToken, credentialsPath, metroUrl, metroWebUrl, writeToken, } from './store.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';
@@ -17,6 +18,8 @@ const USAGE = `metro — the command line for your MCP connectors
                   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
@@ -123,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/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.23",
+  "version": "0.1.0-beta.25",
   "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/attach-serve.ts

@@ -14,7 +14,7 @@ import {
 import { attachmentOwner, recordAttachmentOwner } from './attach-owner.js';
 import { grantAllows, issueAttachmentGrant } from './attach-grant.js';
 import { errMsg, log } from './log.js';
-import { loadTunnelConfig } from './tunnel.js';
+import { loadTunnelConfig, webhookPort } from './tunnel.js';
 
 function authorized(req: IncomingMessage, name: string): boolean {
   const owner = attachmentOwner(name);
@@ -34,14 +34,19 @@ export function publicBaseUrl(): string | null {
   return host ? `https://${host}` : null;
 }
 
+const localBase = (): string | null =>
+  (process.env.METRO_RUN_TOKEN?.trim() ?? '') === ''
+    ? null
+    : `http://127.0.0.1:${String(webhookPort())}`;
+
 export const publicBaseOrDefault = (): string =>
-  publicBaseUrl() ?? DEFAULT_PUBLIC_BASE;
+  publicBaseUrl() ?? localBase() ?? DEFAULT_PUBLIC_BASE;
 
 export function attachmentUrl(
   pathOrName: string,
   agentId: string,
 ): string | null {
-  const base = publicBaseUrl();
+  const base = publicBaseUrl() ?? localBase();
   if (!base) return null;
   const name = pathOrName.split('/').pop();
   if (!name || !resolveCachedAttachment(name)) return null;

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;

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.23"
+  "version": "0.1.0-beta.25"
 }