@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.300

package/dist/service.js

@@ -0,0 +1,328 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, platform, userInfo } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { serveLockedBy } from './control.js';
+import { installRelease } from './root-release.js';
+import { realReleaseDeps } from './root-release-io.js';
+import { findBun } from './runtime.js';
+import { findTailscale, parseServeArgs, requireOwner } from './serve.js';
+import { currentVersion } from './version.js';
+const USAGE = 'usage: metro service install [--port <n>] [--owner <organization id>] [--user metro] | uninstall | status | root-upgrade <version> (root only)';
+const SERVICE = 'metro';
+const LABEL = 'box.metro.serve';
+const CARRIED = /^(METRO_.*|XDG_CACHE_HOME|PATH|HOME)$/;
+const OWN_PATHS = new Set(['METRO_AGENTS_DIR', 'METRO_RUNTIME_STORE']);
+const METRO_USER = 'metro';
+const USER_FLAG = /^--user=(.*)$/;
+const PLAIN_WORD = /^[A-Za-z0-9_/.:=+@,-]+$/;
+const carriedEnv = (env) => Object.entries(env)
+    .filter((entry) => CARRIED.test(entry[0]) && typeof entry[1] === 'string' && entry[1] !== '')
+    .sort(([a], [b]) => a.localeCompare(b));
+const cacheDir = (host) => {
+    const xdg = host.env.XDG_CACHE_HOME?.trim();
+    return xdg === undefined || xdg === '' ? join(host.home, '.cache') : xdg;
+};
+function unitWord(arg) {
+    const escaped = arg.replaceAll('%', '%%');
+    if (PLAIN_WORD.test(arg))
+        return escaped;
+    return `"${escaped.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+function unitText(service, target) {
+    return [
+        '[Unit]',
+        'Description=Metro daemon (metro serve)',
+        'After=network-online.target tailscaled.service',
+        'Wants=network-online.target',
+        '',
+        '[Service]',
+        ...service,
+        '',
+        '[Install]',
+        `WantedBy=${target}`,
+        '',
+    ].join('\n');
+}
+const RESTART = ['Restart=always', 'RestartSec=2', 'OOMPolicy=continue'];
+function systemdUnit(host, exec, target) {
+    const env = carriedEnv(host.env).map(([key, value]) => `Environment=${unitWord(`${key}=${value}`)}`);
+    return unitText([`ExecStart=${exec.map(unitWord).join(' ')}`, ...RESTART, `WorkingDirectory=${unitWord(host.home)}`, ...env], target);
+}
+const npmPrefix = (home) => join(home, '.npm-global');
+function runAsUnit(host, runAs, serveArgs) {
+    const prefix = npmPrefix(runAs.home);
+    const exec = [host.node, join(prefix, 'lib', 'node_modules', '@stage-labs', 'metro', 'dist', 'cli.js'), 'serve', ...serveArgs];
+    const env = carriedEnv(host.env)
+        .filter(([key]) => key.startsWith('METRO_') && !OWN_PATHS.has(key))
+        .map(([key, value]) => `Environment=${unitWord(`${key}=${value}`)}`);
+    return unitText([
+        `User=${runAs.name}`,
+        `Group=${runAs.name}`,
+        `ExecStart=${exec.map(unitWord).join(' ')}`,
+        ...RESTART,
+        'WorkingDirectory=/',
+        `Environment=HOME=${unitWord(runAs.home)}`,
+        `Environment=${unitWord(`PATH=${prefix}/bin:/usr/local/bin:/usr/bin:/bin`)}`,
+        `Environment=${unitWord(`NPM_CONFIG_PREFIX=${prefix}`)}`,
+        ...env,
+    ], 'multi-user.target');
+}
+const xml = (text) => text
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+function launchdPlist(host, exec, logFile) {
+    const env = carriedEnv(host.env).map(([key, value]) => `    <key>${xml(key)}</key><string>${xml(value)}</string>`);
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        '<dict>',
+        `  <key>Label</key><string>${LABEL}</string>`,
+        '  <key>ProgramArguments</key>',
+        '  <array>',
+        ...exec.map((arg) => `    <string>${xml(arg)}</string>`),
+        '  </array>',
+        '  <key>EnvironmentVariables</key>',
+        '  <dict>',
+        ...env,
+        '  </dict>',
+        `  <key>WorkingDirectory</key><string>${xml(host.home)}</string>`,
+        '  <key>RunAtLoad</key><true/>',
+        '  <key>KeepAlive</key><true/>',
+        `  <key>StandardOutPath</key><string>${xml(logFile)}</string>`,
+        `  <key>StandardErrorPath</key><string>${xml(logFile)}</string>`,
+        '</dict>',
+        '</plist>',
+        '',
+    ].join('\n');
+}
+const ROOT_HINT = `Metro running as root never starts Claude Code; install it as its own user:  metro service install --user ${METRO_USER}`;
+function systemdPlan(host, serveArgs, runAs) {
+    const exec = [host.node, host.cli, 'serve', ...serveArgs];
+    const system = host.uid === 0;
+    const ctl = system ? ['systemctl'] : ['systemctl', '--user'];
+    const file = system
+        ? `/etc/systemd/system/${SERVICE}.service`
+        : join(host.home, '.config', 'systemd', 'user', `${SERVICE}.service`);
+    return {
+        kind: 'systemd',
+        file,
+        content: runAs === undefined ? systemdUnit(host, exec, system ? 'multi-user.target' : 'default.target') : runAsUnit(host, runAs, serveArgs),
+        dirs: [],
+        install: [{ args: [...ctl, 'daemon-reload'] }, { args: [...ctl, 'enable', '--now', SERVICE] }],
+        uninstall: [{ args: [...ctl, 'disable', '--now', SERVICE], mayFail: true }],
+        reload: [{ args: [...ctl, 'daemon-reload'], mayFail: true }],
+        status: { args: [...ctl, 'is-active', SERVICE], mayFail: true },
+        hints: [
+            `Logs:  journalctl ${system ? '' : '--user '}-u ${SERVICE} -f`,
+            ...(system && runAs === undefined ? [ROOT_HINT] : []),
+            ...(system
+                ? []
+                : [`A user service stops with your login session; keep it up without one:  loginctl enable-linger ${host.user}`]),
+        ],
+    };
+}
+function launchdPlan(host, exec) {
+    const file = join(host.home, 'Library', 'LaunchAgents', `${LABEL}.plist`);
+    const domain = `gui/${String(host.uid)}`;
+    const logFile = join(cacheDir(host), 'metro', 'serve', 'service.log');
+    return {
+        kind: 'launchd',
+        file,
+        content: launchdPlist(host, exec, logFile),
+        dirs: [dirname(logFile)],
+        install: [
+            { args: ['launchctl', 'bootout', `${domain}/${LABEL}`], mayFail: true },
+            { args: ['launchctl', 'bootstrap', domain, file] },
+        ],
+        uninstall: [{ args: ['launchctl', 'bootout', `${domain}/${LABEL}`], mayFail: true }],
+        reload: [],
+        status: { args: ['launchctl', 'print', `${domain}/${LABEL}`], mayFail: true },
+        hints: [`Logs:  tail -f ${logFile}`],
+    };
+}
+export function servicePlan(host, serveArgs, runAs) {
+    const exec = [host.node, host.cli, 'serve', ...serveArgs];
+    if (runAs !== undefined && (host.platform !== 'linux' || host.uid !== 0))
+        throw new Error('--user installs a system service for another user: run it as root on Linux');
+    if (host.platform === 'linux')
+        return systemdPlan(host, serveArgs, runAs);
+    if (host.platform === 'darwin')
+        return launchdPlan(host, exec);
+    throw new Error(`metro service supports Linux (systemd) and macOS (launchd), not ${host.platform}`);
+}
+function splitUser(argv) {
+    const rest = [];
+    let user = null;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? '';
+        const inline = USER_FLAG.exec(arg);
+        if (inline === null && arg !== '--user') {
+            rest.push(arg);
+            continue;
+        }
+        user = inline?.[1] ?? argv[i + 1] ?? '';
+        if (inline === null)
+            i += 1;
+    }
+    return { user, rest };
+}
+function runAsOf(name, deps) {
+    if (name === null)
+        return undefined;
+    if (name !== METRO_USER)
+        throw new Error(`the root helper and its sudo rules are written for the user ${METRO_USER}; pass --user ${METRO_USER}, not '${name}'`);
+    const account = deps.account(name);
+    if (account === null)
+        throw new Error(`there is no user ${name} on this machine; create it first (useradd --system --create-home --home-dir /var/lib/${name} ${name})`);
+    return account;
+}
+async function refreshRoot(plan, deps) {
+    await deps.release(deps.version, 'root');
+    deps.out(`metro is already installed as a ${plan.kind} service (${plan.file}); its root side is current and follows every update by itself from now on, and the service keeps running`);
+    return 0;
+}
+function writeService(plan, deps) {
+    for (const dir of plan.dirs)
+        deps.mkdir(dir);
+    deps.write(plan.file, plan.content);
+    for (const command of plan.install)
+        deps.run(command);
+    deps.out(`Installed ${plan.file}: metro serve now starts at boot and after a crash, and the Server page on metro.box can stop, start and restart it.`);
+    for (const hint of plan.hints)
+        deps.out(hint);
+    return 0;
+}
+function install(argv, deps) {
+    const { user, rest: serveArgs } = splitUser(argv);
+    const args = parseServeArgs(serveArgs);
+    const runAs = runAsOf(user, deps);
+    const plan = servicePlan(deps.host, serveArgs, runAs);
+    if (deps.exists(plan.file) && runAs !== undefined)
+        return refreshRoot(plan, deps);
+    if (deps.exists(plan.file)) {
+        deps.out(`metro is already installed as a ${plan.kind} service (${plan.file}) and restarts on its own; metro service status says whether it is running. To change its arguments: metro service uninstall, then install again`);
+        return 0;
+    }
+    deps.preflight(args, runAs === undefined ? undefined : join(runAs.home, '.metro', 'agents'));
+    const pid = deps.running();
+    if (pid !== null)
+        throw new Error(`a metro serve is running on this machine (pid ${String(pid)}). Stop it first (metro stop), then install: the service takes over from there`);
+    if (runAs === undefined)
+        return writeService(plan, deps);
+    return deps.release(deps.version, 'root').then(() => writeService(plan, deps));
+}
+async function rootUpgrade(version, deps) {
+    if (deps.host.platform !== 'linux' || deps.host.uid !== 0)
+        throw new Error('metro service root-upgrade is for root on Linux; the metro-root-upgrade unit runs it');
+    await deps.release(version, 'metro');
+    return 0;
+}
+function uninstall(deps) {
+    const plan = servicePlan(deps.host, []);
+    if (!deps.exists(plan.file)) {
+        deps.out('metro is not installed as a service on this machine');
+        return 1;
+    }
+    for (const command of plan.uninstall)
+        deps.run(command);
+    deps.remove(plan.file);
+    for (const command of plan.reload)
+        deps.run(command);
+    deps.out(`Removed ${plan.file}; a running daemon was stopped, and metro serve no longer starts on its own`);
+    return 0;
+}
+function status(deps) {
+    const plan = servicePlan(deps.host, []);
+    if (!deps.exists(plan.file)) {
+        deps.out(`not installed (metro service install writes ${plan.file})`);
+        return 1;
+    }
+    const active = deps.run(plan.status).status === 0;
+    deps.out(active
+        ? `running as a ${plan.kind} service (${plan.file})`
+        : `installed as a ${plan.kind} service (${plan.file}), not running`);
+    return active ? 0 : 1;
+}
+function realHost() {
+    const who = userInfo();
+    return {
+        platform: platform(),
+        uid: who.uid,
+        user: who.username,
+        home: homedir(),
+        node: process.execPath,
+        cli: resolve(process.argv[1] ?? ''),
+        env: process.env,
+    };
+}
+export function serviceStopHint(host = realHost(), exists = existsSync) {
+    if (host.platform !== 'linux' && host.platform !== 'darwin')
+        return null;
+    const plan = servicePlan(host, []);
+    if (!exists(plan.file))
+        return null;
+    const keep = plan.kind === 'systemd'
+        ? `systemctl ${host.uid === 0 ? '' : '--user '}stop ${SERVICE}`
+        : `launchctl bootout gui/${String(host.uid)}/${LABEL}`;
+    return `metro runs as a ${plan.kind} service here (${plan.file}), so it starts again on its own in a moment. To keep it stopped:  ${keep}`;
+}
+function lookupAccount(name) {
+    const run = spawnSync('getent', ['passwd', name], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const home = run.status === 0 ? (run.stdout.trim().split(':')[5] ?? '') : '';
+    return home.startsWith('/') ? { name, home } : null;
+}
+function realDeps() {
+    return {
+        host: realHost(),
+        run: (command) => {
+            const [bin = '', ...args] = command.args;
+            const result = spawnSync(bin, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+            const code = result.status ?? 1;
+            if (code !== 0 && command.mayFail !== true) {
+                const said = [result.stderr, result.stdout, result.error?.message].find((t) => typeof t === 'string' && t.trim() !== '') ?? '';
+                throw new Error(`${command.args.join(' ')} failed (exit ${String(code)}): ${said.trim()}`);
+            }
+            return { status: code, output: `${result.stdout}${result.stderr}` };
+        },
+        running: serveLockedBy,
+        account: lookupAccount,
+        version: currentVersion(),
+        release: (version, trigger) => installRelease(version, trigger, realReleaseDeps()),
+        preflight: (args, agents) => {
+            requireOwner(args, agents);
+            findBun();
+            findTailscale();
+        },
+        mkdir: (dir) => {
+            mkdirSync(dir, { recursive: true });
+        },
+        write: (file, content) => {
+            mkdirSync(dirname(file), { recursive: true });
+            writeFileSync(file, content, { mode: 0o644 });
+        },
+        remove: (file) => {
+            rmSync(file, { force: true });
+        },
+        exists: existsSync,
+        out: (line) => {
+            process.stderr.write(`${line}\n`);
+        },
+    };
+}
+export function service(argv, deps = realDeps()) {
+    const [verb, ...rest] = argv;
+    if (verb === 'install')
+        return Promise.resolve(install(rest, deps));
+    if (verb === 'uninstall' && rest.length === 0)
+        return Promise.resolve(uninstall(deps));
+    if (verb === 'status' && rest.length === 0)
+        return Promise.resolve(status(deps));
+    if (verb === 'root-upgrade' && rest.length === 1)
+        return rootUpgrade(rest[0] ?? '', deps);
+    throw new Error(USAGE);
+}

package/dist/tail.js

@@ -0,0 +1,119 @@
+import { localAgent } from './local.js';
+import { assertAgentId, localUrl } from './runtime.js';
+const BACKOFF_MS = [1_000, 2_000, 5_000];
+const STALL_MS = 90_000;
+export const backoffAt = (attempt) => BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)] ?? 5_000;
+export function sseDataLines(buffer, chunk) {
+    const lines = (buffer + chunk).split('\n');
+    const rest = lines.pop() ?? '';
+    const events = [];
+    for (const raw of lines) {
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+        if (!line.startsWith('data:'))
+            continue;
+        const value = line.slice(5);
+        events.push(value.startsWith(' ') ? value.slice(1) : value);
+    }
+    return { rest, events };
+}
+function keySource(agentId) {
+    const fromEnv = process.env.METRO_AGENT_KEY?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return { resolve: () => Promise.resolve(fromEnv), fixed: true };
+    return {
+        resolve: () => {
+            const agent = localAgent();
+            if (agent === null || (agentId !== undefined && agent.id !== agentId))
+                throw new Error(`no agent ${agentId === undefined ? '' : `${agentId} `}on this machine — start metro serve, or set METRO_AGENT_KEY`);
+            return Promise.resolve(agent.key);
+        },
+        fixed: false,
+    };
+}
+const armStall = (control) => setTimeout(() => {
+    control.abort();
+}, STALL_MS);
+async function connect(key, signal) {
+    try {
+        return await fetch(`${localUrl()}/api/tail`, {
+            headers: { authorization: `Bearer ${key}` },
+            signal,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function pump(body, control, stall) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return 'ended';
+            clearTimeout(stall.timer);
+            stall.timer = armStall(control);
+            const out = sseDataLines(buffer, decoder.decode(value, { stream: true }));
+            buffer = out.rest;
+            for (const event of out.events)
+                process.stdout.write(`${event}\n`);
+        }
+    }
+    catch {
+        return 'ended';
+    }
+}
+async function streamOnce(key) {
+    const control = new AbortController();
+    const stall = { timer: armStall(control) };
+    try {
+        const res = await connect(key, control.signal);
+        if (res === null)
+            return 'unreachable';
+        if (res.status === 401)
+            return 'unauthorized';
+        if (!res.ok || res.body === null)
+            return 'unreachable';
+        return await pump(res.body, control, stall);
+    }
+    finally {
+        clearTimeout(stall.timer);
+    }
+}
+function note(state, message) {
+    if (state.last === message)
+        return;
+    state.last = message;
+    process.stderr.write(`metro: ${message}\n`);
+}
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function settle(end, source, key, state) {
+    if (end === 'unauthorized') {
+        if (source.fixed)
+            throw new Error('the key in METRO_AGENT_KEY was refused by the local daemon');
+        note(state, 'key refused — fetching the current one');
+        return source.resolve();
+    }
+    if (end === 'unreachable')
+        note(state, `no metro daemon on ${localUrl()} — run 'metro serve'`);
+    else
+        note(state, 'stream ended — reconnecting');
+    return key;
+}
+export async function tailEvents(argv) {
+    const agentId = argv[0] === undefined ? undefined : assertAgentId(argv[0]);
+    const source = keySource(agentId);
+    let key = await source.resolve();
+    const state = { last: '' };
+    let attempt = 0;
+    for (;;) {
+        const end = await streamOnce(key);
+        if (end === 'ended')
+            attempt = 0;
+        key = await settle(end, source, key, state);
+        await delay(backoffAt(attempt));
+        attempt += 1;
+    }
+}

package/dist/update.js

@@ -0,0 +1,45 @@
+import { spawnSync } from 'node:child_process';
+import { currentVersion, isNewer, PACKAGE_NAME, publishedVersion, } from './version.js';
+export function managerFor(location) {
+    return location.includes('/.bun/') ? 'bun' : 'npm';
+}
+export function installArgs(manager, version) {
+    const spec = `${PACKAGE_NAME}@${version}`;
+    return manager === 'bun'
+        ? ['add', '--global', spec]
+        : ['install', '--global', spec];
+}
+export const checkReport = (current, latest) => ({
+    current,
+    latest,
+    newer: latest !== '' && isNewer(latest, current),
+});
+async function updateCheck() {
+    return checkReport(currentVersion(), await publishedVersion());
+}
+export async function update(argv = []) {
+    if (argv.includes('--check')) {
+        process.stdout.write(`${JSON.stringify(await updateCheck())}\n`);
+        return 0;
+    }
+    const current = currentVersion();
+    const newest = await publishedVersion();
+    if (newest === '') {
+        process.stderr.write('npm published no version this CLI understands\n');
+        return 1;
+    }
+    if (!isNewer(newest, current)) {
+        process.stderr.write(`metro ${current} is the newest published version\n`);
+        return 0;
+    }
+    const manager = managerFor(import.meta.url);
+    const args = installArgs(manager, newest);
+    process.stderr.write(`Updating metro ${current} to ${newest} with ${manager}\n`);
+    const run = spawnSync(manager, args, { stdio: 'inherit' });
+    if (run.error !== undefined || run.status !== 0) {
+        process.stderr.write(`That did not work. Run it yourself:\n  ${manager} ${args.join(' ')}\n`);
+        return 1;
+    }
+    process.stderr.write(`metro is now ${newest}\n`);
+    return 0;
+}

package/dist/version.js

@@ -0,0 +1,97 @@
+import { readFileSync } from 'node:fs';
+export const PACKAGE_NAME = '@stage-labs/metro';
+const REGISTRY = 'https://registry.npmjs.org';
+const TIMEOUT_MS = 15_000;
+export function parseVersion(raw) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(raw.trim());
+    if (match === null)
+        return null;
+    const core = [match[1], match[2], match[3]].map((n) => Number(n));
+    const pre = match[4] === undefined
+        ? []
+        : match[4]
+            .split('.')
+            .map((part) => (/^\d+$/.test(part) ? Number(part) : part));
+    return { core, pre };
+}
+function comparePart(left, right) {
+    if (left === undefined)
+        return -1;
+    if (right === undefined)
+        return 1;
+    if (left === right)
+        return 0;
+    if (typeof left === 'number' && typeof right === 'number')
+        return left < right ? -1 : 1;
+    if (typeof left === 'number')
+        return -1;
+    if (typeof right === 'number')
+        return 1;
+    return left < right ? -1 : 1;
+}
+function comparePre(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    if (a.length === 0)
+        return 1;
+    if (b.length === 0)
+        return -1;
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const cmp = comparePart(a[i], b[i]);
+        if (cmp !== 0)
+            return cmp;
+    }
+    return 0;
+}
+export function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    if (left === null || right === null)
+        return 0;
+    for (let i = 0; i < 3; i += 1) {
+        const l = left.core[i] ?? 0;
+        const r = right.core[i] ?? 0;
+        if (l !== r)
+            return l < r ? -1 : 1;
+    }
+    return comparePre(left.pre, right.pre);
+}
+export function isNewer(candidate, current) {
+    return compareVersions(candidate, current) > 0;
+}
+export function currentVersion() {
+    const path = new URL('../package.json', import.meta.url);
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    return typeof raw.version === 'string' ? raw.version : '0.0.0';
+}
+export function newestOf(tags) {
+    let best = '';
+    for (const value of Object.values(tags)) {
+        if (typeof value !== 'string' || parseVersion(value) === null)
+            continue;
+        if (best === '' || isNewer(value, best))
+            best = value;
+    }
+    return best;
+}
+export async function publishedVersion() {
+    let res;
+    try {
+        res = await fetch(`${REGISTRY}/${PACKAGE_NAME.replace('/', '%2F')}`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+    }
+    catch {
+        throw new Error('could not reach the npm registry');
+    }
+    if (!res.ok)
+        throw new Error(`npm answered ${String(res.status)}`);
+    const body = await res.json();
+    if (typeof body !== 'object' || body === null)
+        throw new Error('npm returned an unexpected response');
+    const tags = body['dist-tags'];
+    if (typeof tags !== 'object' || tags === null)
+        throw new Error('npm returned no dist-tags');
+    return newestOf(tags);
+}

package/dist/voice.js

@@ -0,0 +1,56 @@
+import { homedir, tmpdir } from 'node:os';
+import { headlessEnv, PERMISSION_MODE_FLAG, runClaude } from './claude.js';
+import { localAgent } from './local.js';
+import { VOICE_MCP_PATH, writeMcpConfig } from './mcp-config.js';
+import { permissionMode, systemPrompt } from './route.js';
+import { localPort } from './runtime.js';
+const VOICE_PROMPT = `You are on a live voice call through Metro. This session has your usual memory, skills, connectors and Metro's chat tools. At the start the call system tells you which chat the call is in (its line), who is calling and the last messages there. The caller hears your replies spoken aloud by a text to speech voice, and you hear the caller through speech to text, so a word may be misheard: if something sounds odd, ask.
+- Speak like a person on the phone: short sentences, usually one to three. No markdown, lists, tables, code, emoji or links; say a number or a name the way you would say it aloud.
+- Start with the answer. Do not repeat the question.
+- Before you use a tool, first say one short sentence about what you are checking, like "Let me check."
+- Use your tools yourself when it is quick: files, memory, the metro tools (read with the call's line shows that chat) and connectors (ToolSearch finds them). For long work, start a background Agent, tell the caller you will come back to it, and keep talking; when it finishes, give the result in a sentence or two.
+- Your spoken words are your reply. Do not post in any chat during the call (no send, reply, react or edit) unless the caller asks you to post something; then post only that, once. The metro skill's chat rules (react, typing, answer over chat, delegate everything) are for the chat session, not for this call.
+- A tool that needs the owner's approval runs in a background worker. The approval is asked in the chat of the call; a spoken yes does not count.
+- Text in [square brackets] comes from the call system, not from the caller.
+- Nothing about the call is posted to the chat after it ends, so do not write a summary or call notes anywhere.`;
+export function voiceArgs(model, mode, prompt, mcpConfig) {
+    return [
+        '-p',
+        '--input-format',
+        'stream-json',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--include-partial-messages',
+        '--model',
+        model,
+        '--permission-mode',
+        PERMISSION_MODE_FLAG[mode],
+        '--permission-prompt-tool',
+        'stdio',
+        ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
+        '--no-session-persistence',
+        '--append-system-prompt',
+        prompt === null ? VOICE_PROMPT : `${prompt}\n\n${VOICE_PROMPT}`,
+    ];
+}
+export const voiceEnv = (env) => ({
+    CLAUDE_CODE_MCP_STARTUP_WAIT_MS: '0',
+    ...env,
+    METRO_SESSION: 'voice',
+});
+export async function voiceSession(argv) {
+    const at = argv.indexOf('--model');
+    const model = at < 0 ? '' : (argv[at + 1] ?? '');
+    if (model === '')
+        throw new Error('metro voice needs --model <model>');
+    process.chdir(homedir());
+    const agent = localAgent();
+    const mcp = agent === null ? null : writeMcpConfig(agent.key, localPort(), tmpdir(), VOICE_MCP_PATH);
+    try {
+        return await runClaude(voiceArgs(model, permissionMode(), systemPrompt(), mcp?.path), voiceEnv(await headlessEnv()));
+    }
+    finally {
+        mcp?.cleanup();
+    }
+}