@stage-labs/metro 0.1.0-beta.20 → 0.1.0-beta.21

package/dist/cli.js

@@ -39,7 +39,7 @@ function hostLabel() {
     return name === '' ? 'unnamed machine' : name;
 }
 async function authorizeRuntime(agentId) {
-    process.stderr.write(`Authorize this machine at ${metroWebUrl()}/#/agent/${agentId}\n`);
+    process.stderr.write(`Authorize this machine at ${metroWebUrl()}/#/authorize/${agentId}\n`);
     const code = (await askLine('Paste the code: ')).trim();
     if (code === '')
         throw new Error('no code given');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.20",
+  "version": "0.1.0-beta.21",
   "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/db/materialize.ts

@@ -108,6 +108,24 @@ export function unmovableStations(list: LoadedAccount[]): StationName[] {
   ];
 }
 
+export interface StationRecord {
+  id: string;
+  agentId: string;
+  station: StationName;
+}
+
+export async function listAllStations(): Promise<StationRecord[]> {
+  if (!databaseUrl()) return [];
+  const rows = await getDb()
+    .select({
+      id: stations.id,
+      agentId: stations.agentId,
+      station: stations.station,
+    })
+    .from(stations);
+  return rows;
+}
+
 export async function loadAllStationsFor(
   agentId: string,
 ): Promise<LoadedAccount[]> {
@@ -174,14 +192,12 @@ async function loadAgents(): Promise<LoadedAgent[]> {
     out.push({
       id: a.id,
       name: a.name,
-      accounts: acctRows
-        .filter((r) => !MOVABLE_STATIONS.has(r.station))
-        .map((r) => ({
-          station: r.station,
-          id: r.id,
-          allowlist: r.allowlist,
-          config: r.config as Record<string, unknown>,
-        })),
+      accounts: acctRows.map((r) => ({
+        station: r.station,
+        id: r.id,
+        allowlist: r.allowlist,
+        config: r.config as Record<string, unknown>,
+      })),
       key: a.key,
     });
   }
@@ -214,6 +230,12 @@ export function writeIfChanged(path: string, content: string): boolean {
   return true;
 }
 
+export const isLocalRuntime = (): boolean =>
+  (process.env.METRO_RUN_TOKEN?.trim() ?? '') !== '';
+
+export const stationRunsHere = (station: StationName): boolean =>
+  isLocalRuntime() || !MOVABLE_STATIONS.has(station);
+
 function writeStations(list: LoadedAgent[]): Map<StationName, number> {
   mkdirSync(METRO_DIR, { recursive: true });
   mkdirSync(TRAINS_DIR, { recursive: true });
@@ -225,11 +247,13 @@ function writeStations(list: LoadedAgent[]): Map<StationName, number> {
   for (const agent of list) {
     names[agent.id] = agent.name;
     for (const a of agent.accounts) {
-      const cur = byStation.get(a.station);
-      if (cur) cur.push(a);
-      else byStation.set(a.station, [a]);
       map[`${a.station}/${a.id}`] = agent.id;
       if (a.allowlist) allow[`${a.station}/${a.id}`] = a.allowlist;
+      if (stationRunsHere(a.station)) {
+        const cur = byStation.get(a.station);
+        if (cur) cur.push(a);
+        else byStation.set(a.station, [a]);
+      }
     }
   }
   setAgentMap(map, names);

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

@@ -12,8 +12,11 @@ export async function mintRuntimeCodeForEmail(
   const blocked = unmovableStations(await loadAllStationsFor(agent.id));
   if (blocked.length > 0)
     throw new ApiError(
-      `'${agent.name}' cannot run locally while it holds ${blocked.join(', ')} — ` +
-        'those stations only run on metro. Move them to another agent first.',
+      `'${agent.name}' holds ${blocked.join(', ')}, which only runs on metro ` +
+        'because a webhook url has to be publicly reachable. Its deliveries ' +
+        'would arrive at metro while this agent listens on your machine, so ' +
+        'they would be dropped. Detach it, or attach it to a second agent that ' +
+        'stays on metro, then authorize this one.',
       409,
     );
   return mintRunCode({ email, agentId: agent.id });

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

@@ -6,6 +6,12 @@ import {
 import { listEndpoints } from '../daemon/tunnel.js';
 import { hookUrl } from '../stations/attach.js';
 import { agentIdForAccount } from '../db/agent-map.js';
+import {
+  listAllStations,
+  stationRunsHere,
+  type StationRecord,
+} from '../db/materialize.js';
+import { type StationName } from '../db/schema.js';
 
 const accountId = (acc: unknown): string | undefined => {
   const id = (acc as { id?: unknown }).id;
@@ -74,24 +80,48 @@ export interface ScopedAccounts {
   unavailable: string[];
 }
 
+async function liveAccounts(
+  station: string,
+): Promise<{ rows: unknown[]; reachable: boolean }> {
+  if (!hasTrain(station))
+    return { rows: inCoreAccounts(station), reachable: true };
+  if (!stationRunsHere(station as StationName))
+    return { rows: [], reachable: true };
+  try {
+    const resp = await forwardTrainCall(station, 'accounts', {});
+    const list = (resp.result as { accounts?: unknown[] } | undefined)?.accounts;
+    return { rows: Array.isArray(list) ? list : [], reachable: true };
+  } catch {
+    return { rows: [], reachable: false };
+  }
+}
+
+function mergeKnown(
+  station: string,
+  live: unknown[],
+  known: StationRecord[],
+): unknown[] {
+  const seen = new Set(
+    live.flatMap((row) => {
+      const id = accountId(row);
+      return id === undefined ? [] : [id];
+    }),
+  );
+  const missing = known
+    .filter((r) => r.station === station && !seen.has(r.id))
+    .map((r) => ({ id: r.id }));
+  return [...live, ...missing];
+}
+
 async function loadStations(): Promise<ScopedAccounts> {
   const unavailable: string[] = [];
   const accounts: Record<string, unknown[]> = {};
+  const known = await listAllStations();
   await Promise.all(
     accountStationNames().map(async (station) => {
-      if (!hasTrain(station)) {
-        accounts[station] = inCoreAccounts(station);
-        return;
-      }
-      try {
-        const resp = await forwardTrainCall(station, 'accounts', {});
-        const list = (resp.result as { accounts?: unknown[] } | undefined)
-          ?.accounts;
-        accounts[station] = Array.isArray(list) ? list : [];
-      } catch {
-        accounts[station] = [];
-        unavailable.push(station);
-      }
+      const { rows, reachable } = await liveAccounts(station);
+      if (!reachable) unavailable.push(station);
+      accounts[station] = mergeKnown(station, rows, known);
     }),
   );
   return { accounts, unavailable };

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.20"
+  "version": "0.1.0-beta.21"
 }