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

package/dist/tail.js

@@ -1,161 +1,119 @@
-// Standalone inbound stream. Polls Telegram + connects to Discord, prints
-// one JSON line per inbound message on stdout. Designed to be launched by
-// an agent and observed via Bash+Monitor (Claude Code) or unified_exec
-// polling (Codex).
-//
-// On every inbound: fires a 👀 reaction and starts a typing indicator that
-// refreshes until the agent replies (signaled by `metro reply` touching
-// .typing-stop/<key>) or the 60s safety cap is hit.
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import pkg from '../package.json' with { type: 'json' };
-import * as discord from './channels/discord.js';
-import * as telegram from './channels/telegram.js';
-import { tg } from './channels/telegram.js';
-import { CodexRC } from './lib/codex-rc.js';
-import { configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
-import { errMsg, log } from './log.js';
-loadMetroEnv();
-const platforms = configuredPlatforms();
-requireConfiguredPlatform(platforms);
-// Telegram allows only one getUpdates poller per bot token. If another
-// `metro` instance is already running, exit cleanly instead of fighting
-// (409 spam). Stale lockfiles (PID dead) are reclaimed.
-const LOCK_FILE = join(STATE_DIR, '.tail-lock');
-function processIsAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
+import { localAgent } from './local.js';
+import { assertAgentId, localUrl } 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 };
 }
-if (existsSync(LOCK_FILE)) {
-    const pid = Number(readFileSync(LOCK_FILE, 'utf8').trim());
-    if (Number.isInteger(pid) && pid > 0 && processIsAlive(pid)) {
-        log.info({ pid }, 'another `metro` instance is already polling; exiting');
-        process.exit(0);
-    }
+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 agent = localAgent();
+            if (agent === null || (agentId !== undefined && agent.id !== agentId))
+                throw new Error(`no agent ${agentId === undefined ? '' : `${agentId} `}on this machine — start metro serve, or set METRO_AGENT_KEY`);
+            return Promise.resolve(agent.key);
+        },
+        fixed: false,
+    };
+}
+const armStall = (control) => setTimeout(() => {
+    control.abort();
+}, STALL_MS);
+async function connect(key, signal) {
     try {
-        unlinkSync(LOCK_FILE);
+        return await fetch(`${localUrl()}/api/tail`, {
+            headers: { authorization: `Bearer ${key}` },
+            signal,
+        });
+    }
+    catch {
+        return null;
     }
-    catch { }
 }
