@stage-labs/metro 0.1.0-beta.70 → 0.1.0-beta.72

package/dist/bedrock.js

@@ -1,63 +1,10 @@
-import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { claudeArgs } from './claude.js';
+import { claudeArgs, runClaude } from './claude.js';
 import { bedrockConfigFromEnv, startBedrockProxy } from './bedrock-proxy.js';
-export const PROVIDER_FLAGS = [
-    'CLAUDE_CODE_USE_BEDROCK',
-    'CLAUDE_CODE_USE_MANTLE',
-    'CLAUDE_CODE_USE_VERTEX',
-    'CLAUDE_CODE_USE_FOUNDRY',
-    'CLAUDE_CODE_USE_ANTHROPIC_AWS',
-    'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
-    'CLAUDE_CODE_USE_GATEWAY',
-];
-const CONFLICTING = [
-    ...PROVIDER_FLAGS,
-    'ANTHROPIC_BASE_URL',
-    'ANTHROPIC_API_KEY',
-    'ANTHROPIC_AUTH_TOKEN',
-];
+import { settingsConflicts, settingsFiles } from './claude-settings.js';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+export { PROVIDER_FLAGS, settingsConflicts, settingsFiles };
 const SCRUBBED = [...PROVIDER_FLAGS, 'ANTHROPIC_API_KEY', 'AWS_BEARER_TOKEN_BEDROCK'];
-export function settingsFiles(cwd = process.cwd(), env = process.env) {
-    const explicit = env.CLAUDE_CONFIG_DIR?.trim() ?? '';
-    const configDir = explicit === '' ? join(homedir(), '.claude') : explicit;
-    return [
-        ...new Set([
-            join(configDir, 'settings.json'),
-            join(cwd, '.claude', 'settings.json'),
-            join(cwd, '.claude', 'settings.local.json'),
-        ]),
-    ];
-}
-function envBlock(file) {
-    if (!existsSync(file))
-        return {};
-    try {
-        const parsed = JSON.parse(readFileSync(file, 'utf8'));
-        const block = parsed.env;
-        return typeof block === 'object' && block !== null
-            ? block
-            : {};
-    }
-    catch {
-        return {};
-    }
-}
-export function settingsConflicts(files) {
-    const out = [];
-    for (const file of files) {
-        const block = envBlock(file);
-        for (const key of CONFLICTING) {
-            const value = block[key];
-            if (typeof value === 'string' && value.trim() !== '')
-                out.push(`${file}: ${key}`);
-        }
-    }
-    return out;
-}
 export function firstPartyModelId(bedrockId) {
     return bedrockId.replace(/^(?:[a-z-]+\.)?anthropic\./, '').replace(/-v\d+:\d+$/, '');
 }
@@ -71,22 +18,6 @@ export function claudeEnv(base, port, token, pinned = null) {
         ANTHROPIC_AUTH_TOKEN: token,
     };
 }
