@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

package/dist/agent.js

@@ -0,0 +1,123 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { runChild } from './child.js';
+import { headlessEnv, NO_UPDATES } from './claude-env.js';
+import { localAgent } from './local.js';
+import { withLock } from './lock.js';
+import { currentModel, permissionMode, systemPrompt } from './route.js';
+import { installDependencies, ranges, readOrNull } from './runtime-install.js';
+import { findBun, localPort, runtimeDir } from './runtime.js';
+export const RUNNER_SOURCES = 'sdk-runner';
+const STAMP = 'runner.json';
+const ENTRY = join('src', 'main.ts');
+const METRO_MODULES = join('node_modules', '@metro-labs');
+const BUNFIG = '[install]\noptional = false\npeer = false\n';
+const SDK = '@anthropic-ai/claude-agent-sdk';
+const PREPARE_LOCK = '.prepare.lock';
+const PREPARE_WAIT = { staleMs: 20 * 60_000, waitMs: 20 * 60_000, pollMs: 250 };
+export function runnerStore(env = process.env) {
+    const explicit = env.METRO_RUNNER_STORE?.trim() ?? '';
+    return explicit === '' ? join(homedir(), '.metro', 'sdk-runner') : explicit;
+}
+export function readRunnerManifest(text) {
+    const raw = JSON.parse(text);
+    return {
+        version: typeof raw.version === 'string' ? raw.version : '',
+        dependencies: ranges(raw.dependencies),
+    };
+}
+function glibcMissing() {
+    const report = process.report.getReport();
+    return report.header?.glibcVersionRuntime === undefined;
+}
+export function claudePackage(platform = process.platform, arch = process.arch, musl = platform === 'linux' && glibcMissing()) {
+    return { name: `${SDK}-${platform}-${arch}${musl ? '-musl' : ''}`, binary: platform === 'win32' ? 'claude.exe' : 'claude' };
+}
+export function runnerDependencies(manifest, pkg) {
+    const sdk = manifest.dependencies[SDK];
+    return sdk === undefined ? manifest.dependencies : { ...manifest.dependencies, [pkg.name]: sdk };
+}
+function stageSources(sources, store, stamp) {
+    mkdirSync(store, { recursive: true });
+    if (readOrNull(join(store, STAMP)) !== stamp || !existsSync(join(store, ENTRY))) {
+        rmSync(join(store, 'src'), { recursive: true, force: true });
+        rmSync(join(store, METRO_MODULES), { recursive: true, force: true });
+        cpSync(join(sources, 'src'), join(store, 'src'), { recursive: true });
+        cpSync(join(sources, METRO_MODULES), join(store, METRO_MODULES), { recursive: true });
+        writeFileSync(join(store, STAMP), stamp);
+    }
+    if (readOrNull(join(store, 'bunfig.toml')) !== BUNFIG)
+        writeFileSync(join(store, 'bunfig.toml'), BUNFIG);
+}
+export function prepareRunner(opts = {}) {
+    const store = opts.store ?? runnerStore();
+    const log = opts.log ??
+        ((line) => {
+            process.stderr.write(`metro agent: ${line}\n`);
+        });
+    const waiting = () => {
+        log(`waiting for another preparation of ${store} to finish`);
+    };
+    return withLock(join(store, PREPARE_LOCK), { ...PREPARE_WAIT, waiting }, () => prepareIn(store, opts, log));
+}
+function prepareIn(store, opts, log) {
+    const sources = opts.sources ?? join(runtimeDir(), RUNNER_SOURCES);
+    const stamp = readFileSync(join(sources, STAMP), 'utf8');
+    stageSources(sources, store, stamp);
+    const pkg = opts.claude ?? claudePackage();
+    const claude = join(store, 'node_modules', ...pkg.name.split('/'), pkg.binary);
+    const marker = join(store, 'node_modules', '.metro-installed');
+    if (!existsSync(claude))
+        rmSync(marker, { force: true });
+    installDependencies(store, runnerDependencies(readRunnerManifest(stamp), pkg), opts.bun ?? findBun(), log);
+    if (!existsSync(claude)) {
+        rmSync(marker, { force: true });
+        throw new Error(`The Claude Code binary bundled with the Agent SDK is missing at ${claude}. Try preparing the runner again.`);
+    }
+    return { entry: join(store, ENTRY), claude };
+}
+export function runnerEnv(key, port, model, mode, prompt, claude) {
+    return {
+        METRO_RUNNER_MCP_URL: `http://127.0.0.1:${String(port)}/mcp`,
+        METRO_RUNNER_CLAUDE: claude,
+        METRO_AGENT_KEY: key,
+        METRO_RUNNER_PERMISSION_MODE: mode,
+        ...(model === null ? {} : { METRO_RUNNER_MODEL: model }),
+        ...(prompt === null ? {} : { METRO_RUNNER_PROMPT: prompt }),
+    };
+}
+function checkBinary(bin) {
+    const run = spawnSync(bin, ['--version'], { env: { ...process.env, ...NO_UPDATES }, stdio: 'ignore', timeout: 30_000 });
+    if (run.error !== undefined || run.status !== 0)
+        throw new Error(`Runner preflight failed: ${bin} cannot run (${run.error?.message ?? `exit ${String(run.status)}`}).`);
+}
+export function prepareAgentRunner(opts = {}) {
+    const prepared = prepareRunner(opts);
+    try {
+        checkBinary(prepared.claude);
+    }
+    catch (err) {
+        rmSync(join(opts.store ?? runnerStore(), 'node_modules', '.metro-installed'), { force: true });
+        throw err;
+    }
+}
+const prepareOnly = (args) => args[0] === '--prepare' && (args.length === 1 || (args.length === 2 && args[1] === 'sdk'));
+export async function agentSession(args = []) {
+    if (prepareOnly(args)) {
+        prepareAgentRunner();
+        return 0;
+    }
+    if (args.length > 0)
+        throw new Error('metro agent accepts only --prepare');
+    process.chdir(homedir());
+    const agent = localAgent();
+    if (agent === null)
+        throw new Error('metro agent needs the agent of this machine, and there is none yet');
+    const bun = findBun();
+    const runner = prepareRunner({ bun });
+    process.stderr.write('metro agent: this agent runs as one Agent SDK session: a light front talks, background workers do the work\n');
+    const env = { ...(await headlessEnv(runner.claude, 'metro agent')), ...runnerEnv(agent.key, localPort(), currentModel(), permissionMode(), systemPrompt(), runner.claude) };
+    return runChild(bun, [runner.entry], env);
+}

