@stage-labs/metro 0.1.0-beta.46 → 0.1.0-beta.48

package/dist/cli.js

@@ -16,7 +16,7 @@ const USAGE = `metro — the command line for your MCP connectors
 
   metro start <agent-id> [--detach]
                   run that agent's stations on this machine
-  metro serve [--port <n>] [--tunnel]
+  metro serve [--port <n>] [--tunnel] [--owner <address>]
                   run a daemon of your own: its agents and stations live in ~/.metro/agents
                   here, and metro.box manages it through the link it prints; --tunnel adds
                   a public https address through a Cloudflare quick tunnel (needs

package/dist/serve.js

@@ -1,25 +1,45 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { agentsDir } from './local.js';
 import { serveLockedBy, serveStateDir } from './control.js';
 import { findBun, localPort, runtimeDir, SERVER_ENTRY, spawnPlan, } from './runtime.js';
 const SCRUBBED = new Set(['METRO_RUN_TOKEN', 'METRO_AGENT', 'DATABASE_URL']);
 const PORT_FLAG = /^--port=(.*)$/;
-const USAGE = 'usage: metro serve [--port <n>] [--tunnel]';
+const OWNER_FLAG = /^--owner=(.*)$/;
+const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+const USAGE = 'usage: metro serve [--port <n>] [--tunnel] [--owner <address>]';
 function portOf(raw) {
     const n = Number(raw);
     if (raw === undefined || raw === '' || !Number.isInteger(n) || n < 1 || n > 65535)
         throw new Error(`'${raw ?? ''}' is not a port — ${USAGE}`);
     return n;
 }
+function ownerOf(raw) {
+    if (raw === undefined || !ADDRESS.test(raw))
+        throw new Error(`'${raw ?? ''}' is not an Ethereum address — ${USAGE}`);
+    return raw.toLowerCase();
+}
 export function parseServeArgs(argv) {
     let port = localPort();
     let tunnel = false;
+    let owner = null;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i] ?? '';
         if (arg === '--tunnel') {
             tunnel = true;
             continue;
         }
+        const inlineOwner = OWNER_FLAG.exec(arg);
+        if (inlineOwner) {
+            owner = ownerOf(inlineOwner[1]);
+            continue;
+        }
+        if (arg === '--owner') {
+            owner = ownerOf(argv[i + 1]);
+            i += 1;
+            continue;
+        }
         const inline = PORT_FLAG.exec(arg);
         if (inline) {
             port = portOf(inline[1]);
@@ -32,7 +52,15 @@ export function parseServeArgs(argv) {
         }
         throw new Error(`unknown argument '${arg}' — ${USAGE}`);
     }
-    return { port, tunnel };
+    return { port, tunnel, owner };
+}
+export function requireOwner(owner, dir = agentsDir()) {
+    if (owner !== null || existsSync(join(dir, '.owner')))
+        return;
+    throw new Error('no owner is set for this machine, so no wallet could sign in.\n' +
+        'Pass the wallet that owns it once; it is remembered in ' +
+        join(dir, '.owner') +
+        ':\n  metro serve --owner <address>');
 }
 function findCloudflared() {
     const found = spawnSync('cloudflared', ['--version'], { stdio: 'ignore' });
@@ -60,18 +88,20 @@ export function servePlan(opts) {
             METRO_TRAINS_DIR: join(opts.dir, 'trains'),
             METRO_STATE_DIR: process.env.METRO_STATE_DIR ?? serveStateDir(),
             ...(opts.tunnel ? { METRO_TUNNEL: 'quick' } : {}),
+            ...(opts.owner === null ? {} : { METRO_OWNER: opts.owner }),
         },
     };
 }
 export function serve(argv) {
-    const { port, tunnel } = parseServeArgs(argv);
+    const { port, tunnel, owner } = parseServeArgs(argv);
     const running = serveLockedBy();
     if (running !== null)
         throw new Error(`a metro serve daemon is already running on this machine (pid ${String(running)}). ` +
             'Stop it first: metro stop');
+    requireOwner(owner);
     if (tunnel)
         findCloudflared();
-    const plan = servePlan({ dir: runtimeDir(), port, tunnel });
+    const plan = servePlan({ dir: runtimeDir(), port, tunnel, owner });
     process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}\n`);
     return spawnPlan(plan);
 }

