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

package/dist/native-recovery-state.js

@@ -0,0 +1,154 @@
+import { randomUUID } from 'node:crypto';
+import { closeSync, constants, fstatSync, fsyncSync, lstatSync, mkdirSync, opendirSync, openSync, readSync, renameSync, rmdirSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { isRecord, processAlive } from './background.js';
+export const NATIVE_TASK_MAX = 256;
+export const NATIVE_FILE_MAX = 16;
+export const NATIVE_CURSOR_MAX = 256;
+export const NATIVE_NOTICE_MAX = 512;
+export const NATIVE_STATE_BYTES = 512 * 1024;
+export const nativeToken = (value) => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(value);
+export const nativeId = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const integer = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+const nullable = (value, valid) => value === null || valid(value);
+const keys = (value, fields) => Object.keys(value).length === fields.length && fields.every((key) => Object.hasOwn(value, key));
+const statuses = new Set(['started', 'completed', 'failed', 'stopped', 'restarted']);
+const reasons = new Set(['interrupted', 'failed', 'restarted', 'incomplete']);
+function taskFields(value) {
+    return nullable(value.source, nativeToken) && nativeToken(value.tool) && (value.kind === 'Agent' || value.kind === 'SendMessage')
+        && nullable(value.agent, nativeToken) && statuses.has(value.state) && nativeToken(value.receipt);
+}
+function task(value) {
+    return isRecord(value) && keys(value, ['id', 'source', 'tool', 'kind', 'agent', 'at', 'updatedAt', 'state', 'receipt']) && nativeId(value.id)
+        && integer(value.at) && integer(value.updatedAt) && value.updatedAt >= value.at && taskFields(value);
+}
+function noticeTimes(value) {
+    if (!nullable(value.deliveredAt, integer) || !nullable(value.acknowledgedAt, integer))
+        return false;
+    if (value.attempts === 0)
+        return value.deliveredAt === null && value.acknowledgedAt === null;
+    if (typeof value.deliveredAt !== 'number')
+        return false;
+    return value.acknowledgedAt === null || (typeof value.acknowledgedAt === 'number' && value.acknowledgedAt >= value.deliveredAt);
+}
+function notice(value) {
+    return isRecord(value) && keys(value, ['id', 'task', 'reason', 'attempts', 'deliveredAt', 'acknowledgedAt']) && nativeId(value.id)
+        && nullable(value.task, nativeId) && reasons.has(value.reason) && integer(value.attempts) && value.attempts <= 3 && noticeTimes(value);
+}
+function cursor(value) {
+    return isRecord(value) && keys(value, ['agent', 'offset']) && nullable(value.agent, nativeToken) && integer(value.offset);
+}
+function rows(value, max, valid, key) {
+    return Array.isArray(value) && value.length <= max && value.every(valid) && new Set(value.map(key)).size === value.length;
+}
+function validState(value, owner) {
+    if (!isRecord(value) || !keys(value, ['version', 'owner', 'tasks', 'notices', 'files']) || value.version !== 1 || value.owner !== owner)
+        return false;
+    const { tasks, notices, files } = value;
+    return rows(tasks, NATIVE_TASK_MAX, task, (v) => v.id) && rows(notices, NATIVE_NOTICE_MAX, notice, (v) => v.id)
+        && rows(files, NATIVE_CURSOR_MAX, cursor, (v) => v.agent)
+        && notices.every((row) => row.task === null || tasks.some((entry) => entry.id === row.task));
+}
+function readStateBytes(path) {
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > NATIVE_STATE_BYTES)
+            throw new Error('state exceeds its size bound');
+        const buffer = Buffer.alloc(NATIVE_STATE_BYTES + 1);
+        const count = readSync(fd, buffer, 0, buffer.length, 0);
+        if (count !== stat.size || fstatSync(fd).size !== stat.size)
+            throw new Error('state changed while reading');
+        return buffer.subarray(0, count).toString('utf8');
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function readNativeState(path, owner) {
+    try {
+        const raw = JSON.parse(readStateBytes(path));
+        if (!validState(raw, owner))
+            throw new Error('state does not match its schema');
+        return raw;
+    }
+    catch (err) {
+        if (isRecord(err) && err.code === 'ENOENT')
+            return { version: 1, owner, tasks: [], notices: [], files: [] };
+        throw new Error('Native recovery state cannot be read safely. Restore it before resuming; it has not been overwritten.', { cause: err });
+    }
+}
+function retireLock(path) {
+    if (!lstatSync(path).isDirectory())
+        throw new Error('Native recovery lock is not a directory');
+    const dir = opendirSync(path);
+    let name;
+    try {
+        name = dir.readSync()?.name;
+        if (dir.readSync() !== null)
+            throw new Error('Native recovery lock has unexpected entries');
+    }
+    finally {
+        dir.closeSync();
+    }
+    const pid = /^(\d{1,10})-[a-f0-9-]{36}$/.exec(name ?? '')?.[1];
+    if (pid === undefined || Number(pid) < 1 || processAlive(Number(pid)))
+        throw new Error('Native recovery preparation is locked. Restore an unreadable lock before resuming.');
+    unlinkSync(join(path, name ?? ''));
+    rmdirSync(path);
+}
+export function withNativeStateLock(path, work) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const lock = `${path}.lock`;
+    try {
+        mkdirSync(lock, { mode: 0o700 });
+    }
+    catch (err) {
+        if (!isRecord(err) || err.code !== 'EEXIST')
+            throw err;
+        retireLock(lock);
+        mkdirSync(lock, { mode: 0o700 });
+    }
+    const owner = join(lock, `${String(process.pid)}-${randomUUID()}`);
+    writeFileSync(owner, '', { flag: 'wx', mode: 0o600 });
+    try {
+        return work();
+    }
+    finally {
+        unlinkSync(owner);
+        rmdirSync(lock);
+    }
+}
+function syncDirectory(path) {
+    if (process.platform === 'win32')
+        return;
+    const fd = openSync(path, 'r');
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function saveNativeState(path, state) {
+    const text = JSON.stringify(state);
+    if (!validState(state, state.owner) || Buffer.byteLength(text) > NATIVE_STATE_BYTES)
+        throw new Error('Native recovery state exceeds its bounds; it has not been overwritten.');
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    try {
+        const fd = openSync(tmp, 'wx', 0o600);
+        try {
+            writeFileSync(fd, text);
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(tmp, path);
+        syncDirectory(dirname(path));
+    }
+    finally {
+        rmSync(tmp, { force: true });
+    }
+}

package/dist/native-recovery.js

@@ -0,0 +1,164 @@
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { claudeDir, projectDir, resumeSessionId } from './background.js';
+import { scanNative } from './native-recovery-scan.js';
+import { nativeToken, NATIVE_NOTICE_MAX, NATIVE_TASK_MAX, readNativeState, saveNativeState, withNativeStateLock } from './native-recovery-state.js';
+const hash = (...parts) => createHash('sha256').update(JSON.stringify(parts)).digest('hex');
+const taskId = (owner, source, tool) => hash(owner, source ?? '', tool);
+const RETRY_MS = [0, 60_000, 10 * 60_000];
+const PROMPT_NOTICES = 8;
+const taskReason = (task) => task.state === 'started' ? 'interrupted' : task.state === 'failed' ? 'failed' : task.state === 'restarted' ? 'restarted' : null;
+function agentResult(task, outcome) {
+    if (nativeToken(outcome.agentId))
+        task.agent = outcome.agentId;
+    if (outcome.status === 'completed')
+        task.state = 'completed';
+    else if (outcome.status === 'async_launched')
+        task.state = 'started';
+}
+function messageResult(task, outcome) {
+    if (outcome.success === true && nativeToken(outcome.resumedAgentId)) {
+        task.agent = outcome.resumedAgentId;
+        task.state = 'started';
+    }
+    else if (outcome.success === true && outcome.resumedAgentId === undefined)
+        task.state = 'completed';
+    else if (outcome.success === false)
+        task.state = 'failed';
+}
+function result(task, event) {
+    if (event.at < task.updatedAt || event.receipt === task.receipt)
+        return;
+    if (event.failed)
+        task.state = 'failed';
+    else if (event.outcome !== null) {
+        if (task.kind === 'Agent')
+            agentResult(task, event.outcome);
+        else
+            messageResult(task, event.outcome);
+    }
+    task.receipt = event.receipt;
+    task.updatedAt = event.at;
+}
+function acknowledge(state, event) {
+    const notice = state.notices.find((row) => row.id === event.id);
+    if (notice !== undefined && notice.deliveredAt !== null && event.at >= notice.deliveredAt)
+        notice.acknowledgedAt = event.at;
+}
+function notification(state, event) {
+    const candidates = state.tasks.filter((row) => row.source === event.source && row.at <= event.at
+        && (event.tool === null ? row.agent === event.agent : row.tool === event.tool && (row.agent === null || row.agent === event.agent)));
+    if (candidates.length > 1)
+        return false;
+    const task = candidates[0];
+    if (task !== undefined && event.at >= task.updatedAt) {
+        task.agent = event.agent;
+        task.state = event.state;
+        task.receipt = event.receipt;
+        task.updatedAt = event.at;
+    }
+    return true;
+}
+function applyEvent(state, event) {
+    if (event.type === 'ack') {
+        acknowledge(state, event);
+        return true;
+    }
+    if (event.type === 'notification')
+        return notification(state, event);
+    const id = taskId(state.owner, event.source, event.tool);
+    const task = state.tasks.find((row) => row.id === id);
+    if (event.type === 'result') {
+        if (task !== undefined)
+            result(task, event);
+        return true;
+    }
+    if (task !== undefined)
+        return true;
+    if (state.tasks.length >= NATIVE_TASK_MAX)
+        prune(state);
+    if (state.tasks.length >= NATIVE_TASK_MAX)
+        return false;
+    state.tasks.push({ id, source: event.source, tool: event.tool, kind: event.kind, agent: null, at: event.at, updatedAt: event.at, state: 'started', receipt: event.receipt });
+    return true;
+}
+function addNotice(state, task, reason, gap = 'incomplete') {
+    const id = hash(state.owner, task?.id ?? 'scan', task?.receipt ?? gap, reason);
+    if (state.notices.some((row) => row.id === id))
+        return;
+    if (state.notices.length >= NATIVE_NOTICE_MAX)
+        throw new Error('Native recovery has too many retained notices. Saved state has not been overwritten.');
+    state.notices.push({ id, task: task?.id ?? null, reason, attempts: 0, deliveredAt: null, acknowledgedAt: null });
+}
+function prune(state) {
+    const pending = new Set(state.notices.filter((row) => row.acknowledgedAt === null).map((row) => row.task));
+    const acknowledged = new Set(state.notices.filter((row) => row.acknowledgedAt !== null).map((row) => row.id));
+    const removable = state.tasks.filter((row) => !pending.has(row.id) && (taskReason(row) === null || acknowledged.has(hash(state.owner, row.id, row.receipt, taskReason(row) ?? ''))))
+        .sort((a, b) => a.updatedAt - b.updatedAt);
+    const removed = new Set(removable.slice(0, Math.max(0, state.tasks.length - NATIVE_TASK_MAX / 2)).map((row) => row.id));
+    state.tasks = state.tasks.filter((row) => !removed.has(row.id));
+    state.notices = state.notices.filter((row) => row.task === null || !removed.has(row.task));
+}
+function noticeLine(state, notice) {
+    const task = state.tasks.find((row) => row.id === notice.task);
+    const subject = task === undefined ? 'Native task history' : `${task.kind} receipt ${task.tool}${task.agent === null ? '' : `, worker ${task.agent}`}`;
+    const facts = {
+        interrupted: 'has no terminal receipt. Work may have run before interruption; its outcome is unknown.',
+        failed: 'reported failure. Earlier side effects may already have happened.',
+        restarted: 'was stopped by worker restart, not explicit user cancellation.',
+        incomplete: 'could not be fully checked within the bounded local scan. Other unfinished work may exist.',
+    };
+    return `${subject} ${facts[notice.reason]}\nAfter taking responsibility for this notice, emit a standalone assistant text block exactly: METRO_RECOVERY_ACK ${notice.id}`;
+}
+function promptFor(state, notices) {
+    return [
+        'Metro native recovery notice. This is recovery bookkeeping, not a new user task or permission to repeat actions.',
+        `Owner conversation: ${state.owner}. Native worker routing may have lost ownership metadata; this notice does not repair it.`,
+        'Review the affected work and current evidence, using a read-only worker if needed. Do not blindly rerun a task, resend a message, or repeat another side effect. Acknowledge awareness only; acknowledgment is not proof of successful completion. Do not post these bookkeeping markers to chat.',
+        ...notices.map((notice) => noticeLine(state, notice)),
+    ].join('\n\n');
+}
+function prepare(state, root) {
+    const scan = scanNative(root, state.owner, state.files, state.tasks);
+    prune(state);
+    for (const event of scan.events)
+        if (!applyEvent(state, event))
+            scan.gaps.push('unresolved-receipts');
+    state.files = scan.files;
+    for (const task of state.tasks) {
+        const reason = taskReason(task);
+        if (reason !== null)
+            addNotice(state, task, reason);
+    }
+    for (const gap of scan.gaps)
+        addNotice(state, null, 'incomplete', gap);
+}
+function isDue(notice, now) {
+    return notice.acknowledgedAt === null && notice.attempts < RETRY_MS.length
+        && (notice.deliveredAt === null || now - notice.deliveredAt >= (RETRY_MS[notice.attempts] ?? Infinity));
+}
+function locations(owner, deps) {
+    const env = deps.env ?? process.env;
+    const given = env.HOME?.trim();
+    const home = resolve(given === '' ? homedir() : given ?? homedir());
+    return { path: join(home, '.metro', 'native-recovery', `${owner}.json`), root: projectDir(claudeDir(env), deps.cwd ?? process.cwd()) };
+}
+export function nativeRecoveryArgs(extra, deps = {}) {
+    const owner = resumeSessionId(extra);
+    if (extra.length !== 2 || owner === undefined || (extra[0] !== '--resume' && extra[0] !== '-r'))
+        return extra;
+    const { path, root } = locations(owner, deps);
+    return withNativeStateLock(path, () => {
+        const state = readNativeState(path, owner);
+        prepare(state, root);
+        const now = deps.now ?? Date.now();
+        const due = state.notices.filter((row) => isDue(row, now)).slice(0, PROMPT_NOTICES);
+        for (const notice of due) {
+            notice.attempts += 1;
+            notice.deliveredAt = now;
+        }
+        saveNativeState(path, state);
+        return due.length === 0 ? extra : [...extra, promptFor(state, due)];
+    });
+}

package/dist/node-name.js

@@ -0,0 +1,71 @@
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentsDir } from './local.js';
+const NODE_FILE = '.node';
+const ALPHABET = 'abcdefghjkmnpqrstuvwxyz23456789';
+const NAME_RE = /^metro-[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/;
+const RENAME_WAIT_MS = 30_000;
+const RENAME_POLL_MS = 500;
+const renameWaitMs = () => Number(process.env.METRO_NODE_RENAME_WAIT_MS) || RENAME_WAIT_MS;
+const pause = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+const stderrLine = (line) => {
+    process.stderr.write(`${line}\n`);
+};
+export function newNodeName() {
+    const bytes = randomBytes(6);
+    return `metro-${[...bytes].map((b) => ALPHABET[b % ALPHABET.length] ?? 'x').join('')}`;
+}
+export function nodeName(dir = agentsDir()) {
+    const path = join(dir, NODE_FILE);
+    if (existsSync(path)) {
+        const held = readFileSync(path, 'utf8').trim();
+        if (NAME_RE.test(held))
+            return held;
+    }
+    const name = newNodeName();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(path, `${name}\n`, { mode: 0o600 });
+    return name;
+}
+export function currentNodeLabel(bin) {
+    const run = spawnSync(bin, ['status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (run.error !== undefined || run.status !== 0)
+        return null;
+    try {
+        const parsed = JSON.parse(run.stdout);
+        const dns = typeof parsed.Self?.DNSName === 'string' ? parsed.Self.DNSName : '';
+        const label = dns.split('.')[0] ?? '';
+        return label === '' ? null : label.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function awaitRename(bin, wanted, warn) {
+    const wait = renameWaitMs();
+    const until = Date.now() + wait;
+    while (Date.now() < until) {
+        if (currentNodeLabel(bin) === wanted)
+            return;
+        pause(RENAME_POLL_MS);
+    }
+    warn(`tailscale still reports the old machine name after ${String(Math.round(wait / 1000))}s; the Funnel address may come up under it until the next restart`);
+}
+export function ensureNodeName(bin, dir = agentsDir(), warn = stderrLine) {
+    const wanted = nodeName(dir);
+    if (currentNodeLabel(bin) === wanted)
+        return wanted;
+    const run = spawnSync(bin, ['set', '--hostname', wanted], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    if (run.error !== undefined || run.status !== 0) {
+        const said = run.stderr.trim();
+        const reason = said === '' ? (run.error?.message ?? `exit ${String(run.status)}`) : said;
+        throw new Error(`could not name this machine ${wanted} on your tailnet (${reason}).\n` +
+            `Run it once yourself, then start again:  sudo tailscale set --hostname ${wanted}`);
+    }
+    awaitRename(bin, wanted, warn);
+    return wanted;
+}

package/dist/onboarding.js

@@ -0,0 +1,44 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const FILE = '.claude.json';
+const FLAG = 'hasCompletedOnboarding';
+const given = (value) => value !== undefined && value.trim() !== '' ? value.trim() : undefined;
+export function claudeConfigPath(env = process.env) {
+    return join(given(env.CLAUDE_CONFIG_DIR) ?? given(env.HOME) ?? homedir(), FILE);
+}
+function readConfig(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function markOnboardingDone(path = claudeConfigPath()) {
+    const config = readConfig(path);
+    if (config === null)
+        return 'unreadable';
+    if (config[FLAG] === true)
+        return 'already';
+    writeFileSync(path, `${JSON.stringify({ ...config, [FLAG]: true }, null, 2)}\n`, { mode: 0o600 });
+    return 'marked';
+}
+const FEATURES = 'cachedGrowthBookFeatures';
+const CHANNEL_FLAGS = ['tengu_harbor', 'tengu_harbor_permissions'];
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export function seedChannels(path = claudeConfigPath()) {
+    const config = readConfig(path);
+    if (config === null)
+        return 'unreadable';
+    const features = isRecord(config[FEATURES]) ? config[FEATURES] : {};
+    if (CHANNEL_FLAGS.every((flag) => features[flag] === true))
+        return 'already';
+    const seeded = Object.fromEntries(CHANNEL_FLAGS.map((flag) => [flag, true]));
+    const next = { ...config, [FEATURES]: { ...features, ...seeded } };
+    writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    return 'marked';
+}

package/dist/provider-flags.js

@@ -0,0 +1,9 @@
+export const PROVIDER_FLAGS = [
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_MANTLE',
+    'CLAUDE_CODE_USE_VERTEX',
+    'CLAUDE_CODE_USE_FOUNDRY',
+    'CLAUDE_CODE_USE_ANTHROPIC_AWS',
+    'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
+    'CLAUDE_CODE_USE_GATEWAY',
+];

package/dist/root-release-io.js

@@ -0,0 +1,161 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { X509Certificate } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { isRecord } from './background.js';
+import { ISSUER, isVersion, PUBLISHER, RELEASE_DIR } from './root-release.js';
+import { PACKAGE_NAME } from './version.js';
+const REGISTRY = 'https://registry.npmjs.org';
+const ENCODED = PACKAGE_NAME.replace('/', '%2F');
+const ROOT_PATH = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
+const SETUP = join('runtime', 'node_modules', '@metro-labs', 'daemon', 'src', 'metro-user', 'install.ts');
+const MAX_TARBALL = 64 * 1024 * 1024;
+const TIMEOUT_MS = 60_000;
+const isSigstore = (mod) => isRecord(mod) && typeof mod.verify === 'function';
+export function rootOwned(path) {
+    let at = realpathSync(path);
+    for (;;) {
+        const st = statSync(at);
+        if (st.uid !== 0 || (st.mode & 0o022) !== 0)
+            return false;
+        if (at === dirname(at))
+            return true;
+        at = dirname(at);
+    }
+}
+function mustBeRootOwned(path, what) {
+    if (!existsSync(path) || !rootOwned(path))
+        throw new Error(`${what} at ${path} is missing or not owned by root alone; refused`);
+    return path;
+}
+async function getJson(url) {
+    const res = await fetch(url, { headers: { accept: 'application/json' }, signal: AbortSignal.timeout(TIMEOUT_MS) });
+    if (!res.ok)
+        throw new Error(`${url} answered ${String(res.status)}`);
+    return res.json();
+}
+async function published(version) {
+    const body = await getJson(`${REGISTRY}/${ENCODED}`);
+    const tags = isRecord(body) && isRecord(body['dist-tags']) ? body['dist-tags'] : {};
+    const entry = isRecord(body) && isRecord(body.versions) ? body.versions[version] : undefined;
+    const dist = isRecord(entry) && isRecord(entry.dist) ? entry.dist : {};
+    if (typeof dist.tarball !== 'string' || typeof dist.integrity !== 'string')
+        throw new Error(`npm has no ${PACKAGE_NAME}@${version}`);
+    return { tags, tarball: dist.tarball, integrity: dist.integrity };
+}
+async function download(url) {
+    const res = await fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+    if (!res.ok)
+        throw new Error(`${url} answered ${String(res.status)}`);
+    if (Number(res.headers.get('content-length') ?? 0) > MAX_TARBALL)
+        throw new Error(`${url} is too large`);
+    const bytes = Buffer.from(await res.arrayBuffer());
+    if (bytes.length > MAX_TARBALL)
+        throw new Error(`${url} is too large`);
+    return bytes;
+}
+function loadSigstore() {
+    const npm = mustBeRootOwned(join(dirname(dirname(process.execPath)), 'lib', 'node_modules', 'npm'), "npm's sigstore");
+    const mod = createRequire(join(npm, 'package.json'))('sigstore');
+    if (!isSigstore(mod))
+        throw new Error(`no sigstore verifier in ${npm}; refused`);
+    return mod;
+}
+function leafCertificate(bundle) {
+    const material = isRecord(bundle) && isRecord(bundle.verificationMaterial) ? bundle.verificationMaterial : {};
+    const chain = isRecord(material.x509CertificateChain) && Array.isArray(material.x509CertificateChain.certificates) ? material.x509CertificateChain.certificates : [];
+    const leaf = isRecord(material.certificate) ? material.certificate : chain[0];
+    return isRecord(leaf) && typeof leaf.rawBytes === 'string' ? leaf.rawBytes : null;
+}
+export function signedByPublisher(bundle) {
+    const raw = leafCertificate(bundle);
+    if (raw === null)
+        return false;
+    const names = new X509Certificate(Buffer.from(raw, 'base64')).subjectAltName?.split(', ') ?? [];
+    return names.includes(`URI:${PUBLISHER}`);
+}
+async function verifySignature(bundle) {
+    if (!signedByPublisher(bundle))
+        throw new Error(`the provenance was not signed for ${PUBLISHER}; refused`);
+    const sigstore = loadSigstore();
+    const tuf = mkdtempSync(join(tmpdir(), 'metro-tuf-'));
+    try {
+        await sigstore.verify(bundle, { certificateIdentityURI: PUBLISHER, certificateIssuer: ISSUER, tufCachePath: tuf });
+    }
+    catch (err) {
+        throw new Error(`the provenance signature does not check out: ${err instanceof Error ? err.message : String(err)}; refused`);
+    }
+    finally {
+        rmSync(tuf, { recursive: true, force: true });
+    }
+}
+function checked(file, args, cwd = '/') {
+    const run = spawnSync(file, args, { cwd, env: { PATH: ROOT_PATH }, stdio: ['ignore', 'inherit', 'inherit'] });
+    if (run.error !== undefined)
+        throw run.error;
+    if (run.status !== 0)
+        throw new Error(`${file} ${args.join(' ')} failed (exit ${String(run.status)})`);
+}
+function manifestVersion(dir) {
+    const file = join(dir, 'package.json');
+    if (!existsSync(file))
+        return null;
+    const raw = JSON.parse(readFileSync(file, 'utf8'));
+    return isRecord(raw) && raw.name === PACKAGE_NAME && typeof raw.version === 'string' && isVersion(raw.version) ? raw.version : null;
+}
+function unpack(tarball, version) {
+    const work = mkdtempSync(join(tmpdir(), 'metro-release-'));
+    const staged = `${RELEASE_DIR}.new`;
+    try {
+        const file = join(work, 'metro.tgz');
+        writeFileSync(file, tarball, { mode: 0o600 });
+        rmSync(staged, { recursive: true, force: true });
+        mkdirSync(staged, { recursive: true, mode: 0o755 });
+        checked('tar', ['-xzf', file, '-C', staged, '--strip-components=1', '--no-same-owner', '--no-same-permissions']);
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+    if (manifestVersion(staged) !== version)
+        throw new Error(`the unpacked package is not ${PACKAGE_NAME}@${version}; refused`);
+    return staged;
+}
+function findBun() {
+    const found = ROOT_PATH.split(':')
+        .map((dir) => join(dir, 'bun'))
+        .find((path) => existsSync(path));
+    if (found === undefined)
+        throw new Error(`no bun on ${ROOT_PATH}`);
+    return mustBeRootOwned(found, 'bun');
+}
+function setup(dir) {
+    const node = mustBeRootOwned(process.execPath, 'node');
+    checked(findBun(), ['--no-install', join(dir, SETUP), '--node', node]);
+}
+function swap(staged) {
+    const old = `${RELEASE_DIR}.old`;
+    rmSync(old, { recursive: true, force: true });
+    if (existsSync(RELEASE_DIR))
+        renameSync(RELEASE_DIR, old);
+    renameSync(staged, RELEASE_DIR);
+    rmSync(old, { recursive: true, force: true });
+}
+export function realReleaseDeps() {
+    process.umask(0o022);
+    mkdirSync(dirname(RELEASE_DIR), { recursive: true, mode: 0o755 });
+    return {
+        installed: () => manifestVersion(RELEASE_DIR),
+        published,
+        download,
+        attestations: (version) => getJson(`${REGISTRY}/-/npm/v1/attestations/${ENCODED}@${version}`),
+        verifySignature,
+        unpack,
+        setup,
+        swap,
+        out: (line) => {
+            process.stderr.write(`metro root: ${line}\n`);
+        },
+    };
+}