package/dist/api.js

@@ -1,131 +1,11 @@
-import { metroUrl, readRunTokens, readToken } from './store.js';
-export class NotSignedIn extends Error {
-}
-const TIMEOUT_MS = 20_000;
-const LOOPBACK = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
-export function carriesSecretsSafely(base) {
-    let url;
-    try {
-        url = new URL(base);
-    }
-    catch {
-        return false;
-    }
-    if (url.protocol === 'https:')
-        return true;
-    return url.protocol === 'http:' && LOOPBACK.has(url.hostname);
-}
-function tokenOrThrow() {
-    if (!carriesSecretsSafely(metroUrl()))
-        throw new Error(`refusing to send your session to ${metroUrl()} in the clear — use https, or a loopback address`);
-    const token = readToken() ?? soleRunToken();
-    if (token === null)
-        throw new NotSignedIn('not signed in — run `metro login`, or `metro start <agent-id>` on this machine');
-    return token;
-}
-function soleRunToken() {
-    const tokens = readRunTokens();
-    return tokens.length === 1 ? (tokens[0] ?? null) : null;
-}
-async function get(path) {
-    const auth = tokenOrThrow();
-    let res;
-    try {
-        res = await fetch(`${metroUrl()}${path}`, {
-            headers: { authorization: `Bearer ${auth}` },
-            signal: AbortSignal.timeout(TIMEOUT_MS),
-        });
-    }
-    catch {
-        throw new Error(`could not reach ${metroUrl()}`);
-    }
-    if (res.status === 401)
-        throw new NotSignedIn("metro refused this machine's sign-in — run `metro login` again");
-    if (!res.ok)
-        throw new Error(`metro answered ${String(res.status)}`);
-    return res.json();
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-async function post(path, body) {
-    if (!carriesSecretsSafely(metroUrl()))
-        throw new Error(`refusing to send your code to ${metroUrl()} in the clear — use https, or a loopback address`);
-    let res;
-    try {
-        res = await fetch(`${metroUrl()}${path}`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(TIMEOUT_MS),
-        });
-    }
-    catch {
-        throw new Error(`could not reach ${metroUrl()}`);
-    }
-    const parsed = await res.json().catch(() => null);
-    if (res.ok)
-        return parsed;
-    const detail = isRecord(parsed) ? parsed.error : undefined;
-    throw new Error(typeof detail === 'string' ? detail : `metro answered ${String(res.status)}`);
-}
-export class RuntimeRevoked extends Error {
-}
-export function keyOfRunConfig(body) {
-    const agent = isRecord(body) ? body.agent : undefined;
-    const key = isRecord(agent) ? agent.key : undefined;
-    if (typeof key !== 'string' || key === '')
-        throw new Error('this agent has no key — reset it on its page in the web UI');
-    return key;
-}
-export async function runConfigKey(token) {
-    if (!carriesSecretsSafely(metroUrl()))
-        throw new Error(`refusing to send this machine's authorization to ${metroUrl()} in the clear — use https, or a loopback address`);
-    let res;
-    try {
-        res = await fetch(`${metroUrl()}/api/run/config`, {
-            headers: { authorization: `Bearer ${token}` },
-            signal: AbortSignal.timeout(TIMEOUT_MS),
-        });
-    }
-    catch {
-        throw new Error(`could not reach ${metroUrl()}`);
-    }
-    if (res.status === 401 || res.status === 403 || res.status === 409)
-        throw new RuntimeRevoked('this machine no longer holds the agent — authorize it again from the agent page');
-    if (!res.ok)
-        throw new Error(`metro answered ${String(res.status)}`);
-    return keyOfRunConfig(await res.json());
-}
-export async function claimCode(code) {
-    const body = await post('/api/cli/claim', { code });
-    if (!isRecord(body) ||
-        typeof body.token !== 'string' ||
-        typeof body.email !== 'string' ||
-        typeof body.agent !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return { token: body.token, email: body.email, agent: body.agent };
-}
-export async function claimRuntime(code, label) {
-    const body = await post('/api/run/claim', { code, label });
-    if (!isRecord(body) ||
-        typeof body.token !== 'string' ||
-        typeof body.agent !== 'string' ||
-        typeof body.label !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return { token: body.token, agent: body.agent, label: body.label };
-}
-export async function mcpServers() {
-    const body = await get('/api/cli/mcp');
-    if (!isRecord(body) || typeof body.json !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return body.json;
-}
+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() {
-    const body = await get('/api/cli/session');
-    if (!isRecord(body) ||
-        typeof body.email !== 'string' ||
-        typeof body.agent !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return { email: body.email, agent: body.agent };
+    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/automation.js

@@ -0,0 +1,56 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { findBun, runtimeDir } from './runtime.js';
+const TASK_HELP = `metro task: queue work for the existing Agent SDK conversation
+
+  metro task submit <routine> <prompt-file> [--slot <UTC ISO timestamp>] [--dry-run]
+                  queue a local prompt file (regular UTF-8 file, at most 64 KiB);
+                  default slot is the current UTC hour; use --slot for other cadences;
+                  accepted means saved, not executed; duplicates show their current state;
+                  --dry-run writes nothing
+  metro task status [routine]
+                  read safe local metadata, including the token needed to finish;
+                  never print prompts
+  metro task finish <uuid> <token> completed|blocked
+                  save a receipt pending runner verification, not mark work complete
+
+  These commands never start a session, install a runtime or connect to the daemon.
+  Local task authorization is not fresh owner approval for external actions.
+`;
+function taskRuntime() {
+    let dir;
+    try {
+        dir = runtimeDir();
+    }
+    catch {
+        throw new Error('metro task needs the shipped runtime; reinstall @stage-labs/metro@beta');
+    }
+    const entry = join(dir, 'sdk-runner', 'src', 'automation-cli.ts');
+    if (!existsSync(entry))
+        throw new Error('metro task is missing its shipped entry; reinstall @stage-labs/metro@beta');
+    try {
+        return { bun: findBun(), entry };
+    }
+    catch {
+        throw new Error('metro task needs Bun on PATH; it never installs Bun or the runner');
+    }
+}
+export async function automationCommand(args) {
+    if (args.length === 0 || (args.length === 1 && ['help', '--help', '-h'].includes(args[0] ?? ''))) {
+        process.stderr.write(TASK_HELP);
+        return args.length === 0 ? 1 : 0;
+    }
+    const { bun, entry } = taskRuntime();
+    return new Promise((resolve) => {
+        const child = spawn(bun, ['--no-install', entry, ...args], {
+            stdio: ['ignore', 'inherit', 'inherit'],
+            env: { ...process.env, BUN_RUNTIME_TRANSPILER_CACHE_PATH: '0' },
+        });
+        child.once('error', () => {
+            process.stderr.write('metro task: unable to run the shipped task command\n');
+            resolve(1);
+        });
+        child.once('exit', (code) => { resolve(code ?? 1); });
+    });
+}

package/dist/child.js

@@ -0,0 +1,33 @@
+import { spawn } from 'node:child_process';
+const KILL_GRACE_MS = 30_000;
+function deadline(child, timeoutMs) {
+    if (timeoutMs === undefined)
+        return () => undefined;
+    let kill;
+    const term = setTimeout(() => {
+        child.kill('SIGTERM');
+        kill = setTimeout(() => {
+            child.kill('SIGKILL');
+        }, KILL_GRACE_MS);
+    }, timeoutMs);
+    return () => {
+        clearTimeout(term);
+        clearTimeout(kill);
+    };
+}
+export function runChild(command, args, env, headless) {
+    return new Promise((resolve, reject) => {
+        const leaveToChild = () => undefined;
+        process.on('SIGINT', leaveToChild);
+        process.on('SIGTERM', leaveToChild);
+        const child = spawn(command, args, { stdio: [headless === undefined ? 'inherit' : 'ignore', 'inherit', 'inherit'], env });
+        const stop = deadline(child, headless?.timeoutMs);
+        child.on('error', (err) => {
+            reject(new Error(err.code === 'ENOENT' ? `${command} was not found` : err.message));
+        });
+        child.on('exit', (code) => {
+            stop();
+            resolve(code ?? 1);
+        });
+    });
+}

package/dist/claude-env.js

@@ -0,0 +1,104 @@
+import { spawnSync } from 'node:child_process';
+import { currentRoute, routeModelEnv } 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 KEY_HEADER = 'x-metro-key';
+const PROBE_MS = 3_000;
+const AUTH_STATUS_MS = 20_000;
+const RM_PROMPT_OFF = 'CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT';
+const OWN_CREDENTIALS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
+export const AGENT_VIEW_OFF = 'CLAUDE_CODE_DISABLE_AGENT_VIEW';
+export const NO_UPDATES = { DISABLE_AUTOUPDATER: '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 const toolSearchEnv = (env) => set(env, 'ENABLE_TOOL_SEARCH') ? env : { ...env, ENABLE_TOOL_SEARCH: 'true' };
+export const rmPromptEnv = (env) => set(env, RM_PROMPT_OFF) ? env : { ...env, [RM_PROMPT_OFF]: '1' };
+export const keepInSession = (env) => set(env, AGENT_VIEW_OFF) ? env : { ...env, [AGENT_VIEW_OFF]: '1' };
+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(claude, env = process.env) {
+    const run = spawnSync(claude, ['auth', 'status', '--json'], { encoding: 'utf8', env: { ...env, ...NO_UPDATES }, stdio: ['ignore', 'pipe', 'ignore'], timeout: AUTH_STATUS_MS });
+    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' };
+}
+function gatewayLaunchEnv(key, port, claude, say) {
+    say(`inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)`);
+    const pointed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
+    const routed = toolSearchEnv(pointed);
+    if (routed !== pointed)
+        say('MCP tool search is on, so connector tools load when Claude needs them instead of all at start');
+    const env = credentialEnv(routed, key, claudeSignedIn(claude));
+    if (env !== routed)
+        say("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");
+    return env;
+}
+export async function headlessEnv(claude, command) {
+    const say = (line) => {
+        process.stderr.write(`${command}: ${line}\n`);
+    };
+    const decision = await verdict();
+    if ('skip' in decision)
+        say(decision.skip);
+    const env = 'key' in decision ? gatewayLaunchEnv(decision.key, localPort(), claude, say) : process.env;
+    return { ...keepInSession(rmPromptEnv(env)), ...NO_UPDATES };
+}

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;
+}