@stage-labs/metro 0.1.0-beta.108 → 0.1.0-beta.109

package/dist/claude.js

@@ -1,6 +1,7 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { markOnboardingDone, seedChannels } from './onboarding.js';
 import { writeMcpConfig } from './mcp-config.js';
+import { currentRoute, routeModelEnv } from './route.js';
 import { settingsConflicts, settingsFiles } from './claude-settings.js';
 import { localAgents, pickLocalAgent } from './local.js';
 import { PROVIDER_FLAGS } from './provider-flags.js';
@@ -135,7 +136,7 @@ function mcpConfigFor(key, port) {
 }
 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, key, port);
+    const routed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
     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");

package/dist/route.js

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentsDir } from './local.js';
+const PROVIDERS = ['bedrock', 'openrouter', 'codex'];
+export function currentRoute(dir = agentsDir()) {
+    const path = join(dir, 'model.json');
+    if (!existsSync(path))
+        return null;
+    try {
+        const cfg = JSON.parse(readFileSync(path, 'utf8'));
+        const provider = PROVIDERS.find((p) => p === cfg.provider);
+        if (provider === undefined)
+            return null;
+        const block = cfg[provider];
+        const model = typeof block === 'object' && block !== null ? block.model : undefined;
+        return typeof model === 'string' && model !== '' ? `${provider}:${model}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function routeModelEnv(env, route) {
+    if (route === null || (env.ANTHROPIC_MODEL ?? '').trim() !== '')
+        return env;
+    return { ...env, ANTHROPIC_MODEL: route };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.108",
+  "version": "0.1.0-beta.109",
   "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.108",
+  "version": "0.1.0-beta.109",
   "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, the standing rules loaded at each session start, and a refresh skill for when the daemon could not keep the server list current. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -7,6 +7,7 @@ import { readJson, writeJson } from '@metro-labs/core/secure-fs';
 import { agentsDir } from '../agents/files.js';
 import { claudeDir } from './files.js';
 import { stagedMarketplaceDir } from './plugin-install.js';
+import { readModelConfig, type ModelConfig } from '../gateway/model-config.js';
 
 export const PRIVACY_ENV: Record<string, string> = {
   DISABLE_TELEMETRY: '1',
@@ -112,8 +113,8 @@ export function applyPrivacy(dir: string, enabled: boolean): SettingsOutcome {
   const current = readSettings(path);
   if (current === null) return 'unreadable';
   const next = withPrivacy(current, enabled);
+  if (existsSync(path) && JSON.stringify(next) === JSON.stringify(current)) return 'unchanged';
   const text = `${JSON.stringify(next, null, 2)}\n`;
-  if (existsSync(path) && readFileSync(path, 'utf8') === text) return 'unchanged';
   mkdirSync(dir, { recursive: true });
   const tmp = `${path}.metro-${String(process.pid)}.tmp`;
   writeFileSync(tmp, text, { mode: 0o644 });
@@ -140,6 +141,7 @@ export function ensureClaudeSetup(deps: SetupDeps = {}): SetupReport {
     skill: placeSkill(dir, deps.guidance ?? guidancePath(deps.env)),
     settings: applyPrivacy(dir, privacy),
   };
+  syncAvailableModelsQuietly({ ...deps, dir, agents });
   if (report.worker === 'written' || report.skill === 'written' || report.settings === 'written')
     log.info(report, 'claude-setup: applied the Claude Code setup for a metro box');
   if (report.settings === 'unreadable') log.warn({ path: join(dir, 'settings.json') }, 'claude-setup: settings.json is not valid JSON, so the privacy settings were not written');
@@ -168,3 +170,47 @@ export function tryClaudeSetup(deps: SetupDeps = {}): void {
     log.warn({ err: errMsg(err) }, 'claude-setup: could not apply the Claude Code setup');
   }
 }
+
+const MODELS_KEY = 'availableModels';
+const ENFORCE_KEY = 'enforceAvailableModels';
+
+export function routeOf(cfg: ModelConfig): string | null {
+  if (cfg.provider === 'anthropic') return null;
+  const model = cfg[cfg.provider].model;
+  return model === '' ? null : `${cfg.provider}:${model}`;
+}
+
+function withAvailableModels(settings: Record<string, unknown>, route: string | null, metroWrote: boolean): Record<string, unknown> {
+  if (route !== null) return { ...settings, [MODELS_KEY]: [route], [ENFORCE_KEY]: true };
+  if (!metroWrote) return settings;
+  return Object.fromEntries(Object.entries(settings).filter(([key]) => key !== MODELS_KEY && key !== ENFORCE_KEY));
+}
+
+export function syncAvailableModels(cfg: ModelConfig, deps: SetupDeps = {}): SettingsOutcome {
+  const dir = deps.dir ?? claudeDir();
+  const agents = deps.agents ?? agentsDir();
+  const route = routeOf(cfg);
+  const state = readJson<unknown>(statePath(agents), null);
+  const metroWrote = isRecord(state) && state.modelsByMetro === true;
+  const path = join(dir, 'settings.json');
+  const current = readSettings(path);
+  if (current === null) return 'unreadable';
+  const next = withAvailableModels(current, route, metroWrote);
+  mkdirSync(agents, { recursive: true });
+  writeJson(statePath(agents), { ...(isRecord(state) ? state : {}), modelsByMetro: route !== null });
+  if (existsSync(path) && JSON.stringify(next) === JSON.stringify(current)) return 'unchanged';
+  const text = `${JSON.stringify(next, null, 2)}\n`;
+  mkdirSync(dir, { recursive: true });
+  const tmp = `${path}.metro-${String(process.pid)}.tmp`;
+  writeFileSync(tmp, text, { mode: 0o644 });
+  renameSync(tmp, path);
+  return 'written';
+}
+
+export function syncAvailableModelsQuietly(deps: SetupDeps = {}, cfg?: ModelConfig): void {
+  try {
+    syncAvailableModels(cfg ?? readModelConfig(deps.agents ?? agentsDir()), deps);
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'claude-setup: could not sync the model allowlist');
+  }
+}

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

@@ -7,6 +7,8 @@ import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from './cod
 import { beginDeviceLogin, pollDeviceLogin } from './codex-device.js';
 import { codexModels, currentTokens, freshCodexState } from './codex.js';
 import { openrouterModels, openrouterZdrModels } from './openrouter.js';
+import { anthropicModels, bedrockModels } from './provider-models.js';
+import { syncAvailableModelsQuietly, type SetupDeps } from '../claude/setup.js';
 import { lastServed } from './served.js';
 import type { CodexTokens } from './codex-auth.js';
 import { GatewayError } from './forward.js';
@@ -23,6 +25,8 @@ import {
 const PATH = '/api/model';
 const CODEX = '/api/model/codex/';
 const OPENROUTER = '/api/model/openrouter/';
+const ANTHROPIC = '/api/model/anthropic/';
+const BEDROCK = '/api/model/bedrock/';
 const BODY_MAX = 16 * 1024;
 const DEVICE_PREFIX = 'device/';
 const DEVICE_ID_RE = /^[A-Za-z0-9_-]{16,64}$/;
@@ -36,6 +40,9 @@ export interface ModelApiDeps {
   codexHome?: string;
   codexBase?: string;
   openrouterBase?: string;
+  anthropicBase?: string;
+  bedrockControlBase?: string;
+  setup?: SetupDeps;
 }
 
 interface Store {
@@ -54,11 +61,11 @@ const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({ ...public
 
 function asApiError(err: unknown): never {
   if (err instanceof ModelConfigError || err instanceof CodexAuthError) throw new ApiError(err.message, 400);
-  if (err instanceof GatewayError) throw new ApiError(err.message, 502);
+  if (err instanceof GatewayError) throw new ApiError(err.message, err.status >= 400 && err.status < 500 ? 400 : 502);
   throw err;
 }
 
-async function update(req: IncomingMessage, store: Store): Promise<unknown> {
+async function update(req: IncomingMessage, store: Store, deps: ModelApiDeps): Promise<unknown> {
   const patch = await readJsonBody(req, BODY_MAX);
   let next: ModelConfig;
   try {
@@ -67,6 +74,7 @@ async function update(req: IncomingMessage, store: Store): Promise<unknown> {
     asApiError(err);
   }
   store.write(next);
+  syncAvailableModelsQuietly(deps.setup ?? {}, next);
   log.info({ provider: next.provider }, 'model-api: route updated');
   return settingsBody(next);
 }
@@ -146,6 +154,20 @@ const OPENROUTER_ROUTES: Record<string, Route> = {
   },
 };
 
+const ANTHROPIC_ROUTES: Record<string, Route> = {
+  models: {
+    method: 'GET',
+    run: async (_req, deps, store) => ({ models: await anthropicModels(store.read().anthropic, deps.anthropicBase, deps.fetchImpl).catch(asApiError) }),
+  },
+};
+
+const BEDROCK_ROUTES: Record<string, Route> = {
+  models: {
+    method: 'GET',
+    run: async (_req, deps, store) => ({ models: await bedrockModels(store.read().bedrock, deps.bedrockControlBase, deps.fetchImpl).catch(asApiError) }),
+  },
+};
+
 const named = (table: Record<string, Route>, name: string, method: string | undefined): Route | number => {
   const route = table[name];
   if (route === undefined) return 404;
@@ -154,7 +176,7 @@ const named = (table: Record<string, Route>, name: string, method: string | unde
 
 function settingsRoute(method: string | undefined): Route | number {
   if (method === 'GET') return { method: 'GET', run: (_req, _deps, store) => Promise.resolve(settingsBody(store.read())) };
-  if (method === 'PUT') return { method: 'POST', run: (req, _deps, store) => update(req, store) };
+  if (method === 'PUT') return { method: 'POST', run: (req, deps, store) => update(req, store, deps) };
   return 405;
 }
 
@@ -165,11 +187,14 @@ function codexRoute(rest: string, method: string | undefined): Route | number {
   return method === 'GET' ? { method: 'GET', run: (_req, deps, store) => pollDevice(id, deps, store) } : 405;
 }
 
-const mine = (path: string): boolean => path === PATH || path.startsWith(CODEX) || path.startsWith(OPENROUTER);
+const mine = (path: string): boolean =>
+  path === PATH || path.startsWith(CODEX) || path.startsWith(OPENROUTER) || path.startsWith(ANTHROPIC) || path.startsWith(BEDROCK);
 
 function routeFor(path: string, method: string | undefined): Route | number {
   if (path === PATH) return settingsRoute(method);
   if (path.startsWith(OPENROUTER)) return named(OPENROUTER_ROUTES, path.slice(OPENROUTER.length), method);
+  if (path.startsWith(ANTHROPIC)) return named(ANTHROPIC_ROUTES, path.slice(ANTHROPIC.length), method);
+  if (path.startsWith(BEDROCK)) return named(BEDROCK_ROUTES, path.slice(BEDROCK.length), method);
   return codexRoute(path.slice(CODEX.length), method);
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/gateway/provider-models.ts

@@ -0,0 +1,65 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { GatewayError } from './forward.js';
+import type { AnthropicSettings, BedrockSettings } from './model-config.js';
+
+export const ANTHROPIC_API = 'https://api.anthropic.com';
+const ANTHROPIC_VERSION = '2023-06-01';
+const LIST_MAX = 1000;
+
+export interface ProviderModel {
+  id: string;
+  name: string;
+}
+
+export const KNOWN_CLAUDE: ProviderModel[] = [
+  { id: 'claude-fable-5-1', name: 'Claude Fable 5.1' },
+  { id: 'claude-opus-5', name: 'Claude Opus 5' },
+  { id: 'claude-sonnet-5', name: 'Claude Sonnet 5' },
+  { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5' },
+];
+
+const str = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+export async function anthropicModels(settings: AnthropicSettings, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
+  if (settings.apiKey === '') return KNOWN_CLAUDE;
+  const res = await fetchImpl(`${base}/v1/models?limit=${String(LIST_MAX)}`, {
+    headers: { 'x-api-key': settings.apiKey, 'anthropic-version': ANTHROPIC_VERSION, accept: 'application/json' },
+    redirect: 'manual',
+  });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `Anthropic would not list its models with the stored key (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = isRecord(body) && Array.isArray(body.data) ? body.data : null;
+  if (data === null) throw new GatewayError(502, 'api_error', 'Anthropic answered with no model list');
+  return data
+    .flatMap((entry) => (isRecord(entry) && str(entry.id) !== '' ? [{ id: str(entry.id), name: str(entry.display_name) || str(entry.id) }] : []))
+    .sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export const bedrockControlBase = (region: string): string => `https://bedrock.${region}.amazonaws.com`;
+
+export async function bedrockModels(settings: BedrockSettings, base?: string, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
+  if (settings.region === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs a region before its models can be listed');
+  if (settings.apiKey === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key before its models can be listed');
+  const res = await fetchImpl(`${base ?? bedrockControlBase(settings.region)}/inference-profiles?maxResults=${String(LIST_MAX)}`, {
+    headers: { authorization: `Bearer ${settings.apiKey}`, accept: 'application/json' },
+    redirect: 'manual',
+  });
+  if (!res.ok)
+    throw new GatewayError(
+      res.status,
+      'api_error',
+      `Bedrock would not list its inference profiles (${String(res.status)}); the stored key may cover the runtime only, so type the model id instead`,
+    );
+  const body: unknown = await res.json();
+  const list = isRecord(body) && Array.isArray(body.inferenceProfileSummaries) ? body.inferenceProfileSummaries : null;
+  if (list === null) throw new GatewayError(502, 'api_error', 'Bedrock answered with no inference profile list');
+  return list
+    .flatMap((entry) => {
+      if (!isRecord(entry)) return [];
+      const id = str(entry.inferenceProfileId);
+      const status = str(entry.status);
+      if (id === '' || !id.includes('anthropic') || (status !== '' && status !== 'ACTIVE')) return [];
+      return [{ id, name: str(entry.inferenceProfileName) || id }];
+    })
+    .sort((a, b) => a.id.localeCompare(b.id));
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.108"
+  "version": "0.1.0-beta.109"
 }