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

package/dist/agents/codex.js

@@ -1,282 +0,0 @@
-// Codex agent adapter. Spawns `codex app-server --listen unix://…` as a
-// child process, talks to it over WebSocket-over-UDS, manages one codex
-// thread per scope, and streams per-turn events back to the orchestrator
-// (text deltas, tool-call lifecycle, completion).
-//
-// The orchestrator never speaks codex directly — it asks this adapter to
-// `ensureThread(scopeKey)` and `sendTurn(threadId, text, callbacks)`.
-import { spawn } from 'node:child_process';
-import { existsSync, unlinkSync } from 'node:fs';
-import { createConnection } from 'node:net';
-import { join } from 'node:path';
-import { WebSocket } from 'ws';
-import { errMsg, log } from '../log.js';
-import { STATE_DIR } from '../paths.js';
-const SOCKET_PATH = join(STATE_DIR, 'codex-app-server.sock');
-const READY_TIMEOUT_MS = 15_000;
-const READY_POLL_MS = 100;
-export class CodexAgent {
-    clientVersion;
-    ws = null;
-    daemon = null;
-    nextId = 1;
-    pending = new Map();
-    turnCallbacks = new Map(); // keyed by thread_id
-    constructor(clientVersion) {
-        this.clientVersion = clientVersion;
-    }
-    async start() {
-        // Fail loud at boot if codex isn't installed, rather than 15s later
-        // via a "socket didn't appear" timeout.
-        await this.checkCodexInstalled();
-        // Stale socket file from a previous run would let us connect to nothing
-        // (no listener) — wipe before spawning so codex binds fresh.
-        try {
-            unlinkSync(SOCKET_PATH);
-        }
-        catch { /* missing is fine */ }
-        log.info({ socket: SOCKET_PATH }, 'codex agent: starting app-server');
-        // Spawn the daemon listening on our UDS. Inherits CODEX_HOME so it picks
-        // up the user's auth, settings, MCPs, etc.
-        this.daemon = spawn('codex', ['app-server', '--listen', `unix://${SOCKET_PATH}`], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        // Capture daemon stderr so a startup failure surfaces with the actual
-        // error message, not just a generic timeout. Once the daemon is ready,
-        // stderr goes back to trace (its own tracing is noisy).
-        let bootStderr = '';
-        let daemonExited = false;
-        let daemonExitCode = null;
-        const onBootStderr = (d) => {
-            bootStderr += String(d);
-            log.trace({ src: 'codex-stderr' }, String(d).trim());
-        };
-        this.daemon.stdout?.on('data', d => log.trace({ src: 'codex-stdout' }, String(d).trim()));
-        this.daemon.stderr?.on('data', onBootStderr);
-        this.daemon.on('exit', code => {
-            daemonExited = true;
-            daemonExitCode = code;
-            log.warn({ code }, 'codex daemon exited');
-        });
-        try {
-            await this.waitForSocket(() => daemonExited, () => bootStderr.trim() || `exit code ${daemonExitCode}`);
-            await this.connect();
-        }
-        catch (err) {
-            // Make the failure self-explanatory in the orchestrator's catch log.
-            const detail = bootStderr.trim() ? ` (codex stderr: ${bootStderr.trim().slice(0, 200)})` : '';
-            throw new Error(`${errMsg(err)}${detail}`);
-        }
-        log.info('codex agent: ready');
-    }
-    async checkCodexInstalled() {
-        await new Promise((resolve, reject) => {
-            const c = spawn('codex', ['--version'], { stdio: ['ignore', 'ignore', 'pipe'] });
-            let stderr = '';
-            c.stderr?.on('data', d => { stderr += String(d); });
-            c.on('error', err => reject(new Error(`codex CLI not found on PATH: ${errMsg(err)}`)));
-            c.on('exit', code => code === 0
-                ? resolve()
-                : reject(new Error(`codex --version exited ${code}: ${stderr.trim()}`)));
-        });
-    }
-    async stop() {
-        this.ws?.close();
-        this.ws = null;
-        this.daemon?.kill('SIGTERM');
-        this.daemon = null;
-    }
-    /**
-     * Create a new codex thread and return its id. The caller is responsible
-     * for caching the mapping `scopeKey → threadId` and only calling this
-     * once per scope (subsequent inbounds reuse the thread via `sendTurn`).
-     */
-    async createThread() {
-        const result = await this.call('thread/start', {});
-        log.info({ thread: result.thread.id }, 'codex agent: thread created');
-        return result.thread.id;
-    }
-    /**
-     * Send a user message to a thread and stream the agent's response via
-     * the provided callbacks. Resolves immediately after `turn/start`
-     * acknowledges; callbacks fire as notifications arrive and conclude
-     * with `onComplete` or `onError`.
-     */
-    async sendTurn(threadId, text, callbacks) {
-        this.turnCallbacks.set(threadId, callbacks);
-        try {
-            // Wire format per codex's generated TS bindings: `text_elements`
-            // (snake_case), not camelCase. Sending camelCase silently degrades
-            // — accepted by the server but doesn't echo back in items.
-            await this.call('turn/start', {
-                threadId,
-                input: [{ type: 'text', text, text_elements: [] }],
-            });
-        }
-        catch (err) {
-            this.turnCallbacks.delete(threadId);
-            callbacks.onError(err instanceof Error ? err : new Error(String(err)));
-        }
-    }
-    // --- transport ---
-    async waitForSocket(exited, exitReason) {
-        const deadline = Date.now() + READY_TIMEOUT_MS;
-        while (Date.now() < deadline) {
-            if (exited())
-                throw new Error(`codex app-server exited before listening: ${exitReason()}`);
-            if (existsSync(SOCKET_PATH))
-                return;
-            await new Promise(r => setTimeout(r, READY_POLL_MS));
-        }
-        throw new Error(`codex app-server didn't appear at ${SOCKET_PATH} within ${READY_TIMEOUT_MS}ms`);
-    }
-    async connect() {
-        // perMessageDeflate disabled: codex 0.130's WS upgrade handler closes
-        // the connection if a client offers `Sec-WebSocket-Extensions:
-        // permessage-deflate` (the `ws` library's default). Disabling it makes
-        // the upgrade succeed cleanly. Compression is irrelevant over a UDS.
-        const ws = new WebSocket('ws://localhost/', {
-            perMessageDeflate: false,
-            createConnection: () => {
-                const sock = createConnection({ path: SOCKET_PATH });
-                // Swallow socket-level errors so a transport hiccup during the HTTP
-                // upgrade doesn't surface as an uncaught error on the http_client
-                // request (Node's http.ClientRequest re-emits this).
-                sock.on('error', err => log.warn({ err: errMsg(err) }, 'codex agent: socket error'));
-                return sock;
-            },
-        });
-        this.ws = ws;
-        ws.on('error', err => log.warn({ err: errMsg(err) }, 'codex agent: websocket error'));
-        await new Promise((resolve, reject) => {
-            ws.once('open', () => resolve());
-            ws.once('error', err => reject(err));
-        });
-        ws.on('message', data => this.onMessage(data));
-        ws.on('close', () => {
-            log.warn('codex agent: websocket closed');
-            this.ws = null;
-            // Drain stranded turns + RPC promises so the orchestrator can
-            // release its in-flight gate and the user sees an error rather
-            // than a permanent "Thinking…".
-            this.drainPending('codex websocket closed');
-        });
-        await this.call('initialize', {
-            clientInfo: { name: 'metro', version: this.clientVersion, title: null },
-        });
-    }
-    onMessage(raw) {
-        let msg;
-        try {
-            msg = JSON.parse(raw.toString());
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex agent: malformed message');
-            return;
-        }
-        // RPC response
-        if (msg.id !== undefined && this.pending.has(msg.id)) {
-            const p = this.pending.get(msg.id);
-            this.pending.delete(msg.id);
-            if (msg.error)
-                p.reject(new Error(msg.error.message ?? 'rpc error'));
-            else
-                p.resolve(msg.result);
-            return;
-        }
-        // Notifications.
-        if (!msg.method)
-            return;
-        log.trace({ method: msg.method }, 'codex agent: notification');
-        const params = msg.params;
-        const threadId = params?.threadId;
-        if (!threadId)
-            return;
-        const cb = this.turnCallbacks.get(threadId);
-        if (!cb)
-            return; // no active turn for this thread (yet or anymore)
-        if (msg.method === 'item/agentMessage/delta') {
-            const p = msg.params;
-            cb.onDelta(p.delta);
-        }
-        else if (msg.method === 'item/started') {
-            const p = msg.params;
-            const summary = summarizeItem(p.item);
-            if (summary && p.item.type !== 'agentMessage' && p.item.type !== 'userMessage') {
-                cb.onToolStart(p.item.type, summary);
-            }
-        }
-        else if (msg.method === 'item/completed') {
-            const p = msg.params;
-            if (p.item.type !== 'agentMessage' && p.item.type !== 'userMessage')
-                cb.onToolEnd(p.item.type);
-        }
-        else if (msg.method === 'thread/status/changed') {
-            // Codex 0.130 doesn't reliably emit `turn/completed` — `thread/status`
-            // returning to `idle` is the dependable completion signal. The same
-            // notification fires on `active` when a turn starts; ignore those.
-            const p = msg.params;
-            if (p.status?.type === 'idle') {
-                this.turnCallbacks.delete(threadId);
-                cb.onComplete();
-            }
-            else if (p.status?.type === 'systemError') {
-                this.turnCallbacks.delete(threadId);
-                cb.onError(new Error('codex thread entered systemError'));
-            }
-        }
-        else if (msg.method === 'turn/completed') {
-            // Belt-and-braces: if codex does emit it, take it.
-            this.turnCallbacks.delete(threadId);
-            cb.onComplete();
-        }
-        else if (msg.method === 'error') {
-            const p = msg.params;
-            this.turnCallbacks.delete(threadId);
-            cb.onError(new Error(p.error?.message ?? 'codex error notification'));
-        }
-    }
-    call(method, params) {
-        if (!this.ws)
-            return Promise.reject(new Error('codex agent: not connected'));
-        const id = this.nextId++;
-        const ws = this.ws;
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve: resolve, reject });
-            ws.send(JSON.stringify({ jsonrpc: '2.0', id, method, params }));
-        });
-    }
-    /** Fail every in-flight turn + RPC. Used when the transport dies. */
-    drainPending(reason) {
-        const err = new Error(reason);
-        for (const cb of this.turnCallbacks.values()) {
-            try {
-                cb.onError(err);
-            }
-            catch (e) {
-                log.warn({ err: errMsg(e) }, 'codex agent: drain callback threw');
-            }
-        }
-        this.turnCallbacks.clear();
-        for (const p of this.pending.values())
-            p.reject(err);
-        this.pending.clear();
-    }
-}
-function summarizeItem(item) {
-    if (item.type === 'commandExecution' && 'command' in item) {
-        return `Running: ${truncate(item.command ?? '', 60)}`;
-    }
-    if (item.type === 'fileChange' && 'changes' in item) {
-        const n = item.changes?.length ?? 0;
-        return n > 0 ? `Editing ${n} file${n === 1 ? '' : 's'}` : 'Editing files';
-    }
-    if (item.type === 'reasoning')
-        return 'Thinking…';
-    if (item.type === 'agentMessage')
-        return ''; // text deltas handled separately
-    return item.type;
-}
-function truncate(s, n) {
-    return s.length > n ? s.slice(0, n - 1) + '…' : s;
-}