-function runClaude(args, env) {
-    return new Promise((resolve, reject) => {
-        const leaveToChild = () => undefined;
-        process.on('SIGINT', leaveToChild);
-        process.on('SIGTERM', leaveToChild);
-        const child = spawn('claude', args, { stdio: 'inherit', env });
-        child.on('error', (err) => {
-            reject(new Error(err.code === 'ENOENT'
-                ? 'the `claude` command is not on PATH — install Claude Code first'
-                : err.message));
-        });
-        child.on('exit', (code) => {
-            resolve(code ?? 1);
-        });
-    });
-}
 export async function bedrock(argv) {
     const cfg = bedrockConfigFromEnv();
     const conflicts = settingsConflicts(settingsFiles());

package/dist/claude-settings.js

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+const CONFLICTING = [...PROVIDER_FLAGS, 'ANTHROPIC_BASE_URL', 'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
+export function settingsFiles(cwd = process.cwd(), env = process.env) {
+    const explicit = env.CLAUDE_CONFIG_DIR?.trim() ?? '';
+    const configDir = explicit === '' ? join(homedir(), '.claude') : explicit;
+    return [
+        ...new Set([
+            join(configDir, 'settings.json'),
+            join(cwd, '.claude', 'settings.json'),
+            join(cwd, '.claude', 'settings.local.json'),
+        ]),
+    ];
+}
+function envBlock(file) {
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        const block = parsed.env;
+        return typeof block === 'object' && block !== null ? block : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function settingsConflicts(files) {
+    const out = [];
+    for (const file of files) {
+        const block = envBlock(file);
+        for (const key of CONFLICTING) {
+            const value = block[key];
+            if (typeof value === 'string' && value.trim() !== '')
+                out.push(`${file}: ${key}`);
+        }
+    }
+    return out;
+}

package/dist/claude.js

@@ -1,15 +1,107 @@
-import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
+import { settingsConflicts, settingsFiles } from './claude-settings.js';
+import { localAgents, pickLocalAgent } from './local.js';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+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) => [
     ...CHANNEL_FLAGS,
     ...extra,
 ];
-export function launchClaude(extra) {
-    const leaveToChild = () => undefined;
-    process.on('SIGINT', leaveToChild);
-    process.on('SIGTERM', leaveToChild);
-    const res = spawnSync('claude', claudeArgs(extra), { stdio: 'inherit' });
-    if (res.error !== undefined)
-        throw new Error('the `claude` command is not on PATH — install Claude Code first');
-    return Promise.resolve(res.status ?? 1);
+const set = (env, name) => (env[name] ?? '').trim() !== '';
+export function pinnedBy(env) {
+    if (set(env, 'ANTHROPIC_BASE_URL'))
+        return 'ANTHROPIC_BASE_URL';
+    return PROVIDER_FLAGS.find((flag) => set(env, flag)) ?? null;
+}
+export function gatewayEnv(base, agentKey, port) {
+    if (agentKey === null || pinnedBy(base) !== null)
+        return base;
+    const own = (base.ANTHROPIC_CUSTOM_HEADERS ?? '').trim();
+    const mine = `${KEY_HEADER}: ${agentKey}`;
+    return {
+        ...base,
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}/gateway`,
+        ANTHROPIC_CUSTOM_HEADERS: own === '' ? mine : `${own}\n${mine}`,
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+    };
+}
+export function servingDaemon(body) {
+    if (typeof body !== 'object' || body === null)
+        return false;
+    const mode = body;
+    return mode.mode === 'local' && mode.stopped !== true;
+}
+async function daemonServing(base = localUrl()) {
+    try {
+        const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });
+        return res.ok && servingDaemon(await res.json());
+    }
+    catch {
+        return false;
+    }
+}
+export function agentKey(agents, wanted) {
+    if (agents.length === 0)
+        return { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' };
+    try {
+        return { key: pickLocalAgent(agents, wanted).key };
+    }
+    catch {
+        return {
+            skip: wanted === undefined || wanted === ''
+                ? 'several agents live here; set METRO_AGENT=<name> to route through the daemon, Claude Code talks to Anthropic directly for now'
+                : `no agent named '${wanted}' lives here, so Claude Code talks to Anthropic directly`,
+        };
+    }
+}
+function localAgentList() {
+    try {
+        return localAgents();
+    }
+    catch {
+        return [];
+    }
+}
+async function verdict() {
+    const pinned = pinnedBy(process.env);
+    if (pinned !== null)
+        return { skip: `${pinned} is set, so Claude Code keeps talking to it` };
+    const conflicts = settingsConflicts(settingsFiles());
+    if (conflicts.length > 0)
+        return { skip: `a settings file pins the provider (${conflicts.join(', ')}), so Claude Code keeps it` };
+    const picked = agentKey(localAgentList(), process.env.METRO_AGENT);
+    if ('skip' in picked)
+        return picked;
+    if (await daemonServing())
+        return picked;
+    return { skip: 'the daemon is not serving here (stopped, or not running), so Claude Code talks to Anthropic directly' };
+}
+export function runClaude(args, env) {
+    return new Promise((resolve, reject) => {
+        const leaveToChild = () => undefined;
+        process.on('SIGINT', leaveToChild);
+        process.on('SIGTERM', leaveToChild);
+        const child = spawn('claude', args, { stdio: 'inherit', env });
+        child.on('error', (err) => {
+            reject(new Error(err.code === 'ENOENT'
+                ? 'the `claude` command is not on PATH — install Claude Code first'
+                : err.message));
+        });
+        child.on('exit', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+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();
+    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`);
+    return runClaude(claudeArgs(extra), gatewayEnv(process.env, decision.key, port));
 }

package/dist/hold.js

@@ -145,8 +145,11 @@ async function listen(server, info) {
         }
     }
 }
