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

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/prompt.js

@@ -0,0 +1,10 @@
+import { createInterface } from 'node:readline';
+export function askLine(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}

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/dist/store.js

@@ -0,0 +1,70 @@
+import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+const DEFAULT_BASE = 'https://mcp.metro.box';
+const DEFAULT_WEB = 'https://metro.box';
+function fromEnv(name, fallback) {
+    const raw = process.env[name]?.trim();
+    return raw === undefined || raw === '' ? fallback : raw.replace(/\/+$/, '');
+}
+export function metroUrl() {
+    return fromEnv('METRO_URL', DEFAULT_BASE);
+}
+export function metroWebUrl() {
+    return fromEnv('METRO_UI_URL', DEFAULT_WEB);
+}
+function configDir() {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim();
+    const base = xdg === undefined || xdg === '' ? join(homedir(), '.config') : xdg;
+    return join(base, 'metro');
+}
+export function credentialsPath() {
+    return join(configDir(), 'credentials.json');
+}
+function readStored() {
+    let raw;
+    try {
+        raw = readFileSync(credentialsPath(), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const { token, url } = parsed;
+    if (typeof token !== 'string' || token === '')
+        return null;
+    return { token, url: typeof url === 'string' ? url : DEFAULT_BASE };
+}
+export function readToken() {
+    const fromEnv = process.env.METRO_TOKEN?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return fromEnv;
+    const stored = readStored();
+    if (stored === null)
+        return null;
+    return stored.url === metroUrl() ? stored.token : null;
+}
+export function writeToken(token) {
+    const path = credentialsPath();
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, `${JSON.stringify({ token, url: metroUrl() })}\n`, {
+        mode: 0o600,
+    });
+    chmodSync(path, 0o600);
+}
+export function clearToken() {
+    try {
+        rmSync(credentialsPath());
+    }
+    catch {
+        return;
+    }
+}

package/dist/update.js

@@ -0,0 +1,33 @@
+import { spawnSync } from 'node:child_process';
+import { currentVersion, isNewer, PACKAGE_NAME, publishedVersion, } from './version.js';
+export function managerFor(location) {
+    return location.includes('/.bun/') ? 'bun' : 'npm';
+}
+export function installArgs(manager, version) {
+    const spec = `${PACKAGE_NAME}@${version}`;
+    return manager === 'bun'
+        ? ['add', '--global', spec]
+        : ['install', '--global', spec];
+}
+export async function update() {
+    const current = currentVersion();
+    const newest = await publishedVersion();
+    if (newest === '') {
+        process.stderr.write('npm published no version this CLI understands\n');
+        return 1;
+    }
+    if (!isNewer(newest, current)) {
+        process.stderr.write(`metro ${current} is the newest published version\n`);
+        return 0;
+    }
+    const manager = managerFor(import.meta.url);
+    const args = installArgs(manager, newest);
+    process.stderr.write(`Updating metro ${current} to ${newest} with ${manager}\n`);
+    const run = spawnSync(manager, args, { stdio: 'inherit' });
+    if (run.error !== undefined || run.status !== 0) {
+        process.stderr.write(`That did not work. Run it yourself:\n  ${manager} ${args.join(' ')}\n`);
+        return 1;
+    }
+    process.stderr.write(`metro is now ${newest}\n`);
+    return 0;
+}

package/dist/version.js

@@ -0,0 +1,97 @@
+import { readFileSync } from 'node:fs';
+export const PACKAGE_NAME = '@stage-labs/metro';
+const REGISTRY = 'https://registry.npmjs.org';
+const TIMEOUT_MS = 15_000;
+export function parseVersion(raw) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(raw.trim());
+    if (match === null)
+        return null;
+    const core = [match[1], match[2], match[3]].map((n) => Number(n));
+    const pre = match[4] === undefined
+        ? []
+        : match[4]
+            .split('.')
+            .map((part) => (/^\d+$/.test(part) ? Number(part) : part));
+    return { core, pre };
+}
+function comparePart(left, right) {
+    if (left === undefined)
+        return -1;
+    if (right === undefined)
+        return 1;
+    if (left === right)
+        return 0;
+    if (typeof left === 'number' && typeof right === 'number')
+        return left < right ? -1 : 1;
+    if (typeof left === 'number')
+        return -1;
+    if (typeof right === 'number')
+        return 1;
+    return left < right ? -1 : 1;
+}
+function comparePre(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    if (a.length === 0)
+        return 1;
+    if (b.length === 0)
+        return -1;
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const cmp = comparePart(a[i], b[i]);
+        if (cmp !== 0)
+            return cmp;
+    }
+    return 0;
+}
+export function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    if (left === null || right === null)
+        return 0;
+    for (let i = 0; i < 3; i += 1) {
+        const l = left.core[i] ?? 0;
+        const r = right.core[i] ?? 0;
+        if (l !== r)
+            return l < r ? -1 : 1;
+    }
+    return comparePre(left.pre, right.pre);
+}
+export function isNewer(candidate, current) {
+    return compareVersions(candidate, current) > 0;
+}
+export function currentVersion() {
+    const path = new URL('../package.json', import.meta.url);
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    return typeof raw.version === 'string' ? raw.version : '0.0.0';
+}
+export function newestOf(tags) {
+    let best = '';
+    for (const value of Object.values(tags)) {
+        if (typeof value !== 'string' || parseVersion(value) === null)
+            continue;
+        if (best === '' || isNewer(value, best))
+            best = value;
+    }
+    return best;
+}
+export async function publishedVersion() {
+    let res;
+    try {
+        res = await fetch(`${REGISTRY}/${PACKAGE_NAME.replace('/', '%2F')}`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+    }
+    catch {
+        throw new Error('could not reach the npm registry');
+    }
+    if (!res.ok)
+        throw new Error(`npm answered ${String(res.status)}`);
+    const body = await res.json();
+    if (typeof body !== 'object' || body === null)
+        throw new Error('npm returned an unexpected response');
+    const tags = body['dist-tags'];
+    if (typeof tags !== 'object' || tags === null)
+        throw new Error('npm returned no dist-tags');
+    return newestOf(tags);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.2",
-  "description": "Chat with your Claude Code or Codex agent over Telegram and Discord. Ultra-lightweight: ~1.2K lines of TypeScript, pure CLI, no hosted infra.",
+  "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": {
     "type": "git",
@@ -14,35 +14,47 @@
     "node": ">=22"
   },
   "bin": {
-    "metro": "./dist/cli.js"
+    "metro": "dist/cli.js"
   },
   "files": [
     "dist",
-    "skills",
-    "README.md",
-    "LICENSE"
+    "runtime"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "tag": "beta"
   },
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "tsc",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "discord.js": "^14.14.0",
-    "pino": "^9.5.0",
-    "ws": "^8.20.0"
+    "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": {
-    "@types/node": "^22.10.0",
-    "@types/ws": "^8.18.1",
+    "@stage-labs/config": "0.1.0-beta.2",
     "eslint": "^10.3.0",
-    "typescript": "^5",
-    "typescript-eslint": "^8.59.2"
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
   },
-  "packageManager": "bun@1.3.9"
+  "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);