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

package/dist/api.js

@@ -0,0 +1,11 @@
+import { localAgent, localDaemonUp } from './local.js';
+import { localUrl } from './runtime.js';
+const NO_DAEMON = `no metro daemon on ${localUrl()} — start one with: metro serve`;
+export async function whoisAuthorized() {
+    if (!(await localDaemonUp()))
+        throw new Error(NO_DAEMON);
+    const agent = localAgent();
+    if (agent === null)
+        throw new Error('no agent on this machine yet');
+    return { agent: agent.id, where: localUrl() };
+}

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

@@ -0,0 +1,163 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { markOnboardingDone, seedChannels } from './onboarding.js';
+import { writeMcpConfig } from './mcp-config.js';
+import { currentRoute, permissionMode, routeModelEnv, systemPrompt } from './route.js';
+import { settingsConflicts, settingsFiles } from './claude-settings.js';
+import { localAgent } 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 FRESH_PROMPT_FLAGS = ['--system-prompt-snapshot', 'off'];
+const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
+const KEY_HEADER = 'x-metro-key';
+const PROBE_MS = 3_000;
+export const claudeArgs = (extra, mcpConfig, mode = 'auto', prompt = null) => [
+    ...CHANNEL_FLAGS,
+    '--permission-mode',
+    PERMISSION_MODE_FLAG[mode],
+    ...FRESH_PROMPT_FLAGS,
+    ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
+    ...(prompt === null ? [] : ['--append-system-prompt', prompt]),
+    ...extra,
+];
+const set = (env, name) => (env[name] ?? '').trim() !== '';
+export function bypassSandboxEnv(env, mode, uid) {
+    if (mode !== 'bypass' || uid !== 0 || env.IS_SANDBOX !== undefined)
+        return env;
+    return { ...env, IS_SANDBOX: '1' };
+}
+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',
+    };
+}
+const OWN_CREDENTIALS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
+export function credentialEnv(env, agentKey, signedIn) {
+    if (signedIn || OWN_CREDENTIALS.some((name) => set(env, name)))
+        return env;
+    return { ...env, ANTHROPIC_AUTH_TOKEN: agentKey };
+}
+export function claudeSignedIn() {
+    const run = spawnSync('claude', ['auth', 'status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (run.error !== undefined || typeof run.stdout !== 'string')
+        return false;
+    try {
+        const parsed = JSON.parse(run.stdout);
+        return parsed.authenticated === true || parsed.loggedIn === true || typeof parsed.email === 'string' || typeof parsed.organization === 'string';
+    }
+    catch {
+        return false;
+    }
+}
+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(agent) {
+    return agent === null ? { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' } : { key: agent.key };
+}
+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(localAgent());
+    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);
+        });
+    });
+}
+async function servedKey(decision) {
+    if ('key' in decision)
+        return decision.key;
+    const picked = agentKey(localAgent());
+    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 = 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");
+    if (seedChannels() === 'marked')
+        process.stderr.write('metro claude: marked Channels as available in Claude Code cached flags, since a box that sends no telemetry never fetches them\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 env;
+}
+export async function launchClaude(extra) {
+    const decision = await verdict();
+    const port = localPort();
+    const mcp = mcpConfigFor(await servedKey(decision), port);
+    const mode = permissionMode();
+    const prompt = systemPrompt();
+    if (prompt !== null)
+        process.stderr.write('metro claude: the system prompt from the Harness page is appended to this session\n');
+    const sandbox = (env) => {
+        const out = bypassSandboxEnv(env, mode, process.getuid?.());
+        if (out !== env)
+            process.stderr.write('metro claude: bypass permission mode under root, so IS_SANDBOX=1 is set for Claude Code (it refuses to skip permissions as root otherwise); this box is a dedicated single-tenant machine\n');
+        return out;
+    };
+    try {
+        if ('skip' in decision) {
+            process.stderr.write(`metro claude: ${decision.skip}\n`);
+            return await runClaude(claudeArgs(extra, mcp?.path, mode, prompt), sandbox(process.env));
+        }
+        return await runClaude(claudeArgs(extra, mcp?.path, mode, prompt), sandbox(gatewayLaunchEnv(decision.key, port)));
+    }
+    finally {
+        mcp?.cleanup();
+    }
+}