@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/plugin.js

@@ -0,0 +1,82 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readToken } from './store.js';
+const MARKETPLACE_REPO = 'bonustrack/metro';
+const PLUGIN_SPEC = 'metro@metro';
+export function installPathFrom(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const plugins = parsed.plugins;
+    if (typeof plugins !== 'object' || plugins === null)
+        return null;
+    const entries = plugins[PLUGIN_SPEC];
+    if (!Array.isArray(entries))
+        return null;
+    const first = entries[0];
+    return typeof first?.installPath === 'string' ? first.installPath : null;
+}
+export function pluginInstallPath() {
+    const registry = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+    let raw;
+    try {
+        raw = readFileSync(registry, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const path = installPathFrom(raw);
+    if (path === null)
+        return null;
+    return existsSync(join(path, 'bin', 'metro-plugin.mjs')) ? path : null;
+}
+function runClaude(args) {
+    const res = spawnSync('claude', args, { encoding: 'utf8' });
+    if (res.error !== undefined)
+        throw new Error('the `claude` command is not on PATH — install Claude Code first');
+    const output = `${res.stdout ?? ''}${res.stderr ?? ''}`;
+    return { ok: res.status === 0, output };
+}
+const tolerable = (output) => /already|exists|latest version/i.test(output);
+export function syncPluginServers() {
+    const path = pluginInstallPath();
+    if (path === null || readToken() === null)
+        return false;
+    const script = join(path, 'bin', 'metro-plugin.mjs');
+    const refreshed = spawnSync(process.execPath, [script, 'refresh'], {
+        stdio: ['ignore', 'inherit', 'inherit'],
+    });
+    if (refreshed.status !== 0)
+        return false;
+    runClaude(['plugin', 'update', PLUGIN_SPEC]);
+    return true;
+}
+export async function installPlugin() {
+    const added = runClaude(['plugin', 'marketplace', 'add', MARKETPLACE_REPO]);
+    if (!added.ok && !tolerable(added.output)) {
+        process.stderr.write(added.output);
+        return 1;
+    }
+    const installed = runClaude(['plugin', 'install', PLUGIN_SPEC]);
+    if (!installed.ok && !tolerable(installed.output)) {
+        process.stderr.write(installed.output);
+        return 1;
+    }
+    process.stderr.write('Claude Code plugin installed.\n');
+    if (syncPluginServers()) {
+        process.stderr.write('Connector servers loaded — new Claude sessions have them; ' +
+            'run /reload-plugins in any session already open.\n');
+        return 0;
+    }
+    process.stderr.write('Now sign in: metro login (get a code at https://metro.box/#/authorize), ' +
+        'or run /metro:login <code> inside Claude Code.\n');
+    return Promise.resolve(0);
+}

package/dist/prompt.js

@@ -0,0 +1,61 @@
+import { createInterface } from 'node:readline';
+const CTRL_C = '\u0003';
+const BACKSPACE = '\u007f';
+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());
+        });
+    });
+}
+export function feedSecret(value, chunk) {
+    let out = value;
+    for (const ch of chunk) {
+        if (ch === CTRL_C)
+            return { kind: 'cancelled' };
+        if (ch === '\r' || ch === '\n')
+            return { kind: 'done', value: out };
+        if (ch === BACKSPACE || ch === '\b') {
+            out = out.slice(0, -1);
+            continue;
+        }
+        if (ch >= ' ')
+            out += ch;
+    }
+    return { kind: 'more', value: out };
+}
+export function askSecret(question) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY)
+        return askLine(question);
+    process.stderr.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    return new Promise((resolve, reject) => {
+        let value = '';
+        const finish = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.off('data', onData);
+            process.stderr.write('\n');
+        };
+        const onData = (chunk) => {
+            const step = feedSecret(value, chunk);
+            if (step.kind === 'cancelled') {
+                finish();
+                reject(new Error('cancelled'));
+                return;
+            }
+            if (step.kind === 'done') {
+                finish();
+                resolve(step.value.trim());
+                return;
+            }
+            value = step.value;
+        };
+        stdin.on('data', onData);
+    });
+}

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