-writeFileSync(LOCK_FILE, String(process.pid));
-function releaseLock() {
+async function pump(body, control, stall) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
     try {
-        if (existsSync(LOCK_FILE) && readFileSync(LOCK_FILE, 'utf8').trim() === String(process.pid)) {
-            unlinkSync(LOCK_FILE);
+        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 { }
+    catch {
+        return 'ended';
+    }
 }
-process.on('exit', releaseLock);
-const TYPING_DIR = join(STATE_DIR, '.typing-stop');
-const TYPING_REFRESH_MS = 4_000;
-const TYPING_MAX_MS = 60_000;
-mkdirSync(TYPING_DIR, { recursive: true });
-// Codex push channel. Set METRO_CODEX_RC to the codex app-server URL
-// (typically `ws://127.0.0.1:8421` matching `codex app-server --listen
-// ws://127.0.0.1:8421`) to inject each inbound into the agent's history
-// via JSON-RPC `turn/start`. Codex's TUI `--remote` flag only accepts
-// ws://, so the daemon, the TUI, and metro must all share the same URL.
-// Unset → metro behaves exactly as before; stdout emit always runs first
-// so Claude Code Monitor users are unaffected.
-const codexRC = process.env.METRO_CODEX_RC ? new CodexRC(process.env.METRO_CODEX_RC, pkg.version) : null;
-codexRC?.start();
-const emit = (line) => {
-    const json = JSON.stringify(line);
-    process.stdout.write(`${json}\n`);
-    codexRC?.push(json);
-};
-const typingActive = new Map();
-const typingKey = (platform, chat) => `${platform}_${chat}`;
-function fireTyping(platform, chat) {
-    if (platform === 'telegram') {
-        void tg('sendChatAction', { chat_id: chat, action: 'typing' }).catch(err => log.warn({ err: errMsg(err) }, 'telegram typing failed'));
+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);
     }
-    else {
-        void discord.sendTyping(chat).catch(err => log.warn({ err: errMsg(err) }, 'discord typing failed'));
+    finally {
+        clearTimeout(stall.timer);
     }
 }
-function startTyping(platform, chat) {
-    const k = typingKey(platform, chat);
-    typingActive.set(k, { platform, chat, started: Date.now() });
-    // Clear any stale stop signal so the new typing actually fires.
-    const stopFile = join(TYPING_DIR, k);
-    if (existsSync(stopFile)) {
-        try {
-            unlinkSync(stopFile);
-        }
-        catch { }
-    }
-    fireTyping(platform, chat);
+function note(state, message) {
+    if (state.last === message)
+        return;
+    state.last = message;
+    process.stderr.write(`metro: ${message}\n`);
 }
-setInterval(() => {
-    const now = Date.now();
-    for (const [k, e] of typingActive) {
-        const stopFile = join(TYPING_DIR, k);
-        if (existsSync(stopFile)) {
-            try {
-                unlinkSync(stopFile);
-            }
-            catch { }
-            typingActive.delete(k);
-            continue;
-        }
-        if (now - e.started > TYPING_MAX_MS) {
-            typingActive.delete(k);
-            continue;
-        }
-        fireTyping(e.platform, e.chat);
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function settle(end, source, key, 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();
     }
-}, TYPING_REFRESH_MS);
-if (platforms.telegram) {
-    const me = await telegram.getMe();
-    log.info({ bot: `@${me.username}` }, 'telegram ready');
-    telegram.onInbound(m => {
-        void tg('setMessageReaction', {
-            chat_id: m.chat_id,
-            message_id: m.message_id,
-            reaction: [{ type: 'emoji', emoji: '👀' }],
-        }).catch(err => log.warn({ err: errMsg(err) }, 'telegram auto-react failed'));
-        const chat = String(m.chat_id);
-        startTyping('telegram', chat);
-        emit({ platform: 'telegram', to: `telegram:${chat}/${m.message_id}`, text: m.text });
-    });
-    void telegram.startPolling();
+    if (end === 'unreachable')
+        note(state, `no metro daemon on ${localUrl()} — run 'metro serve'`);
+    else
+        note(state, 'stream ended — reconnecting');
+    return key;
 }
-if (platforms.discord) {
-    await discord.startGateway();
-    const me = await discord.getMe();
-    log.info({ bot: me.username }, 'discord ready');
-    discord.onInbound(m => {
-        void discord
-            .setReaction(m.channel_id, m.message_id, '👀')
-            .catch(err => log.warn({ err: errMsg(err) }, 'discord auto-react failed'));
-        startTyping('discord', m.channel_id);
-        emit({ platform: 'discord', to: `discord:${m.channel_id}/${m.message_id}`, text: m.text });
-    });
-}
-// `process.on('exit', releaseLock)` above runs whenever process.exit is
-// called. We also `await discord.shutdownGateway()` here so the bot flips
-// offline immediately on SIGTERM / SIGINT instead of waiting ~45s for the
-// gateway's missed-heartbeat timeout. SIGKILL bypasses this (nothing we can
-// do); the lockfile auto-reclaims on the next start either way.
-let shuttingDown = false;
-async function shutdown() {
-    if (shuttingDown)
-        return;
-    shuttingDown = true;
-    codexRC?.stop();
-    if (platforms.discord) {
-        await discord.shutdownGateway().catch(err => log.warn({ err: errMsg(err) }, 'discord shutdown failed'));
+export async function tailEvents(argv) {
+    const agentId = argv[0] === undefined ? undefined : 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, state);
+        await delay(backoffAt(attempt));
+        attempt += 1;
     }
-    process.exit(0);
 }
-process.stdin.on('end', shutdown);
-process.stdin.on('close', shutdown);
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);

package/dist/update.js

@@ -0,0 +1,45 @@
+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 const checkReport = (current, latest) => ({
+    current,
+    latest,
+    newer: latest !== '' && isNewer(latest, current),
+});
+export async function updateCheck() {
+    return checkReport(currentVersion(), await publishedVersion());
+}
+export async function update(argv = []) {
+    if (argv.includes('--check')) {
+        process.stdout.write(`${JSON.stringify(await updateCheck())}\n`);
+        return 0;
+    }
+    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.200",
+  "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,26 @@
     "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"
-  },
-  "packageManager": "bun@1.3.9"
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
 }

package/runtime/marketplace/.claude-plugin/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "metro",
+  "description": "Metro — connector relay and chat bridge for agents",
+  "owner": { "name": "Bonustrack", "url": "https://metro.box" },
+  "plugins": [
+    {
+      "name": "metro",
+      "source": "./plugin",
+      "description": "Every connector on this box as its own MCP server through metro's local relay, the orchestrator guard, and the standing rules loaded at session start."
+    }
+  ]
+}

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "metro",
+  "version": "0.1.0-beta.200",
+  "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
+  "author": {
+    "name": "Bonustrack",
+    "url": "https://metro.box"
+  },
+  "repository": "https://github.com/bonustrack/metro",
+  "license": "MIT",
+  "keywords": [
+    "metro",
+    "mcp",
+    "connectors",
+    "relay"
+  ]
+}

package/runtime/marketplace/plugin/.mcp.json

