@stage-labs/metro 0.1.0-beta.105 → 0.1.0-beta.107

package/dist/claude.js

@@ -6,10 +6,12 @@ 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 PERMISSION_FLAGS = ['--permission-mode', 'auto'];
 const KEY_HEADER = 'x-metro-key';
 const PROBE_MS = 3_000;
 export const claudeArgs = (extra, mcpConfig) => [
     ...CHANNEL_FLAGS,
+    ...PERMISSION_FLAGS,
     ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
     ...extra,
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.105",
+  "version": "0.1.0-beta.107",
   "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.105",
+  "version": "0.1.0-beta.107",
   "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/session.ts

@@ -4,6 +4,7 @@ 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 { METRO_VERSION } from '@metro-labs/core/version';
 import { agentsDir, listAgentFiles } from '../agents/files.js';
 import { notReady, readModelConfig } from '../gateway/model-config.js';
 import { claudeAccount, claudeInstalled } from './login.js';
@@ -26,6 +27,7 @@ export interface SessionDeps {
   agents?: string;
   signedIn?: () => boolean;
   now?: () => number;
+  version?: string;
 }
 
 export interface SessionStatus {
@@ -48,13 +50,24 @@ const memory: Memory = { lastStartedAt: null, lastError: null, strikes: 0, pause
 
 const statePath = (agents: string): string => join(agents, STATE_FILE);
 
-export function autostartEnabled(agents = agentsDir()): boolean {
+function readState(agents: string): Record<string, unknown> {
   const raw = readJson<unknown>(statePath(agents), null);
-  return !isRecord(raw) || raw.autostart !== false;
+  return isRecord(raw) ? raw : {};
 }
 
+const writeState = (agents: string, patch: Record<string, unknown>): void => {
+  writeJson(statePath(agents), { ...readState(agents), ...patch });
+};
+
+export const autostartEnabled = (agents = agentsDir()): boolean => readState(agents).autostart !== false;
+
 export function setAutostart(enabled: boolean, agents = agentsDir()): void {
-  writeJson(statePath(agents), { autostart: enabled });
+  writeState(agents, { autostart: enabled });
+}
+
+export function startedVersion(agents = agentsDir()): string | null {
+  const version = readState(agents).version;
+  return typeof version === 'string' ? version : null;
 }
 
 function tmuxOk(tmux: string, args: string[]): boolean {
@@ -108,6 +121,18 @@ function confirmChannels(tmux: string, until: number): void {
   setTimeout(tick, CONFIRM_POLL_MS).unref();
 }
 
+function recordStart(deps: SessionDeps, tmux: string, now: number, run: { error?: Error; status: number | null; stderr: string }): void {
+  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');
+    return;
+  }
+  memory.lastError = null;
+  writeState(deps.agents ?? agentsDir(), { version: deps.version ?? METRO_VERSION });
+  confirmChannels(tmux, now + CONFIRM_WAIT_MS);
+}
+
 export function startSession(deps: SessionDeps = {}): SessionStatus {
   const tmux = deps.tmux ?? 'tmux';
   const home = deps.home ?? homedir();
@@ -115,15 +140,8 @@ export function startSession(deps: SessionDeps = {}): SessionStatus {
   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);
-  }
+  recordStart(deps, tmux, now, run);
+  if (memory.lastError === null) log.info({ home, trusted, command: [command, ...args].join(' ') }, 'claude-session: started Claude Code in tmux');
   return sessionStatus(deps);
 }
 
@@ -153,15 +171,46 @@ function strike(now: number): boolean {
   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';
+export type Ensured = 'started' | 'restarted' | 'running' | 'blocked' | 'off' | 'paused';
+
+function holdsBack(deps: SessionDeps, now: number): Ensured | null {
   if (now < memory.pausedUntil) return 'paused';
   if (sessionBlocked(deps) !== null) return 'blocked';
-  if (strike(now)) return 'paused';
+  return strike(now) ? 'paused' : null;
+}
+
+interface Resolved {
+  now: number;
+  agents: string;
+  version: string;
+  tmux: string;
+}
+
+const resolved = (deps: SessionDeps): Resolved => ({
+  now: (deps.now ?? Date.now)(),
+  agents: deps.agents ?? agentsDir(),
+  version: deps.version ?? METRO_VERSION,
+  tmux: deps.tmux ?? 'tmux',
+});
+
+function situation(r: Resolved): 'running' | 'stale' | 'absent' {
+  if (!sessionRunning(r.tmux)) return 'absent';
+  return startedVersion(r.agents) === r.version ? 'running' : 'stale';
+}
+
+export function ensureSession(deps: SessionDeps = {}): Ensured {
+  const r = resolved(deps);
+  if (!autostartEnabled(r.agents)) return 'off';
+  const found = situation(r);
+  if (found === 'running') return 'running';
+  const held = holdsBack(deps, r.now);
+  if (held !== null) return held;
+  if (found === 'stale') {
+    log.info({ was: startedVersion(r.agents), now: r.version }, 'claude-session: restarting the session an older metro started, so the new plugin and flags load');
+    stopSession(deps);
+  }
   startSession(deps);
-  return 'started';
+  return found === 'stale' ? 'restarted' : 'started';
 }
 
 let watcher: ReturnType<typeof setInterval> | null = null;
@@ -171,7 +220,7 @@ export function watchSession(deps: SessionDeps = {}, everyMs = WATCH_MS): void {
   const tick = (): void => {
     try {
       const outcome = ensureSession(deps);
-      if (outcome === 'started') log.info('claude-session: started');
+      if (outcome === 'started' || outcome === 'restarted') log.info({ outcome }, 'claude-session: Claude Code is up');
     } catch (err) {
       log.warn({ err: errMsg(err) }, 'claude-session: check failed');
     }

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

@@ -13,6 +13,7 @@ import { anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeRespon
 import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, writeModelConfig, type ModelConfig, type Route } from './model-config.js';
 import { codexCount, codexMessages, freshCodexState, type CodexDeps } from './codex.js';
 import { OPENROUTER_BASE } from './openrouter.js';
+import { isRecord } from '@metro-labs/core/is-record';
 import { forgetServed, noteServed } from './served.js';
 import type { CodexTokens } from './codex-auth.js';
 
@@ -128,13 +129,19 @@ async function toOpenRouter(
   const upstream = await fetch(`${deps.openrouterBase ?? OPENROUTER_BASE}${MESSAGES}`, {
     method: 'POST',
     headers,
-    body: JSON.stringify({ ...body, model: route.model }),
+    body: JSON.stringify(openrouterBody(body, route.model, cfg.openrouter.zdr)),
     signal: watch.signal,
     redirect: 'manual',
   });
   await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true });
 }
 
+export function openrouterBody(body: Record<string, unknown>, model: string, zdr: boolean): Record<string, unknown> {
+  if (!zdr) return { ...body, model };
+  const provider = isRecord(body.provider) ? body.provider : {};
+  return { ...body, model, provider: { ...provider, zdr: true } };
+}
+
 async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
   const cfg = deps.config();
   const raw = await readBody(req);

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

@@ -6,7 +6,7 @@ import { log } from '@metro-labs/core/log';
 import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from './codex-auth.js';
 import { beginDeviceLogin, pollDeviceLogin } from './codex-device.js';
 import { codexModels, currentTokens, freshCodexState } from './codex.js';
-import { openrouterModels } from './openrouter.js';
+import { openrouterModels, openrouterZdrModels } from './openrouter.js';
 import { lastServed } from './served.js';
 import type { CodexTokens } from './codex-auth.js';
 import { GatewayError } from './forward.js';
@@ -140,6 +140,10 @@ const OPENROUTER_ROUTES: Record<string, Route> = {
     method: 'GET',
     run: async (_req, deps) => ({ models: await openrouterModels(deps.openrouterBase, deps.fetchImpl).catch(asApiError) }),
   },
+  zdr: {
+    method: 'GET',
+    run: async (_req, deps) => ({ models: await openrouterZdrModels(deps.openrouterBase, deps.fetchImpl).catch(asApiError) }),
+  },
 };
 
 const named = (table: Record<string, Route>, name: string, method: string | undefined): Route | number => {

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

@@ -21,6 +21,7 @@ export interface BedrockSettings {
 export interface OpenRouterSettings {
   apiKey: string;
   model: string;
+  zdr: boolean;
 }
 
 export interface CodexSettings {
@@ -54,7 +55,7 @@ const empty = (): ModelConfig => ({
   provider: 'anthropic',
   anthropic: { apiKey: '', model: '' },
   bedrock: { region: '', apiKey: '', model: '' },
-  openrouter: { apiKey: '', model: '' },
+  openrouter: { apiKey: '', model: '', zdr: false },
   codex: { model: '', auth: null },
 });
 
@@ -93,7 +94,7 @@ function fromDisk(raw: unknown): ModelConfig {
     provider: isProvider(raw.provider) ? raw.provider : 'anthropic',
     anthropic: { apiKey: text(anthropic.apiKey), model: text(anthropic.model) },
     bedrock: { region: text(bedrock.region), apiKey: text(bedrock.apiKey), model: text(bedrock.model) },
-    openrouter: { apiKey: text(openrouter.apiKey), model: text(openrouter.model) },
+    openrouter: { apiKey: text(openrouter.apiKey), model: text(openrouter.model), zdr: openrouter.zdr === true },
     codex: { model: text(codex.model), auth: tokensFromDisk(codex.auth) },
   };
 }
@@ -106,6 +107,13 @@ export function writeModelConfig(cfg: ModelConfig, dir = agentsDir()): void {
   writeSecure(join(dir, MODEL_FILE), JSON.stringify(cfg, null, 2));
 }
 
+function flag(patch: Record<string, unknown>, key: string, current: boolean, what: string): boolean {
+  if (!(key in patch)) return current;
+  const value = patch[key];
+  if (typeof value !== 'boolean') throw new ModelConfigError(`${what} must be true or false`);
+  return value;
+}
+
 function field(patch: Record<string, unknown>, key: string, current: string, what: string): string {
   if (!(key in patch)) return current;
   const value = patch[key];
@@ -137,6 +145,7 @@ export function applyModelUpdate(cfg: ModelConfig, patch: unknown): ModelConfig
     openrouter: {
       apiKey: field(openrouter, 'apiKey', cfg.openrouter.apiKey, 'OpenRouter API key'),
       model: field(openrouter, 'model', cfg.openrouter.model, 'OpenRouter model'),
+      zdr: flag(openrouter, 'zdr', cfg.openrouter.zdr, 'OpenRouter zero data retention'),
     },
     codex: { model: field(codex, 'model', cfg.codex.model, 'Codex model'), auth: cfg.codex.auth },
   };
@@ -172,7 +181,7 @@ export function publicModelConfig(cfg: ModelConfig): Record<string, unknown> {
     reason: notReady(cfg),
     anthropic: { model: cfg.anthropic.model, hasKey: cfg.anthropic.apiKey !== '' },
     bedrock: { region: cfg.bedrock.region, model: cfg.bedrock.model, hasKey: cfg.bedrock.apiKey !== '' },
-    openrouter: { model: cfg.openrouter.model, hasKey: cfg.openrouter.apiKey !== '' },
+    openrouter: { model: cfg.openrouter.model, hasKey: cfg.openrouter.apiKey !== '', zdr: cfg.openrouter.zdr },
     codex: { model: cfg.codex.model, signedIn: auth !== null, account: auth?.email ?? null, plan: auth?.plan ?? null },
   };
 }

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

@@ -38,3 +38,14 @@ export async function openrouterModels(base = OPENROUTER_BASE, fetchImpl: typeof
     .slice(0, MODELS_MAX)
     .sort((a, b) => a.id.localeCompare(b.id));
 }
+
+export async function openrouterZdrModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<string[]> {
+  const res = await fetchImpl(`${base}/v1/endpoints/zdr`, { headers: { accept: 'application/json' }, redirect: 'manual' });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its zero data retention endpoints (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = typeof body === 'object' && body !== null ? (body as { data?: unknown }).data : undefined;
+  if (!Array.isArray(data)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no endpoint list');
+  const ids = new Set<string>();
+  for (const entry of data) if (isRecord(entry) && str(entry.model_id) !== '') ids.add(str(entry.model_id));
+  return [...ids].sort();
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.105"
+  "version": "0.1.0-beta.107"
 }