package/dist/agents/types.js

@@ -1,3 +0,0 @@
-// Shared interface so the orchestrator can talk to either Codex or Claude
-// Code (or future agents) through the same surface.
-export {};

package/dist/channels/discord.js

@@ -1,142 +0,0 @@
-import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
-import { errMsg, log } from '../log.js';
-// Receive path: discord.js gateway, owned by the orchestrator.
-// Send path: raw REST against discord.com/api — no gateway login required,
-// so callers outside the orchestrator (e.g. cli.ts validation) stay one-shot.
-const API_BASE = 'https://discord.com/api/v10';
-function token() {
-    const t = process.env.DISCORD_BOT_TOKEN;
-    if (!t)
-        throw new Error('DISCORD_BOT_TOKEN is not set');
-    return t;
-}
-async function rest(method, path, body, timeoutMs = 30_000, retriesLeft = 2) {
-    const res = await fetch(`${API_BASE}${path}`, {
-        method,
-        headers: {
-            'Authorization': `Bot ${token()}`,
-            'User-Agent': 'metro (https://github.com/bonustrack/metro, dev)',
-            ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
-        },
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-        signal: AbortSignal.timeout(timeoutMs),
-    });
-    // 429: honor Discord's retry_after (seconds) and try again, up to a few
-    // hops. Common during streaming edits when the agent emits deltas faster
-    // than the per-channel edit cap.
-    if (res.status === 429 && retriesLeft > 0) {
-        const retryAfter = Number(res.headers.get('retry-after')) || 1;
-        log.debug({ path, retryAfter }, 'discord 429; backing off');
-        await new Promise(r => setTimeout(r, Math.max(retryAfter * 1000, 250)));
-        return rest(method, path, body, timeoutMs, retriesLeft - 1);
-    }
-    if (!res.ok) {
-        const text = await res.text().catch(() => '');
-        throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
-    }
-    // 204 No Content for typing/reactions/clear.
-    if (res.status === 204)
-        return undefined;
-    return (await res.json());
-}
-// ---------- Receive path (gateway, discord.js) -----------------------------
-let client = null;
-function getClient() {
-    if (client)
-        return client;
-    client = new Client({
-        intents: [
-            GatewayIntentBits.DirectMessages,
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.MessageContent,
-        ],
-        // DM channels arrive partial; without this messageCreate never fires.
-        partials: [Partials.Channel],
-    });
-    return client;
-}
-let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
-}
-export async function shutdownGateway() {
-    if (!client)
-        return;
-    await client.destroy();
-    client = null;
-}
-export async function startGateway() {
-    const c = getClient();
-    c.on(Events.MessageCreate, m => {
-        if (m.author.bot)
-            return;
-        // Forward every human message; the orchestrator decides what to route
-        // where (scoped thread vs new bootstrap mention vs ignore). The bot's
-        // own @-mention is preserved in `m.content` so the orchestrator can
-        // make that decision from the same payload.
-        const tags = [...m.attachments.values()]
-            .map(a => {
-            if (a.contentType?.startsWith('image/'))
-                return '[image]';
-            if (a.contentType?.startsWith('audio/'))
-                return `[audio: ${a.name}]`;
-            return `[file: ${a.name}]`;
-        })
-            .join(' ');
-        const text = [m.content, tags].filter(Boolean).join(' ').trim();
-        if (!text)
-            return;
-        onInboundHandler({
-            channel_id: m.channelId,
-            message_id: m.id,
-            text,
-            in_guild: !!m.guildId,
-            mentions_bot: c.user ? m.mentions.has(c.user.id) : false,
-        });
-    });
-    c.on(Events.Error, err => log.error({ err: errMsg(err) }, 'discord error'));
-    await c.login(process.env.DISCORD_BOT_TOKEN);
-    await new Promise(r => c.once(Events.ClientReady, () => r()));
-}
-export async function getMe() {
-    const me = await rest('GET', '/users/@me');
-    return { username: me.username };
-}
-export async function sendMessage(channelId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text });
-    return sent.id;
-}
-/**
- * Create a public thread anchored to an existing message. The user's
- * @-mention becomes the thread's starter, so the thread is visually
- * tied to the request that opened it. Returns the new thread's channel id.
- */
-export async function createThreadFromMessage(channelId, messageId, name) {
-    const created = await rest('POST', `/channels/${channelId}/messages/${messageId}/threads`, {
-        name,
-        auto_archive_duration: 1440,
-    });
-    return created.id;
-}
-export async function editMessage(channelId, messageId, text) {
-    const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text });
-    return sent.id;
-}
-/**
- * Fetch all messages newer than `afterMessageId` in a channel. Used for
- * catchup-on-restart so messages sent while metro was down still get a
- * reply once it comes back. Caps at 100 messages — anything older than
- * that during downtime is dropped on the floor.
- */
-export async function fetchMessagesSince(channelId, afterMessageId) {
-    const msgs = await rest('GET', `/channels/${channelId}/messages?after=${afterMessageId}&limit=100`);
-    // Discord returns newest-first; flip to chronological so replay order
-    // matches what the user actually typed.
-    return [...msgs].reverse().map(m => ({
-        message_id: m.id,
-        text: m.content,
-        author_id: m.author.id,
-        author_is_bot: !!m.author.bot,
-    }));
-}

