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

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.47",
   "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/local-mode.ts

@@ -32,7 +32,7 @@ import {
 } from '../db/local-connectors.js';
 import {
   assertLocalOwner,
-  claimLocalOwner,
+  ownerSignIn,
   connectorIdsOfLocalAgent,
   LOCAL_PROJECT_ID,
   localAttachAccount,
@@ -190,7 +190,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 {

package/runtime/runtime.json

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