@@ -0,0 +1 @@
+{}

package/runtime/marketplace/plugin/bin/guard.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { policyVerdict } from './policy.mjs';
+
+const BLOCKING = new Set(['AskUserQuestion', 'ExitPlanMode', 'EnterPlanMode']);
+const ORCHESTRATION = new Set([
+  'Agent',
+  'Workflow',
+  'ToolSearch',
+  'Skill',
+  'ScheduleWakeup',
+  'Monitor',
+  'CronCreate',
+  'CronList',
+  'CronDelete',
+  'TaskCreate',
+  'TaskGet',
+  'TaskList',
+  'TaskOutput',
+  'TaskStop',
+  'TaskUpdate',
+]);
+const IMAGE = /\.(png|jpe?g|gif|webp|bmp)$/i;
+const MCP = /^mcp__/;
+const METRO_MCP = /^mcp__metro__/;
+
+function answer(decision, reason) {
+  process.stdout.write(
+    `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: decision, permissionDecisionReason: reason } })}\n`,
+  );
+}
+
+function ownerPolicy(tool, input, subagent) {
+  const verdict = policyVerdict(tool, input);
+  if (verdict === null) return null;
+  const { where } = verdict;
+  if (verdict.access === 'deny') return { decision: 'deny', reason: `Blocked by the owner's policy for ${verdict.owner} (${verdict.tool}).` };
+  if (subagent) return { decision: 'ask', reason: `The owner asked to approve ${where}.` };
+  return {
+    decision: 'deny',
+    reason: `${where} needs the owner's approval, and waiting for it here would stop the whole session. Run this exact call from a background worker (Agent, run_in_background: true): the worker waits for the owner's answer while you keep answering.`,
+  };
+}
+
+function verdict(payload, input) {
+  const tool = typeof payload.tool_name === 'string' ? payload.tool_name : '';
+  if (BLOCKING.has(tool))
+    return `${tool} blocks the session waiting on the terminal, and nobody is watching it. Decide with your best judgement and state the assumption, or ask over chat with the metro tools and keep working in the meantime.`;
+  if (typeof payload.agent_id === 'string' && payload.agent_id !== '') return null;
+  if (tool === 'Agent' && input.run_in_background === false)
+    return 'A foreground subagent blinds the main thread: it cannot see or acknowledge inbound metro messages until the agent finishes. Re-issue the identical Agent call with run_in_background: true, then wait for the task notification.';
+  if (ORCHESTRATION.has(tool)) return null;
+  if (METRO_MCP.test(tool)) return null;
+  if (MCP.test(tool))
+    return `A connector call is work, not orchestration: ${tool} reads somebody's files, mail or records, and its answer can be long enough to crowd out the chat you are here to follow. Only metro's own tools run on this thread. Delegate it to a subagent with the Agent tool (run_in_background: true; the worker reaches every connector) and relay what it finds.`;
+  if (tool === 'Read' && typeof input.file_path === 'string' && IMAGE.test(input.file_path)) return null;
+  return `The main thread is orchestrator-only, so ${tool === '' ? 'this tool' : tool} is not available here. Delegate the work to a subagent with the Agent tool (run_in_background: true; the worker agent has full tool access) or to a Workflow, and report the result over metro.`;
+}
+
+let payload = {};
+try {
+  payload = JSON.parse(readFileSync(0, 'utf8'));
+} catch {
+  payload = {};
+}
+const shaped = payload !== null && typeof payload === 'object' ? payload : {};
+const input = shaped.tool_input !== null && typeof shaped.tool_input === 'object' ? shaped.tool_input : {};
+const reason = verdict(shaped, input);
+const policy = reason === null && typeof shaped.tool_name === 'string' ? ownerPolicy(shaped.tool_name, input, typeof shaped.agent_id === 'string' && shaped.agent_id !== '') : null;
+if (reason !== null) answer('deny', reason);
+else if (policy !== null) answer(policy.decision, policy.reason);

package/runtime/marketplace/plugin/bin/metro-plugin.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const agentsDir = () => process.env.METRO_AGENTS_DIR || join(homedir(), '.metro', 'agents');
+
+function readAgent() {
+  const path = join(agentsDir(), 'agent.json');
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    throw new Error(`no agent on this machine yet (${path})`);
+  }
+  if (typeof parsed?.key !== 'string') throw new Error(`no agent key in ${path}`);
+  return parsed;
+}
+
+if (process.argv[2] !== 'headers') {
+  process.stderr.write('usage: metro-plugin.mjs headers\n');
+  process.exit(1);
+}
+
+try {
+  process.stdout.write(`${JSON.stringify({ Authorization: `Bearer ${readAgent().key}` })}\n`);
+} catch (err) {
+  process.stderr.write(`metro: ${err.message}\n`);
+  process.stdout.write('{}\n');
+}