package/dist/channels/telegram.js

@@ -1,209 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { STATE_DIR } from '../paths.js';
-import { errMsg, log } from '../log.js';
-const API_BASE = 'https://api.telegram.org';
-function token() {
-    const t = process.env.TELEGRAM_BOT_TOKEN;
-    if (!t)
-        throw new Error('TELEGRAM_BOT_TOKEN is not set');
-    return t;
-}
-async function tg(method, body, opts = {}) {
-    const timeout = opts.timeoutMs ?? 30_000;
-    const signals = [AbortSignal.timeout(timeout)];
-    if (opts.signal)
-        signals.push(opts.signal);
-    const signal = AbortSignal.any(signals);
-    const res = await fetch(`${API_BASE}/bot${token()}/${method}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-        signal,
-    });
-    const json = (await res.json());
-    if (!json.ok)
-        throw new Error(`telegram ${method}: ${json.description ?? 'unknown error'}`);
-    return json.result;
-}
-// ---------- Identity (cached after getMe) ----------------------------------
-let botUsername = null;
-let botUserId = null;
-export async function getMe() {
-    const me = await tg('getMe', {});
-    botUsername = me.username;
-    botUserId = me.id;
-    return me;
-}
-let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
-}
-const offsetFile = join(STATE_DIR, 'telegram-offset.json');
-let pollOffset = 0;
-let pollAbort = null;
-function loadOffset() {
-    try {
-        if (!existsSync(offsetFile))
-            return 0;
-        return Number(readFileSync(offsetFile, 'utf8').trim()) || 0;
-    }
-    catch {
-        return 0;
-    }
-}
-function saveOffset(o) {
-    try {
-        writeFileSync(offsetFile, String(o));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'telegram offset save failed');
-    }
-}
-export async function startPolling() {
-    // A registered webhook short-circuits getUpdates — clear it defensively.
-    await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
-    const persisted = loadOffset();
-    if (persisted > 0) {
-        // Resume from where we left off — telegram queues updates for ~24h, so
-        // any messages sent while metro was down come back through this poll.
-        pollOffset = persisted;
-        log.info({ offset: pollOffset }, 'telegram polling: resuming from persisted offset');
-    }
-    else {
-        // First-ever run: skip historical backlog by anchoring on the latest
-        // update id (-1 returns just the most recent one without consuming it).
-        const initial = await tg('getUpdates', { offset: -1, timeout: 0 });
-        pollOffset = initial.length ? initial[0].update_id + 1 : 0;
-        saveOffset(pollOffset);
-        log.info({ offset: pollOffset }, 'telegram polling: starting fresh');
-    }
-    pollAbort = new AbortController();
-    void pollLoop();
-}
-async function pollLoop() {
-    const abortSignal = pollAbort?.signal;
-    while (pollAbort && !pollAbort.signal.aborted) {
-        try {
-            const updates = await tg('getUpdates', { offset: pollOffset, timeout: 25 }, { timeoutMs: 60_000, signal: abortSignal });
-            for (const u of updates) {
-                pollOffset = u.update_id + 1;
-                await dispatchUpdate(u);
-            }
-            if (updates.length)
-                saveOffset(pollOffset);
-        }
-        catch (err) {
-            if (pollAbort?.signal.aborted)
-                break;
-            log.warn({ err: errMsg(err) }, 'telegram poll error; backing off');
-            await new Promise(r => setTimeout(r, 2000));
-        }
-    }
-    log.info('telegram polling stopped');
-}
-export async function shutdownPolling() {
-    pollAbort?.abort();
-    pollAbort = null;
-}
-async function dispatchUpdate(u) {
-    const m = u.message;
-    if (!m?.chat?.id || typeof m.message_id !== 'number') {
-        log.trace({ update_id: u.update_id }, 'telegram: non-message update');
-        return;
-    }
-    if (m.from?.is_bot) {
-        log.trace({ chat: m.chat.id }, 'telegram: skipping bot author');
-        return;
-    }
-    const text = await messageToText(m);
-    if (!text) {
-        log.trace({ chat: m.chat.id }, 'telegram: no text/caption');
-        return;
-    }
-    const msg = {
-        chat_id: m.chat.id,
-        message_id: m.message_id,
-        message_thread_id: m.is_topic_message ? m.message_thread_id : undefined,
-        text,
-        is_private: m.chat.type === 'private',
-        is_forum_topic: !!m.is_topic_message,
-        in_forum: !!m.chat.is_forum,
-        mentions_bot: detectMentionsBot(m),
-    };
-    log.debug({
-        chat: msg.chat_id,
-        topic: msg.message_thread_id,
-        is_private: msg.is_private,
-        is_forum_topic: msg.is_forum_topic,
-        in_forum: msg.in_forum,
-        mentions_bot: msg.mentions_bot,
-    }, 'telegram: inbound');
-    onInboundHandler(msg);
-}
-function detectMentionsBot(m) {
-    // In DMs, every message to the bot is implicitly addressed to it.
-    if (m.chat?.type === 'private')
-        return true;
-    const text = m.text ?? m.caption ?? '';
-    const entities = m.entities ?? m.caption_entities ?? [];
-    for (const e of entities) {
-        if (e.type === 'mention' && botUsername) {
-            const slice = text.substring(e.offset, e.offset + e.length);
-            if (slice.toLowerCase() === `@${botUsername.toLowerCase()}`)
-                return true;
-        }
-        else if (e.type === 'text_mention' && e.user?.id === botUserId) {
-            return true;
-        }
-    }
-    return false;
-}
-async function messageToText(m) {
-    if (m.text)
-        return m.text;
-    const caption = m.caption ?? '';
-    if (m.photo?.length)
-        return [caption, '[image]'].filter(Boolean).join(' ');
-    if (m.document?.mime_type?.startsWith('image/'))
-        return [caption, '[image]'].filter(Boolean).join(' ');
-    if (m.voice)
-        return [caption, '[voice]'].filter(Boolean).join(' ');
-    if (m.audio)
-        return [caption, '[audio]'].filter(Boolean).join(' ');
-    return caption || null;
-}
-// ---------- Outbound (REST) ------------------------------------------------
-/**
- * Create a new forum topic in a supergroup. Returns the topic's
- * message_thread_id. Requires the bot to be an admin with the
- * `can_manage_topics` privilege.
- */
-export async function createForumTopic(chatId, name) {
-    // Telegram caps topic names at 128 chars.
-    const trimmedName = name.slice(0, 128) || 'metro';
-    const r = await tg('createForumTopic', {
-        chat_id: chatId,
-        name: trimmedName,
-    });
-    return r.message_thread_id;
-}
-export async function sendMessage(chatId, threadId, text) {
-    const body = { chat_id: chatId, text };
-    if (threadId !== undefined)
-        body.message_thread_id = threadId;
-    const r = await tg('sendMessage', body);
-    return r.message_id;
-}
-export async function editMessageText(chatId, messageId, text) {
-    try {
-        await tg('editMessageText', { chat_id: chatId, message_id: messageId, text });
-    }
-    catch (err) {
-        // Telegram rejects edits that match the existing content — ignore that
-        // specific case so debounced no-op flushes don't surface as errors.
-        if (errMsg(err).includes('message is not modified'))
-            return;
-        throw err;
-    }
-}

package/dist/lib/dotenv.js

@@ -1,31 +0,0 @@
-// Tiny .env reader/writer. Used by `metro setup` (read/write the global
-// config file) and by paths.ts (load env vars into process.env at startup).
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-const LINE_RE = /^\s*([A-Za-z_]\w*)\s*=\s*(.*?)\s*$/;
-const QUOTED_RE = /^(['"])(.*)\1$/;
-export function readDotenv(path) {
-    if (!existsSync(path))
-        return {};
-    const out = {};
-    for (const line of readFileSync(path, 'utf8').split('\n')) {
-        const m = line.match(LINE_RE);
-        if (m)
-            out[m[1]] = m[2].replace(QUOTED_RE, '$2');
-    }
-    return out;
-}
-export function writeDotenv(path, env) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, Object.entries(env).map(([k, v]) => `${k}=${v}`).join('\n') + '\n');
-    chmodSync(path, 0o600);
-}
-// Load .env at `path` into process.env, but only for keys that aren't already
-// set — first definer wins, so callers control precedence by the order they
-// invoke this.
-export function loadDotenvIntoProcess(path) {
-    for (const [k, v] of Object.entries(readDotenv(path))) {
-        if (process.env[k] === undefined)
-            process.env[k] = v;
-    }
-}