@stage-labs/metro 0.1.0-beta.101 → 0.1.0-beta.103

package/dist/claude.js

@@ -1,5 +1,6 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { markOnboardingDone } from './onboarding.js';
+import { writeMcpConfig } from './mcp-config.js';
 import { settingsConflicts, settingsFiles } from './claude-settings.js';
 import { localAgents, pickLocalAgent } from './local.js';
 import { PROVIDER_FLAGS } from './provider-flags.js';
@@ -7,8 +8,9 @@ import { localPort, localUrl } from './runtime.js';
 const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
 const KEY_HEADER = 'x-metro-key';
 const PROBE_MS = 3_000;
-export const claudeArgs = (extra) => [
+export const claudeArgs = (extra, mcpConfig) => [
     ...CHANNEL_FLAGS,
+    ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
     ...extra,
 ];
 const set = (env, name) => (env[name] ?? '').trim() !== '';
@@ -114,19 +116,43 @@ export function runClaude(args, env) {
         });
     });
 }
-export async function launchClaude(extra) {
-    const decision = await verdict();
-    if ('skip' in decision) {
-        process.stderr.write(`metro claude: ${decision.skip}\n`);
-        return runClaude(claudeArgs(extra), process.env);
-    }
-    const port = localPort();
+async function servedKey(decision) {
+    if ('key' in decision)
+        return decision.key;
+    const picked = agentKey(localAgentList(), process.env.METRO_AGENT);
+    if ('skip' in picked)
+        return null;
+    return (await daemonServing()) ? picked.key : null;
+}
+function mcpConfigFor(key, port) {
+    if (key === null)
+        return null;
+    const file = writeMcpConfig(key, port);
+    process.stderr.write(`metro claude: the metro MCP server is loaded for this session from the daemon at http://127.0.0.1:${String(port)}/mcp, nothing to add by hand\n`);
+    return file;
+}
+function gatewayLaunchEnv(key, port) {
     process.stderr.write(`metro claude: inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)\n`);
-    const routed = gatewayEnv(process.env, decision.key, port);
-    const env = credentialEnv(routed, decision.key, claudeSignedIn());
+    const routed = gatewayEnv(process.env, key, port);
+    const env = credentialEnv(routed, key, claudeSignedIn());
     if (env !== routed)
         process.stderr.write("metro claude: Claude Code has no login of its own here, so metro's key stands in as its credential; the Model page must route to Bedrock, OpenRouter or Codex\n");
     if (markOnboardingDone() === 'marked')
         process.stderr.write("metro claude: skipped Claude Code's first-run setup, since it already has a credential here\n");
-    return runClaude(claudeArgs(extra), env);
+    return env;
+}
+export async function launchClaude(extra) {
+    const decision = await verdict();
+    const port = localPort();
+    const mcp = mcpConfigFor(await servedKey(decision), port);
+    try {
+        if ('skip' in decision) {
+            process.stderr.write(`metro claude: ${decision.skip}\n`);
+            return await runClaude(claudeArgs(extra, mcp?.path), process.env);
+        }
+        return await runClaude(claudeArgs(extra, mcp?.path), gatewayLaunchEnv(decision.key, port));
+    }
+    finally {
+        mcp?.cleanup();
+    }
 }

package/dist/mcp-config.js

@@ -0,0 +1,25 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const METRO_SERVER = 'metro';
+export function metroMcpConfig(agentKey, port) {
+    const servers = {
+        [METRO_SERVER]: {
+            type: 'http',
+            url: `http://127.0.0.1:${String(port)}/mcp`,
+            headers: { Authorization: `Bearer ${agentKey}` },
+        },
+    };
+    return `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`;
+}
+export function writeMcpConfig(agentKey, port, base = tmpdir()) {
+    const dir = mkdtempSync(join(base, 'metro-claude-'));
+    const path = join(dir, 'mcp.json');
+    writeFileSync(path, metroMcpConfig(agentKey, port), { mode: 0o600 });
+    return {
+        path,
+        cleanup: () => {
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.101",
+  "version": "0.1.0-beta.103",
   "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/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.101",
+  "version": "0.1.0-beta.103",
   "description": "Metro connectors for Claude Code. Runs beside the metro daemon on this machine: each connector the agent holds is one MCP server relayed through the daemon, the daemon keeps that list current on its own, and /reload-plugins picks up a new one without leaving your session. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/daemon/src/boot/boot.ts

@@ -23,6 +23,7 @@ import { agentsDir, fileSource } from '../agents/files.js';
 import { ConnectorWatch } from '../connectors/watch.js';
 import { syncPluginServers } from '../connectors/plugin-sync.js';
 import { ensureMetroPlugin } from '../claude/plugin-install.js';
+import { unwatchSession, watchSession } from '../claude/session.js';
 import { applyLocalOwner } from './local-owner.js';
 import { localOwner } from '../agents/file-admin.js';
 import { ensureStationDeps } from '../stations/runtime-deps.js';
@@ -159,6 +160,7 @@ async function main(): Promise<void> {
     .catch((err: unknown) => {
       log.warn({ err: errMsg(err) }, 'plugin: could not ensure the Claude Code plugin');
     });
+  watchSession();
 }
 
 const SHUTDOWN_TIMEOUT_MS = 3_000;
@@ -170,6 +172,7 @@ async function shutdown(): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
   log.info('dispatcher shutting down');
+  unwatchSession();
   connectors?.stop();
   tunnel?.stop();
   if (webhookServer) {

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

@@ -21,6 +21,14 @@ import {
   startClaudeLogin,
   type LoginDeps,
 } from './login.js';
+import {
+  ensureSession,
+  sessionStatus,
+  setAutostart,
+  startSession,
+  stopSession,
+  type SessionDeps,
+} from './session.js';
 import {
   claudeDir,
   deleteClaudeSession,
@@ -41,6 +49,7 @@ export interface ClaudeApiDeps {
   authorize: (subject: string) => void;
   dir?: () => string;
   login?: LoginDeps;
+  session?: SessionDeps;
 }
 
 function projectOf(query: URLSearchParams): string {
@@ -101,6 +110,31 @@ async function created(req: IncomingMessage, path: string, dir: string): Promise
 }
 
 const LOGIN = 'login';
+const SESSION = 'session';
+
+function sessionCommand(body: Record<string, unknown>, session: SessionDeps): unknown {
+  if (body.action === 'start') {
+    const status = sessionStatus(session);
+    if (status.running) return status;
+    if (status.blocked !== null) throw new ApiError(`cannot start a Claude session: ${status.blocked}`, 409);
+    return startSession(session);
+  }
+  if (body.action === 'stop') return stopSession(session);
+  if (body.action !== undefined) throw new ApiError('action must be start or stop', 400);
+  if (body.autostart === true) ensureSession(session);
+  return sessionStatus(session);
+}
+
+async function sessionAnswer(req: IncomingMessage, deps: ClaudeApiDeps): Promise<unknown> {
+  const session = deps.session ?? {};
+  const method = req.method ?? 'GET';
+  if (method === 'GET') return sessionStatus(session);
+  if (method !== 'POST') throw new ApiError('method not allowed', 405);
+  const body = await readJsonBody(req);
+  if (!isRecord(body)) throw new ApiError('a body is required', 400);
+  if (typeof body.autostart === 'boolean') setAutostart(body.autostart, session.agents);
+  return sessionCommand(body, session);
+}
 
 async function loginAnswer(req: IncomingMessage, id: string, deps: ClaudeApiDeps): Promise<unknown> {
   const method = req.method ?? 'GET';
@@ -136,6 +170,16 @@ function answer(method: string, path: string, query: URLSearchParams, dir: strin
   return handler(query, dir, item);
 }
 
+function routed(req: IncomingMessage, path: string, search: string, deps: ClaudeApiDeps): unknown {
+  const dir = (deps.dir ?? claudeDir)();
+  const [head = '', item = ''] = parts(path);
+  if (head === LOGIN) return loginAnswer(req, item, deps);
+  if (head === SESSION && item === '') return sessionAnswer(req, deps);
+  if (req.method === 'PUT') return writeAnswer(req, path, dir);
+  if (req.method === 'POST') return created(req, path, dir);
+  return answer(req.method ?? 'GET', path, new URLSearchParams(search), dir);
+}
+
 export function handleClaudeRequest(
   req: IncomingMessage,
   res: ServerResponse,
@@ -155,12 +199,7 @@ export function handleClaudeRequest(
     .then((session) => {
       if (!session) throw new ApiError('unauthorized', 401);
       deps.authorize(session.subject);
-      const dir = (deps.dir ?? claudeDir)();
-      const [head = '', item = ''] = parts(path);
-      if (head === LOGIN) return loginAnswer(req, item, deps);
-      if (req.method === 'PUT') return writeAnswer(req, path, dir);
-      if (req.method === 'POST') return created(req, path, dir);
-      return answer(req.method ?? 'GET', path, new URLSearchParams(search), dir);
+      return routed(req, path, search, deps);
     })
     .then((body) => {
       sendJson(req, res, 200, body);

package/runtime/node_modules/@metro-labs/daemon/src/claude/onboarding.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { isRecord } from '@metro-labs/core/is-record';
@@ -32,3 +32,25 @@ export function markOnboardingDone(path = claudeConfigPath()): OnboardingMark {
   writeFileSync(path, `${JSON.stringify({ ...config, [FLAG]: true }, null, 2)}\n`, { mode: 0o600 });
   return 'marked';
 }
+
+const TRUST = 'hasTrustDialogAccepted';
+
+function realDir(dir: string): string {
+  try {
+    return realpathSync(dir);
+  } catch {
+    return dir;
+  }
+}
+
+export function trustFolder(dir: string, path = claudeConfigPath()): OnboardingMark {
+  const config = readConfig(path);
+  if (config === null) return 'unreadable';
+  const key = realDir(dir);
+  const projects = isRecord(config.projects) ? config.projects : {};
+  const project = isRecord(projects[key]) ? projects[key] : {};
+  if (project[TRUST] === true) return 'already';
+  const next = { ...config, projects: { ...projects, [key]: { ...project, [TRUST]: true } } };
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+  return 'marked';
+}

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

@@ -0,0 +1,187 @@
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readJson, writeJson } from '@metro-labs/core/secure-fs';
+import { agentsDir, listAgentFiles } from '../agents/files.js';
+import { notReady, readModelConfig } from '../gateway/model-config.js';
+import { claudeAccount, claudeInstalled } from './login.js';
+import { trustFolder } from './onboarding.js';
+
+export const SESSION_NAME = 'metro';
+const STATE_FILE = 'claude-session.json';
+const WARNING = 'WARNING: Loading development channels';
+const CONFIRM_POLL_MS = 500;
+const CONFIRM_WAIT_MS = 60_000;
+const WATCH_MS = 15_000;
+const STRIKE_WINDOW_MS = 60_000;
+const MAX_STRIKES = 5;
+const PAUSE_MS = 30 * 60_000;
+
+export interface SessionDeps {
+  tmux?: string;
+  metro?: string[];
+  home?: string;
+  agents?: string;
+  signedIn?: () => boolean;
+  now?: () => number;
+}
+
+export interface SessionStatus {
+  name: string;
+  running: boolean;
+  autostart: boolean;
+  blocked: string | null;
+  lastStartedAt: string | null;
+  lastError: string | null;
+}
+
+interface Memory {
+  lastStartedAt: number | null;
+  lastError: string | null;
+  strikes: number;
+  pausedUntil: number;
+}
+
+const memory: Memory = { lastStartedAt: null, lastError: null, strikes: 0, pausedUntil: 0 };
+
+const statePath = (agents: string): string => join(agents, STATE_FILE);
+
+export function autostartEnabled(agents = agentsDir()): boolean {
+  const raw = readJson<unknown>(statePath(agents), null);
+  return !isRecord(raw) || raw.autostart !== false;
+}
+
+export function setAutostart(enabled: boolean, agents = agentsDir()): void {
+  writeJson(statePath(agents), { autostart: enabled });
+}
+
+function tmuxOk(tmux: string, args: string[]): boolean {
+  const run = spawnSync(tmux, args, { stdio: 'ignore' });
+  return run.error === undefined && run.status === 0;
+}
+
+export const sessionRunning = (tmux = 'tmux'): boolean => tmuxOk(tmux, ['has-session', '-t', SESSION_NAME]);
+
+function metroCommand(deps: SessionDeps): string[] {
+  if (deps.metro !== undefined) return deps.metro;
+  const bin = process.env.METRO_CLI_BIN?.trim() ?? '';
+  return bin === '' ? ['metro', 'claude'] : [process.execPath, bin, 'claude'];
+}
+
+function credentialReady(deps: SessionDeps): string | null {
+  const signedIn = deps.signedIn ?? (() => claudeAccount().signedIn);
+  if (signedIn()) return null;
+  try {
+    const cfg = readModelConfig(deps.agents ?? agentsDir());
+    if (cfg.provider !== 'anthropic' && notReady(cfg) === null) return null;
+  } catch (err) {
+    return `the Model page is not readable (${errMsg(err)})`;
+  }
+  return 'Claude Code is not signed in and the Model page routes nowhere yet';
+}
+
+export function sessionBlocked(deps: SessionDeps = {}): string | null {
+  const agents = deps.agents ?? agentsDir();
+  if (listAgentFiles(agents).length === 0) return 'no agent on this machine yet';
+  if (deps.metro === undefined && !claudeInstalled()) return 'Claude Code is not installed on this machine';
+  if (!tmuxOk(deps.tmux ?? 'tmux', ['-V'])) return 'tmux is not installed on this machine';
+  return credentialReady(deps);
+}
+
+function capturePane(tmux: string): string {
+  const run = spawnSync(tmux, ['capture-pane', '-p', '-t', SESSION_NAME], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  return run.error === undefined && run.status === 0 ? run.stdout : '';
+}
+
+function confirmChannels(tmux: string, until: number): void {
+  const tick = (): void => {
+    const pane = capturePane(tmux);
+    if (pane.includes(WARNING) && pane.includes('server:metro')) {
+      spawnSync(tmux, ['send-keys', '-t', SESSION_NAME, 'Enter'], { stdio: 'ignore' });
+      log.info('claude-session: confirmed the development channels dialog for server:metro');
+      return;
+    }
+    if (Date.now() < until && sessionRunning(tmux)) setTimeout(tick, CONFIRM_POLL_MS).unref();
+  };
+  setTimeout(tick, CONFIRM_POLL_MS).unref();
+}
+
+export function startSession(deps: SessionDeps = {}): SessionStatus {
+  const tmux = deps.tmux ?? 'tmux';
+  const home = deps.home ?? homedir();
+  const now = (deps.now ?? Date.now)();
+  const trusted = trustFolder(home);
+  const [command = 'metro', ...args] = metroCommand(deps);
+  const run = spawnSync(tmux, ['new-session', '-d', '-s', SESSION_NAME, '-c', home, '-x', '200', '-y', '50', command, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], cwd: home });
+  memory.lastStartedAt = now;
+  if (run.error !== undefined || run.status !== 0) {
+    memory.lastError = run.error === undefined ? `tmux new-session exited ${String(run.status)}: ${run.stderr.trim()}` : errMsg(run.error);
+    log.warn({ err: memory.lastError }, 'claude-session: tmux could not start');
+  } else {
+    memory.lastError = null;
+    log.info({ home, trusted, command: [command, ...args].join(' ') }, 'claude-session: started Claude Code in tmux');
+    confirmChannels(tmux, now + CONFIRM_WAIT_MS);
+  }
+  return sessionStatus(deps);
+}
+
+export function stopSession(deps: SessionDeps = {}): SessionStatus {
+  spawnSync(deps.tmux ?? 'tmux', ['kill-session', '-t', SESSION_NAME], { stdio: 'ignore' });
+  return sessionStatus(deps);
+}
+
+export function sessionStatus(deps: SessionDeps = {}): SessionStatus {
+  return {
+    name: SESSION_NAME,
+    running: sessionRunning(deps.tmux ?? 'tmux'),
+    autostart: autostartEnabled(deps.agents ?? agentsDir()),
+    blocked: sessionBlocked(deps),
+    lastStartedAt: memory.lastStartedAt === null ? null : new Date(memory.lastStartedAt).toISOString(),
+    lastError: memory.lastError,
+  };
+}
+
+function strike(now: number): boolean {
+  if (memory.lastStartedAt !== null && now - memory.lastStartedAt < STRIKE_WINDOW_MS) memory.strikes += 1;
+  else memory.strikes = 1;
+  if (memory.strikes < MAX_STRIKES) return false;
+  memory.pausedUntil = now + PAUSE_MS;
+  memory.strikes = 0;
+  log.warn({ pauseMinutes: PAUSE_MS / 60_000 }, 'claude-session: Claude Code keeps exiting right after starting; not restarting it for a while');
+  return true;
+}
+
+export function ensureSession(deps: SessionDeps = {}): 'started' | 'running' | 'blocked' | 'off' | 'paused' {
+  const now = (deps.now ?? Date.now)();
+  if (!autostartEnabled(deps.agents ?? agentsDir())) return 'off';
+  if (sessionRunning(deps.tmux ?? 'tmux')) return 'running';
+  if (now < memory.pausedUntil) return 'paused';
+  if (sessionBlocked(deps) !== null) return 'blocked';
+  if (strike(now)) return 'paused';
+  startSession(deps);
+  return 'started';
+}
+
+let watcher: ReturnType<typeof setInterval> | null = null;
+
+export function watchSession(deps: SessionDeps = {}, everyMs = WATCH_MS): void {
+  if (watcher !== null) return;
+  const tick = (): void => {
+    try {
+      const outcome = ensureSession(deps);
+      if (outcome === 'started') log.info('claude-session: started');
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'claude-session: check failed');
+    }
+  };
+  watcher = setInterval(tick, everyMs);
+  watcher.unref();
+  setTimeout(tick, 1_000).unref();
+}
+
+export function unwatchSession(): void {
+  if (watcher !== null) clearInterval(watcher);
+  watcher = null;
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.101"
+  "version": "0.1.0-beta.103"
 }