@stage-labs/metro 0.1.0-beta.60 → 0.1.0-beta.62

package/dist/cli.js

@@ -10,13 +10,13 @@ import { serve } from './serve.js';
 import { currentVersion } from './version.js';
 const USAGE = `metro — run your agent on this machine
 
-  metro serve [--port <n>] [--tunnel] [--owner <address>]
+  metro serve [--port <n>] [--owner <address>]
                   run the daemon: the agent, its channels and its connectors live in
-                  ~/.metro/agents here, and the page at metro.box manages it through the
-                  link it prints; --owner names the one wallet that may sign in (remembered
-                  after the first start); --tunnel publishes the daemon through Tailscale
-                  Funnel at a permanent https://<machine>.<tailnet>.ts.net (Tailscale
-                  installed and signed in on this machine), so the link works from anywhere
+                  ~/.metro/agents here, and it is published through Tailscale Funnel at a
+                  permanent https://<machine>.<tailnet>.ts.net (Tailscale installed and
+                  signed in on this machine); the page at metro.box manages it through the
+                  link it prints; --owner names the one wallet that may sign in, needed on
+                  the first start only
   metro stop      stop the metro daemon on this machine
   metro tail <agent-id>
                   follow this machine's inbound events, one JSON line each

package/dist/node-name.js

@@ -0,0 +1,51 @@
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentsDir } from './local.js';
+const NODE_FILE = '.node';
+const ALPHABET = 'abcdefghjkmnpqrstuvwxyz23456789';
+const NAME_RE = /^metro-[a-z0-9]{6}$/;
+export function newNodeName() {
+    const bytes = randomBytes(6);
+    return `metro-${[...bytes].map((b) => ALPHABET[b % ALPHABET.length] ?? 'x').join('')}`;
+}
+export function nodeName(dir = agentsDir()) {
+    const path = join(dir, NODE_FILE);
+    if (existsSync(path)) {
+        const held = readFileSync(path, 'utf8').trim();
+        if (NAME_RE.test(held))
+            return held;
+    }
+    const name = newNodeName();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(path, `${name}\n`, { mode: 0o600 });
+    return name;
+}
+export function currentNodeLabel(bin) {
+    const run = spawnSync(bin, ['status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (run.error !== undefined || run.status !== 0)
+        return null;
+    try {
+        const parsed = JSON.parse(run.stdout);
+        const dns = typeof parsed.Self?.DNSName === 'string' ? parsed.Self.DNSName : '';
+        const label = dns.split('.')[0] ?? '';
+        return label === '' ? null : label.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+export function ensureNodeName(bin, dir = agentsDir()) {
+    const wanted = nodeName(dir);
+    if (currentNodeLabel(bin) === wanted)
+        return wanted;
+    const run = spawnSync(bin, ['set', '--hostname', wanted], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    if (run.error !== undefined || run.status !== 0) {
+        const said = run.stderr.trim();
+        const reason = said === '' ? (run.error?.message ?? `exit ${String(run.status)}`) : said;
+        throw new Error(`could not name this machine ${wanted} on your tailnet (${reason}).\n` +
+            `Run it once yourself, then start again:  sudo tailscale set --hostname ${wanted}`);
+    }
+    return wanted;
+}

package/dist/serve.js

@@ -6,12 +6,13 @@ import { currentVersion } from './version.js';
 import { serveLockedBy, serveStateDir } from './control.js';
 import { findBun, localPort, SERVER_ENTRY, spawnPlan } from './runtime.js';
 import { prepareRuntime } from './runtime-install.js';
+import { ensureNodeName } from './node-name.js';
 const SCRUBBED = new Set(['METRO_RUN_TOKEN', 'METRO_AGENT', 'DATABASE_URL']);
 const PORT_FLAG = /^--port=(.*)$/;
 const OWNER_FLAG = /^--owner=(.*)$/;
 const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
-const USAGE = 'usage: metro serve [--port <n>] [--tunnel] [--owner <address>]';
-const TUNNEL_FLAG = /^--tunnel=(.*)$/;
+const USAGE = 'usage: metro serve [--port <n>] [--owner <address>]';
+const TUNNEL_FLAG = /^--(no-)?tunnel(=.*)?$/;
 const TAILSCALE_APP = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
 function portOf(raw) {
     const n = Number(raw);
@@ -19,23 +20,6 @@ function portOf(raw) {
         throw new Error(`'${raw ?? ''}' is not a port — ${USAGE}`);
     return n;
 }
-function tunnelOf(raw) {
-    if (raw === undefined || raw === '' || raw === 'tailscale')
-        return true;
-    throw new Error(`'${raw}' is not a tunnel metro knows; the public address is Tailscale Funnel — ${USAGE}`);
-}
-function tunnelFlag(argv, i) {
-    const arg = argv[i] ?? '';
-    const inline = TUNNEL_FLAG.exec(arg);
-    if (inline)
-        return { consumed: Number(tunnelOf(inline[1])) - 1 };
-    if (arg !== '--tunnel')
-        return null;
-    const next = argv[i + 1];
-    const takesValue = next !== undefined && !next.startsWith('-');
-    tunnelOf(takesValue ? next : undefined);
-    return { consumed: takesValue ? 1 : 0 };
-}
 function ownerOf(raw) {
     if (raw === undefined || !ADDRESS.test(raw))
         throw new Error(`'${raw ?? ''}' is not an Ethereum address — ${USAGE}`);
@@ -43,16 +27,11 @@ function ownerOf(raw) {
 }
 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] ?? '';
-        const tunnelArg = tunnelFlag(argv, i);
-        if (tunnelArg) {
-            tunnel = true;
-            i += tunnelArg.consumed;
-            continue;
-        }
+        if (TUNNEL_FLAG.test(arg))
+            throw new Error('--tunnel is gone: metro serve always publishes through Tailscale Funnel — ' + USAGE);
         const inlineOwner = OWNER_FLAG.exec(arg);
         if (inlineOwner) {
             owner = ownerOf(inlineOwner[1]);
@@ -75,7 +54,7 @@ export function parseServeArgs(argv) {
         }
         throw new Error(`unknown argument '${arg}' — ${USAGE}`);
     }
-    return { port, tunnel, owner };
+    return { port, owner };
 }
 export function requireOwner(owner, dir = agentsDir()) {
     if (owner !== null || existsSync(join(dir, '.owner')))
@@ -100,7 +79,7 @@ function tailscaleStatus(bin) {
 export function findTailscale(candidates = ['tailscale', TAILSCALE_APP]) {
     const bin = candidates.find((c) => spawnSync(c, ['version'], { stdio: 'ignore' }).status === 0);
     if (bin === undefined)
-        throw new Error('metro serve --tunnel tailscale needs Tailscale on this machine.\n' +
+        throw new Error('metro serve needs Tailscale on this machine: the daemon is published through Tailscale Funnel.\n' +
             'macOS:  brew install --cask tailscale   (or the App Store app)\n' +
             'Linux:  curl -fsSL https://tailscale.com/install.sh | sh\n' +
             'Then sign the machine in:  tailscale up');
@@ -128,20 +107,21 @@ export function servePlan(opts) {
                 ? {}
                 : { METRO_RUNTIME_STORE: opts.runtime.dir, METRO_RUNTIME_MANIFEST: opts.runtime.manifest }),
             METRO_STATE_DIR: process.env.METRO_STATE_DIR ?? serveStateDir(),
-            ...(opts.tunnel ? { METRO_TUNNEL: 'tailscale' } : {}),
-            ...(opts.tailscaleBin === undefined ? {} : { METRO_TAILSCALE_BIN: opts.tailscaleBin }),
+            METRO_TUNNEL: 'tailscale',
+            METRO_TAILSCALE_BIN: opts.tailscaleBin,
             ...(opts.owner === null ? {} : { METRO_OWNER: opts.owner }),
         },
     };
 }
 export function serve(argv) {
-    const { port, tunnel, owner } = parseServeArgs(argv);
+    const { port, 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);
-    const tailscaleBin = tunnel ? findTailscale() : undefined;
-    process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}\n`);
-    return spawnPlan(() => servePlan({ runtime: prepareRuntime(), port, tunnel, owner, ...(tailscaleBin === undefined ? {} : { tailscaleBin }) }));
+    const tailscaleBin = findTailscale();
+    const node = ensureNodeName(tailscaleBin);
+    process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}, published as ${node} on your tailnet\n`);
+    return spawnPlan(() => servePlan({ runtime: prepareRuntime(), port, owner, tailscaleBin }));
 }

package/package.json

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

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.60"
+  "version": "0.1.0-beta.62"
 }