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

package/dist/api.js

@@ -78,6 +78,15 @@ export async function claimCode(code) {
         collection: body.collection,
     };
 }
+export async function claimRuntime(code, label) {
+    const body = await post('/api/run/claim', { code, label });
+    if (!isRecord(body) ||
+        typeof body.token !== 'string' ||
+        typeof body.agent !== 'string' ||
+        typeof body.label !== 'string')
+        throw new Error('metro returned an unexpected response');
+    return { token: body.token, agent: body.agent, label: body.label };
+}
 export async function mcpServers() {
     const body = await get('/api/cli/mcp');
     if (!isRecord(body) || typeof body.json !== 'string')

package/dist/cli.js

@@ -1,11 +1,22 @@
 #!/usr/bin/env node
-import { claimCode, mcpServers, NotSignedIn, whoisAuthorized, } from './api.js';
+import { hostname } from 'node:os';
+import { claimCode, claimRuntime, mcpServers, NotSignedIn, whoisAuthorized, } from './api.js';
 import { askLine } from './prompt.js';
 import { clearToken, credentialsPath, metroUrl, metroWebUrl, writeToken, } from './store.js';
+import { detach, probe, runningPid, stop, tail } from './control.js';
+import { assertAgentId, daemonPlan, localUrl, readRunToken, runDaemon, runtimeDir, writeRunToken, } from './runtime.js';
 import { update } from './update.js';
 import { currentVersion } from './version.js';
 const USAGE = `metro — the command line for your MCP connectors
 
+  metro start <agent-id> [--detach]
+                  run that agent's stations on this machine
+  metro stop <agent-id>
+                  stop the daemon started with --detach
+  metro status <agent-id>
+                  is it running, and is it healthy
+  metro logs <agent-id> [-f]
+                  show the detached daemon's log
   metro login     authorize a connector collection with a code from the web UI
   metro logout    forget this machine's sign-in
   metro whoami    print the account and collection this machine may read
@@ -17,10 +28,66 @@ Start Claude Code with all of them, without writing them to disk:
 
   claude --mcp-config <(metro mcp)
 
-  METRO_URL     the metro to talk to (default https://mcp.metro.box)
-  METRO_TOKEN   use this session instead of the stored one
-  METRO_UI_URL  where the web UI lives (default https://metro.box)
+  METRO_URL          the metro to talk to (default https://mcp.metro.box)
+  METRO_UI_URL       where the web UI lives (default https://metro.box)
+  METRO_TOKEN        use this connector sign-in instead of the stored one
+  METRO_RUN_TOKEN    use this runtime authorization instead of the stored one
+  METRO_RUNTIME_DIR  run the daemon from this directory instead of the bundled one
 `;
+function hostLabel() {
+    const name = hostname().trim();
+    return name === '' ? 'unnamed machine' : name;
+}
+async function authorizeRuntime(agentId) {
+    process.stderr.write(`Authorize this machine at ${metroWebUrl()}/#/agent/${agentId}\n`);
+    const code = (await askLine('Paste the code: ')).trim();
+    if (code === '')
+        throw new Error('no code given');
+    const claimed = await claimRuntime(code, hostLabel());
+    writeRunToken(claimed.agent, claimed.token);
+    process.stderr.write(`Authorized as '${claimed.label}'.\n`);
+    return claimed.token;
+}
+async function start(argv) {
+    const agentId = assertAgentId(argv[0]);
+    if (runningPid(agentId) !== null)
+        throw new Error(`metro is already running for ${agentId} — stop it first`);
+    const dir = runtimeDir();
+    const token = readRunToken(agentId) ?? (await authorizeRuntime(agentId));
+    const detached = argv.includes('--detach');
+    const plan = daemonPlan({ agentId, token, dir });
+    if (!detached)
+        return runDaemon(agentId, plan);
+    const pid = detach({ agentId, ...plan });
+    process.stderr.write(`metro is running for ${agentId} (pid ${String(pid)})\n` +
+        `  logs:  metro logs ${agentId} -f\n` +
+        `  stop:  metro stop ${agentId}\n`);
+    return 0;
+}
+async function stopDaemon(argv) {
+    const agentId = assertAgentId(argv[0]);
+    const stopped = await stop(agentId);
+    process.stderr.write(stopped ? `Stopped metro for ${agentId}\n` : `metro is not running for ${agentId}\n`);
+    return stopped ? 0 : 1;
+}
+async function status(argv) {
+    const agentId = assertAgentId(argv[0]);
+    const pid = runningPid(agentId);
+    if (pid === null) {
+        process.stdout.write(`${agentId}: not running\n`);
+        return 1;
+    }
+    const health = await probe(localUrl());
+    process.stdout.write(`${agentId}: running (pid ${String(pid)}) · ` +
+        (health === null
+            ? `not answering on ${localUrl()}\n`
+            : `healthy, up ${String(health.uptime)}s\n`));
+    return health === null ? 1 : 0;
+}
+function logs(argv) {
+    const agentId = assertAgentId(argv[0]);
+    return tail(agentId, argv.includes('-f') || argv.includes('--follow'));
+}
 async function login() {
     process.stderr.write(`Choose a connector collection at ${metroWebUrl()}/#/authorize\n`);
     const { token, email, collection } = await claimCode(await askLine('Paste the code here: '));
@@ -46,6 +113,10 @@ const COMMANDS = {
         await whoami();
         return 0;
     },
+    start: () => start(process.argv.slice(3)),
+    stop: () => stopDaemon(process.argv.slice(3)),
+    status: () => status(process.argv.slice(3)),
+    logs: () => logs(process.argv.slice(3)),
     mcp: async () => {
         process.stdout.write(`${await mcpServers()}\n`);
         return 0;

package/dist/control.js

@@ -0,0 +1,102 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const STATE = () => join(homedir(), '.metro');
+const pidPath = (agentId) => join(STATE(), `run-${agentId}.pid`);
+export const logPath = (agentId) => join(STATE(), 'logs', `${agentId}.log`);
+function ensureStateDirs() {
+    mkdirSync(STATE(), { recursive: true, mode: 0o700 });
+    mkdirSync(join(STATE(), 'logs'), { recursive: true, mode: 0o700 });
+}
+function readPid(agentId) {
+    try {
+        const pid = Number(readFileSync(pidPath(agentId), 'utf8').trim());
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function runningPid(agentId) {
+    const pid = readPid(agentId);
+    if (pid === null)
+        return null;
+    if (isAlive(pid))
+        return pid;
+    rmSync(pidPath(agentId), { force: true });
+    return null;
+}
+function writePid(agentId, pid) {
+    writeFileSync(pidPath(agentId), String(pid));
+}
+function clearPid(agentId) {
+    rmSync(pidPath(agentId), { force: true });
+}
+export function detach(opts) {
+    ensureStateDirs();
+    const out = openSync(logPath(opts.agentId), 'a');
+    const child = spawn(opts.command, opts.args, {
+        cwd: opts.cwd,
+        env: opts.env,
+        detached: true,
+        stdio: ['ignore', out, out],
+    });
+    child.unref();
+    const pid = child.pid ?? 0;
+    if (pid === 0)
+        throw new Error('could not start the metro daemon');
+    writePid(opts.agentId, pid);
+    return pid;
+}
+export async function stop(agentId, waitMs = 10_000) {
+    const pid = runningPid(agentId);
+    if (pid === null)
+        return false;
+    process.kill(pid, 'SIGTERM');
+    const until = Date.now() + waitMs;
+    while (Date.now() < until) {
+        if (!isAlive(pid)) {
+            clearPid(agentId);
+            return true;
+        }
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    process.kill(pid, 'SIGKILL');
+    clearPid(agentId);
+    return true;
+}
+export function tail(agentId, follow) {
+    const path = logPath(agentId);
+    if (!existsSync(path))
+        throw new Error(`no log for ${agentId} yet — it is only written when started with --detach`);
+    const args = follow ? ['-n', '200', '-f', path] : ['-n', '200', path];
+    const child = spawn('tail', args, { stdio: ['ignore', 'inherit', 'inherit'] });
+    return new Promise((resolve) => {
+        child.on('exit', (code) => {
+            resolve(code ?? 0);
+        });
+    });
+}
+export async function probe(url) {
+    try {
+        const res = await fetch(`${url}/health`, {
+            signal: AbortSignal.timeout(3_000),
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}

package/dist/runtime.js

@@ -0,0 +1,94 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { metroUrl } from './store.js';
+const AGENT_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{10}$/;
+const SERVER_ENTRY = join('node_modules', '@metro-labs', 'mcp', 'src', 'server.ts');
+export class MissingRuntime extends Error {
+}
+export function runtimeDir() {
+    const explicit = process.env.METRO_RUNTIME_DIR?.trim();
+    const dir = explicit !== undefined && explicit !== ''
+        ? explicit
+        : join(dirname(dirname(fileURLToPath(import.meta.url))), 'runtime');
+    if (!existsSync(join(dir, SERVER_ENTRY)))
+        throw new MissingRuntime(`no metro daemon at ${dir}. Reinstall with: npm i -g @stage-labs/metro@beta`);
+    return dir;
+}
+export class MissingBun extends Error {
+}
+export function assertAgentId(id) {
+    if (id === undefined || !AGENT_RE.test(id))
+        throw new Error(`'${id ?? ''}' is not an agent id — copy it from the agent's page in the web UI`);
+    return id;
+}
+export function findBun() {
+    const found = spawnSync('bun', ['--version'], { stdio: 'ignore' });
+    if (found.error !== undefined || found.status !== 0)
+        throw new MissingBun('metro start needs Bun, which is not on PATH.\n' +
+            'Install it with:  curl -fsSL https://bun.sh/install | bash');
+    return 'bun';
+}
+function tokenPath(agentId) {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim();
+    const base = xdg === undefined || xdg === '' ? join(homedir(), '.config') : xdg;
+    return join(base, 'metro', `runtime-${agentId}.json`);
+}
+export function readRunToken(agentId) {
+    const fromEnv = process.env.METRO_RUN_TOKEN?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return fromEnv;
+    try {
+        const parsed = JSON.parse(readFileSync(tokenPath(agentId), 'utf8'));
+        if (typeof parsed.token !== 'string' || parsed.token === '')
+            return null;
+        return parsed.url === metroUrl() ? parsed.token : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeRunToken(agentId, token) {
+    const path = tokenPath(agentId);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, JSON.stringify({ token, url: metroUrl() }, null, 2));
+    chmodSync(path, 0o600);
+}
+export const localPort = () => Number(process.env.METRO_WEBHOOK_PORT) || 8420;
+export const localUrl = () => `http://127.0.0.1:${String(localPort())}`;
+export function daemonPlan(opts) {
+    return {
+        command: findBun(),
+        args: [SERVER_ENTRY],
+        cwd: opts.dir,
+        env: {
+            ...process.env,
+            METRO_RUN_TOKEN: opts.token,
+            METRO_AGENT: opts.agentId,
+            METRO_URL: metroUrl(),
+            METRO_HTTP_HOST: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
+            METRO_TRAINS_DIR: join(opts.dir, 'trains'),
+        },
+    };
+}
+export function runDaemon(agentId, plan) {
+    process.stderr.write(`Starting metro for ${agentId}\n`);
+    const child = spawn(plan.command, plan.args, {
+        cwd: plan.cwd,
+        env: plan.env,
+        stdio: ['ignore', 'inherit', 'inherit'],
+    });
+    const relay = (sig) => () => {
+        child.kill(sig);
+    };
+    process.on('SIGINT', relay('SIGINT'));
+    process.on('SIGTERM', relay('SIGTERM'));
+    return new Promise((resolve) => {
+        child.on('exit', (code) => {
+            resolve(code ?? 0);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.19",
+  "version": "0.1.0-beta.20",
   "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": {
@@ -17,16 +17,17 @@
     "metro": "dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "runtime"
   ],
   "publishConfig": {
     "access": "public",
     "tag": "beta"
   },
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "tsc",
-    "test": "tsc --noEmit && bun test test/"
+    "build": "tsc && node scripts/stage-runtime.mjs",
+    "prepublishOnly": "tsc && node scripts/stage-runtime.mjs",
+    "test": "tsc --noEmit && node scripts/stage-runtime.mjs && bun test test/"
   },
   "devDependencies": {
     "@stage-labs/config": "0.1.0-beta.2",
@@ -34,5 +35,26 @@
     "knip": "^6.15.0",
     "madge": "^8.0.0",
     "typescript": "^5"
+  },
+  "dependencies": {
+    "@discordjs/voice": "^0.19.2",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@mtcute/bun": "0.30.1",
+    "@xmtp/content-type-primitives": "^3.0.1",
+    "@xmtp/content-type-reaction": "^2.0.2",
+    "@xmtp/content-type-remote-attachment": "^2.0.4",
+    "@xmtp/content-type-reply": "^2.0.3",
+    "@xmtp/content-type-wallet-send-calls": "^2.0.0",
+    "@xmtp/node-bindings": "1.9.1",
+    "@xmtp/node-sdk": "^6.0.0",
+    "baileys": "7.0.0-rc14",
+    "discord.js": "^14.26.4",
+    "drizzle-orm": "^0.44.0",
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3",
+    "postgres": "^3.4.5",
+    "prism-media": "^1.3.5",
+    "viem": "^2.52.2",
+    "zod": "^3.23.8"
   }
 }

package/runtime/node_modules/@metro-labs/discord/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@metro-labs/discord",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./verify": "./src/verify.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/mcp": "workspace:*",
+    "@discordjs/voice": "^0.19.2",
+    "discord.js": "^14.26.4",
+    "prism-media": "^1.3.5"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

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

@@ -0,0 +1,119 @@
+import { Client } from 'discord.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  makeAccountStore,
+  resolveAccountId,
+} from '@metro-labs/mcp/stations/account-store';
+import { Line } from '@metro-labs/mcp/lines';
+import { emit } from './wire.js';
+import { API } from './api-base.js';
+
+const ACCOUNTS_FILE =
+  process.env.DISCORD_ACCOUNTS_FILE ??
+  join(homedir(), '.metro', 'discord-accounts.json');
+
+export interface AccountConfig {
+  id: string;
+  token: string;
+  owner?: string;
+}
+
+export const { loadAccounts } = makeAccountStore<AccountConfig>({
+  prefix: 'discord',
+  file: ACCOUNTS_FILE,
+  allowlistEnv: ['DISCORD_ONLY_ACCOUNTS', 'DISCORD_ACCOUNTS'],
+  validate(raw, die) {
+    const seen = new Set<string>();
+    for (const a of raw) {
+      if (!a.id) die('account missing id');
+      if (!a.token || typeof a.token !== 'string')
+        die(`account '${a.id}' missing token`);
+      if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
+      seen.add(a.id);
+    }
+  },
+});
+
+export interface Account {
+  cfg: AccountConfig;
+  client: Client;
+}
+export const accounts = new Map<string, Account>();
+
+function restBody(
+  body: unknown,
+  isForm: boolean,
+): RequestInit['body'] | undefined {
+  if (body === undefined) return undefined;
+  return isForm ? (body as RequestInit['body']) : JSON.stringify(body);
+}
+
+async function restResult<T>(res: Response): Promise<T> {
+  if (res.status === 204) return undefined as T;
+  const ctype = res.headers.get('content-type') ?? '';
+  if (ctype.includes('application/json')) return res.json() as Promise<T>;
+  return res.arrayBuffer().then((b) => Buffer.from(b) as unknown as T);
+}
+
+export async function rest<T = unknown>(
+  accountId: string,
+  method: string,
+  path: string,
+  body?: unknown,
+  isForm = false,
+): Promise<T> {
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const headers: Record<string, string> = {
+    Authorization: `Bot ${acct.cfg.token}`,
+    'User-Agent': 'metro-discord-train (https://github.com/bonustrack/stage)',
+  };
+  if (body !== undefined && !isForm)
+    headers['Content-Type'] = 'application/json';
+  emit({ op: 'log', text: `discord[${accountId}] api ${method} ${path}` });
+  const res = await fetch(`${API}${path}`, {
+    method,
+    headers,
+    body: restBody(body, isForm),
+    signal: AbortSignal.timeout(30_000),
+  });
+  emit({
+    op: 'log',
+    text: `discord[${accountId}] api ${method} ${path} -> ${res.status}`,
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
+  }
+  return restResult<T>(res);
+}
+
+export function lineOf(accountId: string, channelId: string): string {
+  return `metro://discord/${accountId}/${channelId}`;
+}
+
+export function parseLine(
+  line: string,
+): { accountId: string; channelId: string } | null {
+  const p = Line.parseDiscord(line);
+  return p ? { accountId: p.accountId, channelId: p.resource } : null;
+}
+
+export function accountFor(args: { account?: string; line?: string }): string {
+  return resolveAccountId(accounts, args, (line) => parseLine(line)?.accountId);
+}
+
+export function routeOf(
+  line: string,
+  account?: string,
+): { accountId: string; channelId: string } {
+  const parsed = parseLine(line);
+  if (!parsed) throw new Error(`bad discord line: ${line}`);
+  const accountId = account ?? parsed.accountId;
+  if (!accounts.has(accountId))
+    throw new Error(`unknown account '${accountId}' in line ${line}`);
+  return { accountId, channelId: parsed.channelId };
+}
+
+export const encodeEmoji = (e: string): string => encodeURIComponent(e);