@@ -0,0 +1,120 @@
+import { runConfigKey } from './api.js';
+import { assertAgentId, localUrl, readRunToken } from './runtime.js';
+const BACKOFF_MS = [1_000, 2_000, 5_000];
+const STALL_MS = 90_000;
+export const backoffAt = (attempt) => BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)] ?? 5_000;
+export function sseDataLines(buffer, chunk) {
+    const lines = (buffer + chunk).split('\n');
+    const rest = lines.pop() ?? '';
+    const events = [];
+    for (const raw of lines) {
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+        if (!line.startsWith('data:'))
+            continue;
+        const value = line.slice(5);
+        events.push(value.startsWith(' ') ? value.slice(1) : value);
+    }
+    return { rest, events };
+}
+function keySource(agentId) {
+    const fromEnv = process.env.METRO_AGENT_KEY?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return { resolve: () => Promise.resolve(fromEnv), fixed: true };
+    return {
+        resolve: () => {
+            const token = readRunToken(agentId);
+            if (token === null)
+                throw new Error(`this machine is not authorized for ${agentId} — ` +
+                    `run 'metro start ${agentId}' once, or set METRO_AGENT_KEY`);
+            return runConfigKey(token);
+        },
+        fixed: false,
+    };
+}
+const armStall = (control) => setTimeout(() => {
+    control.abort();
+}, STALL_MS);
+async function connect(key, signal) {
+    try {
+        return await fetch(`${localUrl()}/api/tail`, {
+            headers: { authorization: `Bearer ${key}` },
+            signal,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function pump(body, control, stall) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return 'ended';
+            clearTimeout(stall.timer);
+            stall.timer = armStall(control);
+            const out = sseDataLines(buffer, decoder.decode(value, { stream: true }));
+            buffer = out.rest;
+            for (const event of out.events)
+                process.stdout.write(`${event}\n`);
+        }
+    }
+    catch {
+        return 'ended';
+    }
+}
+async function streamOnce(key) {
+    const control = new AbortController();
+    const stall = { timer: armStall(control) };
+    try {
+        const res = await connect(key, control.signal);
+        if (res === null)
+            return 'unreachable';
+        if (res.status === 401)
+            return 'unauthorized';
+        if (!res.ok || res.body === null)
+            return 'unreachable';
+        return await pump(res.body, control, stall);
+    }
+    finally {
+        clearTimeout(stall.timer);
+    }
+}
+function note(state, message) {
+    if (state.last === message)
+        return;
+    state.last = message;
+    process.stderr.write(`metro: ${message}\n`);
+}
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function settle(end, source, key, agentId, state) {
+    if (end === 'unauthorized') {
+        if (source.fixed)
+            throw new Error('the key in METRO_AGENT_KEY was refused by the local daemon');
+        note(state, 'key refused — fetching the current one');
+        return source.resolve();
+    }
+    if (end === 'unreachable')
+        note(state, `no metro daemon on ${localUrl()} — run 'metro start ${agentId}'`);
+    else
+        note(state, 'stream ended — reconnecting');
+    return key;
+}
+export async function tailEvents(argv) {
+    const agentId = assertAgentId(argv[0]);
+    const source = keySource(agentId);
+    let key = await source.resolve();
+    const state = { last: '' };
+    let attempt = 0;
+    for (;;) {
+        const end = await streamOnce(key);
+        if (end === 'ended')
+            attempt = 0;
+        key = await settle(end, source, key, agentId, state);
+        await delay(backoffAt(attempt));
+        attempt += 1;
+    }
+}

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.3",
-  "description": "Orchestrator daemon that bridges Codex / Claude Code agent sessions with Telegram and Discord. Each chat thread gets its own agent session, with streaming responses and tool-call visibility.",
+  "version": "0.1.0-beta.30",
+  "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,34 +14,47 @@
     "node": ">=22"
   },
   "bin": {
-    "metro": "./dist/cli.js"
+    "metro": "dist/cli.js"
   },
   "files": [
     "dist",
-    "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-bot/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@metro-labs/discord-bot",
+  "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"
+  }
+}