@stage-labs/metro 0.1.0-beta.61 → 0.1.0-beta.63

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,6 +6,7 @@ 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=(.*)$/;
@@ -120,6 +121,7 @@ export function serve(argv) {
             'Stop it first: metro stop');
     requireOwner(owner);
     const tailscaleBin = findTailscale();
-    process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}\n`);
+    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.61",
+  "version": "0.1.0-beta.63",
   "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

@@ -25,7 +25,7 @@ function authorized(req: IncomingMessage, name: string): boolean {
   );
 }
 
-const DEFAULT_PUBLIC_BASE = 'https://mcp.metro.box';
+const DEFAULT_PUBLIC_BASE = 'https://api.metro.box';
 
 export function publicBaseUrl(): string | null {
   const env = process.env.METRO_PUBLIC_URL?.trim();

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

@@ -190,6 +190,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     localCli,
     claudeApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     updateApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart },
+    machineApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     identity: { owner: localOwner },
     mode: localModeInfo,
   };

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

@@ -0,0 +1,61 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { hostname } from 'node:os';
+import { ApiError } from './api-error.js';
+import { apiFailure, apiSession, cors, sendJson } from './api-http.js';
+import { publicBaseUrl } from './attach-serve.js';
+import { claudeDir } from './claude-files.js';
+import { webhookPort } from './tunnel.js';
+import { METRO_VERSION } from './version.js';
+import { agentsDir } from '../db/file-source.js';
+import { localOwner } from '../db/file-admin.js';
+
+const PATH = '/api/server';
+
+export interface MachineApiDeps {
+  authorize: (subject: string) => void;
+  startedAt?: string;
+}
+
+const bootedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
+
+export function machineInfo(startedAt = bootedAt): Record<string, unknown> {
+  const store = process.env.METRO_RUNTIME_STORE?.trim() ?? '';
+  return {
+    version: METRO_VERSION,
+    owner: localOwner(),
+    hostname: hostname(),
+    platform: process.platform,
+    arch: process.arch,
+    port: webhookPort(),
+    publicUrl: publicBaseUrl(),
+    uptimeSeconds: Math.round(process.uptime()),
+    startedAt,
+    bun: process.versions.bun ?? null,
+    agentsDir: agentsDir(),
+    claudeDir: claudeDir(),
+    runtimeStore: store === '' ? null : store,
+  };
+}
+
+export function handleMachineRequest(req: IncomingMessage, res: ServerResponse, deps: MachineApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PATH) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'GET') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  apiSession(req)
+    .then((session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      deps.authorize(session.subject);
+      sendJson(req, res, 200, machineInfo(deps.startedAt));
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, 'machine-api');
+    });
+  return true;
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/session-apis.ts

@@ -18,6 +18,7 @@ import { handleVaultApiRequest, type VaultApiDeps } from './vault-api.js';
 import { handleServersApiRequest, type ServersApiDeps } from './servers-api.js';
 import { handleBundleRequest, type BundleApiDeps } from './bundle-api.js';
 import { handleUpdateRequest, type UpdateApiDeps } from './update-api.js';
+import { handleMachineRequest, type MachineApiDeps } from './machine-api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
@@ -26,6 +27,7 @@ export interface SessionApis {
   vaultApi?: VaultApiDeps;
   serversApi?: ServersApiDeps;
   updateApi?: UpdateApiDeps;
+  machineApi?: MachineApiDeps;
   localCli?: LocalCliDeps;
   claudeApi?: ClaudeApiDeps;
   connectorApi?: ConnectorApiDeps;
@@ -50,6 +52,7 @@ export function handleSessionApis(
     ...when(apis.vaultApi, (d) => handleVaultApiRequest(req, res, d)),
     ...when(apis.serversApi, (d) => handleServersApiRequest(req, res, d)),
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
+    ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
     ...when(apis.claudeApi, (d) => handleClaudeRequest(req, res, d)),
     ...when(apis.agentConnectorApi, (d) => handleAgentConnectorRequest(req, res, d)),
     ...when(apis.agentApi, (d) => handleAgentApiRequest(req, res, d)),

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.61"
+  "version": "0.1.0-beta.63"
 }