+const CLOSE_WAIT_MS = 2_000;
 const close = (server) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, CLOSE_WAIT_MS);
     server.close(() => {
+        clearTimeout(timer);
         resolve();
     });
     server.closeAllConnections();
@@ -160,6 +163,13 @@ function releaseLock(lockFile) {
         return;
     }
 }
+function armFunnel(info, log, ending) {
+    if (info.funnel === null || ending !== null)
+        return null;
+    const funnel = new HeldFunnel(info.funnel, info.port, log);
+    funnel.start();
+    return funnel;
+}
 export const holdBanner = (info) => `metro is stopped. Holding http://${info.host}:${String(info.port)}${info.funnel === null ? '' : ' and the Funnel address'} ` +
     'until Start on the Server page; Ctrl-C or metro stop ends metro serve';
 export async function holdUntilStart(info, deps = {}) {
@@ -169,8 +179,12 @@ export async function holdUntilStart(info, deps = {}) {
             process.stderr.write(`${line}\n`);
         });
     let finish = () => undefined;
+    let ending = null;
     const ended = new Promise((resolve) => {
-        finish = resolve;
+        finish = (end) => {
+            ending ??= end;
+            resolve(end);
+        };
     });
     const server = holdServer(info, () => {
         finish('start');
@@ -178,14 +192,14 @@ export async function holdUntilStart(info, deps = {}) {
     const onSignal = () => {
         finish('exit');
     };
+    signals.on('SIGINT', onSignal);
+    signals.on('SIGTERM', onSignal);
     if (info.lockFile !== null)
         writeFileSync(info.lockFile, String(process.pid));
     await listen(server, info);
-    const funnel = info.funnel === null ? null : new HeldFunnel(info.funnel, info.port, log);
-    funnel?.start();
-    signals.on('SIGINT', onSignal);
-    signals.on('SIGTERM', onSignal);
-    log(holdBanner(info));
+    const funnel = armFunnel(info, log, ending);
+    if (ending === null)
+        log(holdBanner(info));
     const end = await ended;
     signals.off('SIGINT', onSignal);
     signals.off('SIGTERM', onSignal);

package/dist/provider-flags.js

@@ -0,0 +1,9 @@
+export const PROVIDER_FLAGS = [
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_MANTLE',
+    'CLAUDE_CODE_USE_VERTEX',
+    'CLAUDE_CODE_USE_FOUNDRY',
+    'CLAUDE_CODE_USE_ANTHROPIC_AWS',
+    'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
+    'CLAUDE_CODE_USE_GATEWAY',
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.70",
+  "version": "0.1.0-beta.72",
   "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/node_modules/@metro-labs/mcp/src/daemon/claude-api.ts

@@ -1,7 +1,9 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from './log.js';
-import { apiFailure, apiSession, cors, sendJson } from './api-http.js';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson } from './api-http.js';
 import { ApiError } from './api-error.js';
+import { isRecord } from './is-record.js';
+import { listClaudeSettings, SETTINGS_MAX, writeClaudeSettings } from './claude-settings.js';
 import {
   claudeDir,
   deleteClaudeSession,
@@ -13,6 +15,8 @@ import {
 } from './claude-files.js';
 
 const PREFIX = '/api/claude';
+const BODY_MAX = SETTINGS_MAX + 4096;
+const WRITABLE = new Set(['GET', 'DELETE', 'PUT']);
 const PAGE = 100;
 const PAGE_MAX = 500;
 
@@ -39,6 +43,7 @@ const COLLECTIONS: Record<string, Handler> = {
   projects: (_query, dir) => ({ projects: listClaudeProjects(dir) }),
   sessions: (query, dir) => ({ sessions: listClaudeSessions(projectOf(query), dir) }),
   memory: (query, dir) => listMemory(projectOf(query), dir),
+  settings: (_query, dir) => ({ files: listClaudeSettings(dir) }),
 };
 
 const ITEMS: Record<string, Handler> = {
@@ -49,8 +54,19 @@ const ITEMS: Record<string, Handler> = {
   memory: (query, dir, name) => ({ name, content: readMemoryFile(projectOf(query), name, dir) }),
 };
 
+const parts = (path: string): string[] => path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+
+async function writeAnswer(req: IncomingMessage, path: string, dir: string): Promise<unknown> {
+  const [head = '', item = ''] = parts(path);
+  if (head !== 'settings' || item === '') throw new ApiError('method not allowed', 405);
+  const body = await readJsonBody(req, BODY_MAX);
+  if (!isRecord(body) || typeof body.text !== 'string') throw new ApiError('text is required', 400);
+  const seenAt = 'seenAt' in body ? (typeof body.seenAt === 'string' ? body.seenAt : null) : undefined;
+  return writeClaudeSettings(item, body.text, seenAt, dir);
+}
+
 function answer(method: string, path: string, query: URLSearchParams, dir: string): unknown {
-  const rest = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const rest = parts(path);
   const [head = '', item] = rest;
   if (method === 'DELETE') {
     if (rest.length !== 2 || head !== 'sessions') throw new ApiError('method not allowed', 405);
@@ -73,7 +89,7 @@ export function handleClaudeRequest(
     res.writeHead(204, cors(req)).end();
     return true;
   }
-  if (req.method !== 'GET' && req.method !== 'DELETE') {
+  if (!WRITABLE.has(req.method ?? '')) {
     sendJson(req, res, 405, { error: 'method not allowed' });
     return true;
   }
@@ -81,7 +97,9 @@ export function handleClaudeRequest(
     .then((session) => {
       if (!session) throw new ApiError('unauthorized', 401);
       deps.authorize(session.subject);
-      return answer(req.method ?? 'GET', path, new URLSearchParams(search), (deps.dir ?? claudeDir)());
+      const dir = (deps.dir ?? claudeDir)();
+      if (req.method === 'PUT') return writeAnswer(req, path, dir);
+      return answer(req.method ?? 'GET', path, new URLSearchParams(search), dir);
     })
     .then((body) => {
       sendJson(req, res, 200, body);

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

@@ -0,0 +1,117 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { ApiError } from './api-error.js';
+import { claudeDir, listClaudeProjects } from './claude-files.js';
+import { isRecord } from './is-record.js';
+import { errMsg } from './log.js';
+
+export const SETTINGS_MAX = 256 * 1024;
+const USER_ID = 'user';
+const LOCAL_SUFFIX = '.local';
+const DEFAULT_MODE = 0o644;
+
+export type SettingsScope = 'user' | 'project' | 'local';
+
+export interface ClaudeSettingsFile {
+  id: string;
+  scope: SettingsScope;
+  label: string;
+  path: string;
+  exists: boolean;
+  editable: boolean;
+  text: string;
+  modifiedAt: string | null;
+}
+
+const missing = (id: string, scope: SettingsScope, label: string, path: string): ClaudeSettingsFile => ({
+  id,
+  scope,
+  label,
+  path,
+  exists: false,
+  editable: true,
+  text: '',
+  modifiedAt: null,
+});
+
+function entryOf(id: string, scope: SettingsScope, label: string, path: string): ClaudeSettingsFile {
+  if (!existsSync(path)) return missing(id, scope, label, path);
+  const stat = statSync(path);
+  const editable = stat.size <= SETTINGS_MAX;
+  return {
+    id,
+    scope,
+    label,
+    path,
+    exists: true,
+    editable,
+    text: editable ? readFileSync(path, 'utf8') : '',
+    modifiedAt: stat.mtime.toISOString(),
+  };
+}
+
+const PROJECT_FILES: [string, SettingsScope, string][] = [
+  ['', 'project', 'settings.json'],
+  [LOCAL_SUFFIX, 'local', 'settings.local.json'],
+];
+
+function projectEntries(dir: string): ClaudeSettingsFile[] {
+  const out: ClaudeSettingsFile[] = [];
+  for (const project of listClaudeProjects(dir)) {
+    const cwd = project.cwd;
+    if (cwd === null) continue;
+    for (const [suffix, scope, name] of PROJECT_FILES) {
+      const path = join(cwd, '.claude', name);
+      if (existsSync(path)) out.push(entryOf(`${project.id}${suffix}`, scope, cwd, path));
+    }
+  }
+  return out;
+}
+
+export function listClaudeSettings(dir = claudeDir()): ClaudeSettingsFile[] {
+  return [entryOf(USER_ID, 'user', 'This machine', join(dir, 'settings.json')), ...projectEntries(dir)];
+}
+
+function assertSettingsJson(text: string): void {
+  if (text.length > SETTINGS_MAX) throw new ApiError('that is more text than a settings file may hold', 413);
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    throw new ApiError(`that is not valid JSON: ${errMsg(err)}`, 400);
+  }
+  if (!isRecord(parsed)) throw new ApiError('Claude Code settings must be a JSON object', 400);
+}
+
+function modeOf(path: string): number {
+  try {
+    return statSync(path).mode & 0o777;
+  } catch {
+    return DEFAULT_MODE;
+  }
+}
+
+function writeAtomic(path: string, text: string): void {
+  const mode = existsSync(path) ? modeOf(path) : DEFAULT_MODE;
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.metro-${String(process.pid)}`;
+  writeFileSync(tmp, text, { mode });
+  chmodSync(tmp, mode);
+  renameSync(tmp, path);
+}
+
+export function writeClaudeSettings(
+  id: string,
+  text: string,
+  seenAt: string | null | undefined,
+  dir = claudeDir(),
+): ClaudeSettingsFile {
+  const target = listClaudeSettings(dir).find((file) => file.id === id);
+  if (target === undefined) throw new ApiError('no such settings file', 404);
+  if (!target.editable) throw new ApiError('that settings file is too large to edit here', 409);
+  assertSettingsJson(text);
+  if (seenAt !== undefined && seenAt !== target.modifiedAt)
+    throw new ApiError('that file changed on disk since you opened it; reload it before saving', 409);
+  writeAtomic(target.path, text);
+  return entryOf(target.id, target.scope, target.label, target.path);
+}

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

@@ -1,4 +1,5 @@
 import { handleSessionApis, type SessionApis } from './session-apis.js';
+import { handleGatewayRequest } from '../gateway/gateway.js';
 import { handleRelayRequest } from './relay.js';
 import {
   createServer,
@@ -348,6 +349,13 @@ function handleSignInRoutes(
   return apis.mode !== undefined && handleModeRequest(req, res, apis.mode);
 }
 
+function handleEarlyRoutes(req: IncomingMessage, res: ServerResponse, apis: SessionApis): boolean {
+  if (handleHealth(req, res)) return true;
+  if (apis.gateway !== undefined && handleGatewayRequest(req, res, apis.gateway)) return true;
+  if (handleSignInRoutes(req, res, apis)) return true;
+  return handleSessionApis(req, res, apis);
+}
+
 async function handlePreMcpRoutes(
   req: IncomingMessage,
   res: ServerResponse,
@@ -355,9 +363,7 @@ async function handlePreMcpRoutes(
   apis: SessionApis,
   monitorCall?: MonitorCall,
 ): Promise<boolean> {
-  if (handleHealth(req, res)) return true;
-  if (handleSignInRoutes(req, res, apis)) return true;
-  if (handleSessionApis(req, res, apis)) return true;
+  if (handleEarlyRoutes(req, res, apis)) return true;
   if (handleUploadRequest(req, res)) return true;
   if (handleAttachRequest(req, res)) return true;
   if (apis.relayApi && handleRelayRequest(req, res, apis.relayApi)) return true;

package/runtime/node_modules/@metro-labs/mcp/src/daemon/local-mode.ts

@@ -41,6 +41,7 @@ import {
   readLocalAgentFile,
 } from '../db/file-admin.js';
 import { listAgentFiles, readAgentFile } from '../db/file-source.js';
+import { readModelConfig } from '../gateway/model-config.js';
 import type { StationName } from '../db/stations.js';
 
 export interface LocalModeDeps {
@@ -177,6 +178,8 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     updateApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart },
     controlApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart, stop: deps.stop },
     machineApi: { authorize: (subject) => { assertLocalOwner(subject); } },
+    modelApi: { authorize: (subject) => { assertLocalOwner(subject); } },
+    gateway: { config: readModelConfig },
     terminalApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     identity: { owner: localOwner },
     mode: localModeInfo,