package/package.json

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

@@ -33,6 +33,8 @@ import {
 import { loadAgentForRuntime, localAgentKey } from '../db/materialize.js';
 import { fileSource } from '../db/file-source.js';
 import { ensureLocalSessionSecret } from './local-secret.js';
+import { applyLocalOwner } from './local-owner.js';
+import { localOwner } from '../db/file-admin.js';
 import { localSessionApis } from './local-mode.js';
 import type { ModeInfo } from './mode-api.js';
 import type { SessionApis } from './session-apis.js';
@@ -124,7 +126,7 @@ let webhookServer: Server | null = null;
 const tunnel = quickTunnelWanted() ? new Tunnel(webhookPort(), announcePublic) : null;
 
 function announcePublic(url: string): void {
-  process.stderr.write(`\n${publicConnectHint(url)}`);
+  process.stderr.write(`\n${publicConnectHint(url, localOwner())}`);
 }
 
 setTrainCallBackend((train, action, args) =>
@@ -138,7 +140,7 @@ const localSource = linkedSource ?? (isLocalMode() ? fileSource : null);
 function announceLocalEndpoint(): void {
   if (isLocalMode())
     process.stderr.write(
-      `\n${tunnel === null ? localConnectHint(webhookPort()) : tunnelPendingHint()}`,
+      `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
     );
   const key = localAgentKey();
   if (key === null) {
@@ -303,7 +305,10 @@ function sessionApis(): SessionApis {
 }
 
 async function main(): Promise<void> {
-  if (isLocalMode()) ensureLocalSessionSecret();
+  if (isLocalMode()) {
+    ensureLocalSessionSecret();
+    applyLocalOwner();
+  }
   if (localSource === null) await materializeFromDb();
   else await materializeFrom(localSource, { allowEmpty: linkedSource === null });
   supervisor.start();

package/runtime/node_modules/@metro-labs/mcp/src/daemon/connect-hint.ts

@@ -5,7 +5,12 @@ const uiBase = (): string => process.env.METRO_UI_URL ?? 'https://metro.box';
 const connectLink = (base: string): string =>
   `${uiBase()}/#/${new URL(base).host}`;
 
-export function localConnectHint(port: number): string {
+const ownerLine = (owner: string | null): string =>
+  owner === null
+    ? 'No owner is set, so no wallet can sign in. Restart with:  metro serve --owner <address>'
+    : `Only ${owner} can sign in.`;
+
+export function localConnectHint(port: number, owner: string | null): string {
   const here = `http://127.0.0.1:${String(port)}`;
   const forward = `ssh -L ${String(port)}:127.0.0.1:${String(port)} ${hostname()}`;
   return [
@@ -14,17 +19,18 @@ export function localConnectHint(port: number): string {
     `  ${connectLink(here)}`,
     '',
     `From another computer, forward the port first:  ${forward}`,
+    ownerLine(owner),
     '',
   ].join('\n');
 }
 
-export function publicConnectHint(url: string): string {
+export function publicConnectHint(url: string, owner: string | null): string {
   return [
     'Manage this machine from the web UI, from anywhere:',
     '',
     `  ${connectLink(url)}`,
     '',
-    'Sign in right away: the first wallet to sign in owns this machine.',
+    ownerLine(owner),
     '',
   ].join('\n');
 }

package/runtime/node_modules/@metro-labs/mcp/src/daemon/import-api.ts

@@ -15,6 +15,7 @@ const PATH = '/api/agents/import';
 
 export interface ImportedAgent extends CreatedAgent {
   stations: number;
+  connectors: number;
 }
 
 export interface ImportApiDeps {
@@ -31,7 +32,7 @@ async function handle(
     const code = parsePairingCode(bodyField(await readJsonBody(req), 'code'));
     const made = await deps.importAgent(subject, code);
     log.info(
-      { agent: made.name, id: made.id, stations: made.stations },
+      { agent: made.name, id: made.id, stations: made.stations, connectors: made.connectors },
       'import-api: agent imported from metro',
     );
     sendJson(req, res, 201, made);

package/runtime/node_modules/@metro-labs/mcp/src/daemon/local-mode.ts

@@ -14,6 +14,7 @@ import { allowLocalConnectors } from './connector-url.js';
 import { keyIdentity, type LocalCliDeps } from './local-cli-api.js';
 import type { RelayApiDeps } from './relay.js';
 import {
+  localImportConnectors,
   localAddConnector,
   localAgentConnectors,
   localConnectorNamesByIds,
@@ -32,7 +33,7 @@ import {
 } from '../db/local-connectors.js';
 import {
   assertLocalOwner,
-  claimLocalOwner,
+  ownerSignIn,
   connectorIdsOfLocalAgent,
   LOCAL_PROJECT_ID,
   localAttachAccount,
@@ -164,6 +165,7 @@ function importApi(deps: LocalModeDeps): ImportApiDeps {
       assertLocalOwner(subject);
       const agent = await fetchAgent(code, hostname());
       const made = await localImportAgent(subject, agent);
+      const connectors = localImportConnectors(agent.connectors ?? []);
       for (const station of new Set(agent.accounts.map((a) => a.station)))
         await deps.syncStations(station).catch((err: unknown) => {
           log.warn(
@@ -171,7 +173,7 @@ function importApi(deps: LocalModeDeps): ImportApiDeps {
             'import: station reload failed, the change lands at the next boot',
           );
         });
-      return made;
+      return { ...made, connectors };
     },
   };
 }
@@ -190,7 +192,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     relayApi,
     localCli,
     claudeApi: { authorize: (subject) => { assertLocalOwner(subject); } },
-    siwe: { ensureUser: claimLocalOwner },
+    siwe: { ensureUser: ownerSignIn },
     mode: localModeInfo,
   };
 }

package/runtime/node_modules/@metro-labs/mcp/src/daemon/local-owner.ts

@@ -0,0 +1,14 @@
+import { localOwner, setLocalOwner } from '../db/file-admin.js';
+import { log } from './log.js';
+
+export function applyLocalOwner(): string | null {
+  const wanted = process.env.METRO_OWNER?.trim() ?? '';
+  if (wanted !== '') {
+    const address = setLocalOwner(wanted);
+    log.info({ owner: address }, 'local daemon: owner set from METRO_OWNER');
+    return address;
+  }
+  const stored = localOwner();
+  if (stored === null) log.warn('local daemon: no owner set, so no wallet can sign in; restart with metro serve --owner <address>');
+  return stored;
+}

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

@@ -1,12 +1,4 @@
-import {
-  closeSync,
-  existsSync,
-  openSync,
-  readFileSync,
-  rmdirSync,
-  rmSync,
-  writeSync,
-} from 'node:fs';
+import { existsSync, readFileSync, rmdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { ApiError } from '../daemon/api-error.js';
 import { ensureSecureDir, writeSecure } from '../daemon/secure-fs.js';
@@ -54,31 +46,23 @@ export function localOwner(dir = agentsDir()): string | null {
   }
 }
 
-function writeOwnerOnce(path: string, address: string): boolean {
-  let fd: number;
-  try {
-    fd = openSync(path, 'wx', 0o600);
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'EEXIST') return false;
-    throw err;
-  }
-  writeSync(fd, `${address}\n`);
-  closeSync(fd);
-  return true;
-}
-
-export function claimLocalOwner(raw: string, dir = agentsDir()): Promise<string> {
+export function setLocalOwner(raw: string, dir = agentsDir()): string {
   const address = normalizeAddress(raw);
-  if (address === null)
-    return Promise.reject(new ApiError('an Ethereum address is required', 400));
+  if (address === null) throw new ApiError(`'${raw}' is not an Ethereum address`, 400);
   ensureSecureDir(dir);
-  if (writeOwnerOnce(join(dir, OWNER_FILE), address))
-    return Promise.resolve(address);
-  if (localOwner(dir) !== address)
+  writeSecure(join(dir, OWNER_FILE), `${address}\n`);
+  return address;
+}
+
+export function ownerSignIn(raw: string, dir = agentsDir()): Promise<string> {
+  const owner = localOwner(dir);
+  if (owner === null)
     return Promise.reject(
-      new ApiError('this machine belongs to another wallet', 403),
+      new ApiError('this machine has no owner yet: start it with metro serve --owner <address>', 403),
     );
-  return Promise.resolve(address);
+  if (owner !== normalizeAddress(raw))
+    return Promise.reject(new ApiError('this machine belongs to another wallet', 403));
+  return Promise.resolve(owner);
 }
 
 function isOwner(subject: string, dir: string): boolean {
@@ -203,12 +187,7 @@ export function assertLocalOwner(subject: string, dir = agentsDir()): void {
   if (!isOwner(subject, dir)) throw new AgentAdminError('no such project', 404);
 }
 
-export async function localImportAgent(
-  subject: string,
-  agent: LoadedAgent,
-  dir = agentsDir(),
-): Promise<{ id: string; name: string; key: string; stations: number }> {
-  assertLocalOwner(subject, dir);
+function assertImportable(agent: LoadedAgent): asserts agent is LoadedAgent & { key: string } {
   const immovable = agent.accounts.find((a) => !MOVABLE_STATIONS.has(a.station));
   if (immovable !== undefined)
     throw new AgentAdminError(
@@ -217,37 +196,71 @@ export async function localImportAgent(
     );
   if (agent.key === null)
     throw new AgentAdminError('that agent has no key; reset it on metro.box first', 400);
-  const folder = join(dir, agent.name);
-  const path = join(folder, AGENT_FILE);
-  if (existsSync(path))
+}
+
+interface ImportTarget {
+  path: string;
+  previous: AgentFile | undefined;
+}
+
+function importTarget(dir: string, agent: LoadedAgent & { key: string }): ImportTarget {
+  const existing = storedAgents(dir);
+  const same = existing.find((s) => s.file.id === agent.id);
+  const fresh = join(dir, agent.name, AGENT_FILE);
+  if (same === undefined && existsSync(fresh))
     throw new AgentAdminError(
       `an agent named '${agent.name}' already exists on this machine`,
       409,
     );
-  assertUnclaimed(storedAgents(dir), agent);
-  const file = fileFor(agent, localOwner(dir), path);
-  ensureSecureDir(folder);
+  assertUnclaimed(existing.filter((s) => s !== same), agent);
+  return { path: same?.path ?? fresh, previous: same?.file };
+}
+
+export async function localImportAgent(
+  subject: string,
+  agent: LoadedAgent,
+  dir = agentsDir(),
+): Promise<{ id: string; name: string; key: string; stations: number }> {
+  assertLocalOwner(subject, dir);
+  assertImportable(agent);
+  const { path, previous } = importTarget(dir, agent);
+  const file = fileFor(agent, localOwner(dir), path, previous);
+  ensureSecureDir(join(path, '..'));
   save({ path, file });
+  if (previous !== undefined && previous.key !== agent.key) unregisterAgentKey(agent.id);
   registerKey(agent.key, agent.id);
   return Promise.resolve({
     id: agent.id,
     name: agent.name,
     key: agent.key,
-    stations: agent.accounts.length,
+    stations: file.stations.length,
   });
 }
 
-function fileFor(agent: LoadedAgent, owner: string | null, path: string): AgentFile {
+function mergedStations(agent: LoadedAgent, previous: AgentFile | undefined): AgentFile['stations'] {
+  const fromMetro = agent.accounts.map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] }));
+  const kept = (previous?.stations ?? []).filter(
+    (s) => !fromMetro.some((m) => m.station === s.station && m.id === s.id),
+  );
+  return [...fromMetro, ...kept];
+}
+
+function fileFor(
+  agent: LoadedAgent,
+  owner: string | null,
+  path: string,
+  previous?: AgentFile,
+): AgentFile {
   try {
     return parseAgentFile(
       JSON.stringify({
         version: 1,
         id: agent.id,
-        name: agent.name,
+        name: previous?.name ?? agent.name,
         key: agent.key,
         owner,
-        stations: agent.accounts.map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] })),
-        connectors: [],
+        stations: mergedStations(agent, previous),
+        connectors: previous?.connectors ?? [],
       }),
       path,
     );

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

@@ -48,6 +48,7 @@ import {
   LOCAL_PROJECT_ID,
 } from './file-admin.js';
 import { newId } from './ids.js';
+import type { LoadedConnector } from './materialize.js';
 
 export interface LocalConnectorRow {
   id: string;
@@ -113,6 +114,26 @@ async function oauthCapable(url: URL, auth: ConnectorAuth): Promise<boolean> {
   return advertisesOAuth(url);
 }
 
+export function localImportConnectors(rows: LoadedConnector[], dir = agentsDir()): number {
+  const current = readLocalConnectors(dir);
+  for (const row of rows) {
+    const other = current.find((r) => r.id !== row.id && r.name === row.name);
+    if (other !== undefined)
+      throw new ConnectorError(`a connector named '${row.name}' already exists on this daemon; rename it first`, 409);
+  }
+  const imported: LocalConnectorRow[] = rows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    url: row.url,
+    transport: 'http',
+    config: readConfig(row.config),
+  }));
+  const ids = new Set(imported.map((r) => r.id));
+  writeRows(dir, [...current.filter((r) => !ids.has(r.id)), ...imported]);
+  for (const row of imported) localHoldEverywhere(row.id, dir);
+  return imported.length;
+}
+
 export async function localListConnectors(
   subject: string,
   project: string,

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

@@ -21,7 +21,14 @@ import {
   type AllowlistMap,
 } from './agent-map.js';
 import { setKeyMap } from './key-map.js';
-import { STATIONS, stations, agents, type StationName } from './schema.js';
+import {
+  agentConnectors,
+  agents,
+  connectors,
+  stations,
+  STATIONS,
+  type StationName,
+} from './schema.js';
 
 interface StationTarget {
   file: string;
@@ -36,11 +43,20 @@ export interface LoadedAccount {
   config: Record<string, unknown>;
 }
 
+export interface LoadedConnector {
+  id: string;
+  name: string;
+  url: string;
+  transport: 'http';
+  config: Record<string, unknown>;
+}
+
 export interface LoadedAgent {
   id: string;
   name: string;
   accounts: LoadedAccount[];
   key: string | null;
+  connectors?: LoadedConnector[];
 }
 
 const METRO_DIR = join(homedir(), '.metro');
@@ -133,10 +149,22 @@ export async function loadAgentForRuntime(
     .select()
     .from(stations)
     .where(eq(stations.agentId, a.id));
+  const held = await db
+    .select({ id: connectors.id, name: connectors.name, url: connectors.url, config: connectors.config })
+    .from(agentConnectors)
+    .innerJoin(connectors, eq(connectors.id, agentConnectors.connectorId))
+    .where(eq(agentConnectors.agentId, a.id));
   return {
     id: a.id,
     name: a.name,
     key: a.key,
+    connectors: held.map((c) => ({
+      id: c.id,
+      name: c.name,
+      url: c.url,
+      transport: 'http' as const,
+      config: c.config as Record<string, unknown>,
+    })),
     accounts: acctRows
       .filter((r) => MOVABLE_STATIONS.has(r.station))
       .map((r) => ({

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.46"
+  "version": "0.1.0-beta.48"
 }