@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.14

package/dist/cli/tail.js

@@ -1,128 +1,74 @@
-/** CLI subcommands: `metro tail` (claim-aware log subscriber) + `metro claim|release|claims`. */
-import { existsSync, watch } from 'node:fs';
-import { CLAIMS_FILE, HISTORY_FILE, claimLine, cursorKey, historySize, passesMode, readClaims, readCursor, readEntriesFrom, releaseLine, writeCursor, } from '../broker.js';
-import { userSelf } from '../history.js';
-import { asLine } from '../stations/index.js';
-import { loadMetroEnv } from '../paths.js';
+/** CLI tail/claim/release/claims + read-only /api/state + /api/tail HTTP. Share drain/watch primitives. */
+import { timingSafeEqual } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import pkg from '../../package.json' with { type: 'json' };
+import { CLAIMS_FILE, claimLine, readClaims, releaseLine } from '../broker/claims.js';
+import { cursorKey, drainTail, followTail, historySize, readCursor, writeCursor, } from '../broker/history-stream.js';
+import { readHistory, userSelf } from '../history.js';
+import { asLine } from '../lines.js';
+import { errMsg, log } from '../log.js';
+import { loadMetroEnv, readBotIds } from '../paths.js';
 import { emit, exitErr, flagOne, isJson, need, writeJson } from './util.js';
-function resolveMode(f, self) {
-    const strict = f.strict === true, unclaimed = f.unclaimed === true, all = f.all === true;
-    if ([strict, unclaimed, all].filter(Boolean).length > 1) {
-        throw exitErr('--strict, --unclaimed, --all are mutually exclusive', 1);
-    }
-    if (strict) {
-        if (!self)
-            throw exitErr('--strict requires --as <user-uri>', 1);
-        return 'mine-only';
-    }
+/* ──────────── CLI: metro tail / claim / release / claims ──────────── */
+/** Pick mode from 3 booleans + optional self. Conflict/strict-no-self routed through `onErr`. */
+function pickMode(strict, unclaimed, all, self, onErr) {
+    if ([strict, unclaimed, all].filter(Boolean).length > 1)
+        return onErr('strict/unclaimed/all are mutually exclusive');
+    if (strict)
+        return self ? 'mine-only' : onErr('strict requires --as <user-uri>');
     if (unclaimed)
         return 'unclaimed';
     if (all || !self)
         return 'all';
     return 'mine-or-unclaimed';
 }
-/** Generic fallback returned by `userSelf()` when there's no Claude/Codex env — treat as "no identity". */
-const GENERIC_USER = 'metro://user';
-function resolveSelf(f) {
-    const raw = flagOne(f, 'as');
-    if (raw !== undefined)
-        return asLine(raw);
-    const auto = userSelf();
-    return auto === GENERIC_USER ? null : auto;
-}
-function resolveStartOffset(f, key) {
-    const since = flagOne(f, 'since');
-    if (since === 'tail')
-        return historySize();
-    if (since !== undefined) {
-        const n = Number(since);
-        if (!Number.isFinite(n) || n < 0)
-            throw exitErr(`--since must be a byte offset or 'tail' (got '${since}')`, 1);
-        return n;
-    }
-    return key ? readCursor(key) : 0;
-}
 export async function cmdTail(_, f) {
     loadMetroEnv();
-    const self = resolveSelf(f);
-    const mode = resolveMode(f, self);
+    const raw = flagOne(f, 'as');
+    const auto = userSelf();
+    const self = raw !== undefined ? asLine(raw) : auto === 'metro://user' ? null : auto;
+    const mode = pickMode(f.strict === true, f.unclaimed === true, f.all === true, self, msg => { throw exitErr(`--${msg}`, 1); });
+    const tail = {
+        mode, self, chatFilter: flagOne(f, 'chat'), stationFilter: flagOne(f, 'station'),
+        includeWebhooks: f['include-webhooks'] === true,
+    };
     const follow = f.follow === true;
-    const chatFilter = flagOne(f, 'chat');
-    const stationFilter = flagOne(f, 'station');
     const limit = Number(flagOne(f, 'limit')) || 0;
     const json = isJson(f);
-    const includeWebhooks = f['include-webhooks'] === true;
-    /** Cursor key derives from the effective mode (not userSelf), so `--all` / `--unclaimed` */
-    /** don't trample the personal `--as=<me>` cursor in a CLAUDECODE shell. */
-    const key = cursorKey(mode, self, { includeWebhooks });
-    const startOffset = resolveStartOffset(f, key);
+    /** Cursor key derives from effective mode (not userSelf), so --all/--unclaimed don't trample --as. */
+    const key = cursorKey(mode, self, { includeWebhooks: tail.includeWebhooks });
+    const since = flagOne(f, 'since');
+    const sN = since !== undefined && since !== 'tail' ? Number(since) : NaN;
+    if (since !== undefined && since !== 'tail' && (!Number.isFinite(sN) || sN < 0)) {
+        throw exitErr(`--since must be a byte offset or 'tail' (got '${since}')`, 1);
+    }
+    let offset = since === 'tail' ? historySize() : Number.isFinite(sN) ? sN : key ? readCursor(key) : 0;
     let emitted = 0;
-    let offset = startOffset;
-    const drain = () => {
-        /** read claims once per drain so a burst of events shares a snapshot */
-        const claims = readClaims();
-        for (const { entry, offset: next } of readEntriesFrom(offset)) {
-            offset = next;
-            if (chatFilter && entry.line !== chatFilter)
-                continue;
-            if (stationFilter && entry.station !== stationFilter)
-                continue;
-            if (!passesMode(entry, mode, self, claims, { includeWebhooks }))
-                continue;
-            if (json)
-                process.stdout.write(JSON.stringify(entry) + '\n');
-            else
-                process.stdout.write(fmtRow(entry) + '\n');
-            if (key)
-                writeCursor(key, offset);
-            emitted++;
-            if (limit && emitted >= limit)
-                return true;
-        }
-        return false;
+    const onEntry = (entry) => {
+        process.stdout.write((json ? JSON.stringify(entry) : fmtRow(entry)) + '\n');
+        if (key)
+            writeCursor(key, offset);
+        if (limit && ++emitted >= limit)
+            return true;
     };
-    if (drain() && !follow)
-        return;
-    if (!follow)
+    offset = drainTail(offset, tail, onEntry);
+    if ((limit && emitted >= limit) || !follow)
         return;
-    /** fs.watch on macOS sometimes coalesces or drops events — poll every 500ms as a backstop. */
     await new Promise(resolve => {
-        let watcher = null;
-        const trigger = () => { if (drain())
-            cleanup(); };
-        const cleanup = () => {
-            if (watcher) {
-                try {
-                    watcher.close();
-                }
-                catch { /* ignore */ }
-                watcher = null;
-            }
-            clearInterval(poll);
-            resolve();
-        };
-        const poll = setInterval(trigger, 500);
-        const startWatcher = () => {
-            if (!existsSync(HISTORY_FILE))
-                return;
-            try {
-                watcher = watch(HISTORY_FILE, () => trigger());
-            }
-            catch { /* ignore — poll will catch */ }
-        };
-        startWatcher();
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-        process.stdin.on('end', cleanup).on('close', cleanup);
+        const stop = followTail(offset, tail, e => { if (onEntry(e) === true)
+            finish(); }, 500);
+        const finish = () => { stop(); resolve(); };
+        process.on('SIGINT', finish);
+        process.on('SIGTERM', finish);
+        process.stdin.on('end', finish).on('close', finish);
     });
 }
 function fmtRow(e) {
-    const ts = e.ts.slice(11, 19);
     const body = e.text ?? (e.emoji ? `[react ${e.emoji}]` : '');
     const text = body.length > 80 ? body.slice(0, 79) + '…' : body;
     const who = (e.fromName ?? e.from).padEnd(28).slice(0, 28);
     const where = e.line.padEnd(40).slice(0, 40);
-    return `${ts}  ${e.id.padEnd(12)}  ${e.kind.padEnd(8)}  ${who}  ${where}  ${text}`;
+    return `${e.ts.slice(11, 19)}  ${e.id.padEnd(12)}  ${e.kind.padEnd(8)}  ${who}  ${where}  ${text}`;
 }
 export async function cmdClaim(p, f) {
     loadMetroEnv();
@@ -138,11 +84,7 @@ export async function cmdRelease(p, f) {
     need(p, 1, 'metro release <line>');
     const line = asLine(p[0]);
     const { released, claims } = releaseLine(line);
-    if (!released) {
-        emit(f, `${line} was not claimed`, { ok: true, released: false, line, claims });
-        return;
-    }
-    emit(f, `released ${line}`, { ok: true, released: true, line, claims });
+    emit(f, released ? `released ${line}` : `${line} was not claimed`, { ok: true, released, line, claims });
 }
 export async function cmdClaims(_, f) {
     loadMetroEnv();
@@ -151,14 +93,120 @@ export async function cmdClaims(_, f) {
     if (isJson(f))
         return writeJson({ claims });
     if (!entries.length) {
-        process.stdout.write('(no claims — every tail with matching filters receives every event)\n');
-        process.stdout.write(`file: ${CLAIMS_FILE}${existsSync(CLAIMS_FILE) ? '' : ' (not created yet)'}\n`);
+        process.stdout.write(`(no claims — every tail with matching filters receives every event)\nfile: ${CLAIMS_FILE}${existsSync(CLAIMS_FILE) ? '' : ' (not created yet)'}\n`);
         return;
     }
-    const widest = Math.max(...entries.map(([l]) => l.length));
+    const w = Math.max(...entries.map(([l]) => l.length));
     process.stdout.write('metro claims\n\n');
-    for (const [line, owner] of entries) {
-        process.stdout.write(`  ${line.padEnd(widest)}  →  ${owner}\n`);
-    }
+    for (const [l, o] of entries)
+        process.stdout.write(`  ${l.padEnd(w)}  →  ${o}\n`);
     process.stdout.write(`\n${entries.length} claim${entries.length === 1 ? '' : 's'} · ${CLAIMS_FILE}\n`);
 }
+/* ──────────── HTTP: /api/state + /api/tail (mounted on webhook server) ──────────── */
+/** Monitor endpoints answer only on dedicated hostnames so webhook tunnel can't double-serve them. */
+const MONITOR_HOSTS = new Set((process.env.METRO_MONITOR_HOSTS ?? 'monitor.metro.box,localhost,127.0.0.1').toLowerCase().split(',').map(s => s.trim()).filter(Boolean));
+const JSON_CT = { 'content-type': 'application/json' };
+function jsonRes(res, status, body) {
+    res.writeHead(status, JSON_CT);
+    res.end(JSON.stringify(body));
+}
+function authorized(req) {
+    const token = process.env.METRO_MONITOR_TOKEN;
+    if (!token)
+        return { status: 503, msg: 'monitor endpoints not configured (METRO_MONITOR_TOKEN unset)' };
+    const value = [].concat(req.headers['authorization'] ?? [])[0];
+    if (!value?.startsWith('Bearer '))
+        return { status: 401, msg: 'unauthorized' };
+    const given = Buffer.from(value.slice(7)), want = Buffer.from(token);
+    if (given.length !== want.length || !timingSafeEqual(given, want))
+        return { status: 401, msg: 'unauthorized' };
+    return null;
+}
+export function handleMonitorRequest(req, res) {
+    const url = req.url ?? '';
+    if (!url.startsWith('/api/'))
+        return false;
+    const host = req.headers[':authority'] ?? req.headers.host;
+    if (host && !MONITOR_HOSTS.has(host.split(':')[0].toLowerCase()))
+        return false;
+    if (req.method !== 'GET') {
+        jsonRes(res, 405, { error: 'method not allowed' });
+        return true;
+    }
+    const auth = authorized(req);
+    if (auth) {
+        jsonRes(res, auth.status, { error: auth.msg });
+        return true;
+    }
+    const [path, qs = ''] = url.split('?', 2);
+    const q = new URLSearchParams(qs);
+    if (path === '/api/state') {
+        handleState(res, q);
+        return true;
+    }
+    if (path === '/api/tail') {
+        handleTail(req, res, q).catch(err => {
+            log.warn({ err: errMsg(err) }, 'monitor: tail handler error');
+            try {
+                if (!res.headersSent)
+                    res.writeHead(500).end();
+                else
+                    res.end();
+            }
+            catch { /* ignore */ }
+        });
+        return true;
+    }
+    jsonRes(res, 404, { error: 'not found' });
+    return true;
+}
+function nonNegInt(raw) {
+    const n = raw == null ? NaN : Number(raw);
+    return Number.isInteger(n) && n >= 0 ? n : null;
+}
+function handleState(res, q) {
+    const before = nonNegInt(q.get('before'));
+    const limit = Math.min(nonNegInt(q.get('limit')) ?? 100, 500);
+    if (before !== null)
+        return jsonRes(res, 200, { recent_history: readHistory({ limit, skip: before }) });
+    const recent = readHistory({ limit }), claims = readClaims();
+    const lines = new Set([...recent.map(e => e.line), ...Object.keys(claims)]);
+    jsonRes(res, 200, {
+        claims, lines: [...lines], recent_history: recent, bot_ids: readBotIds(), version: pkg.version,
+    });
+}
+async function handleTail(req, res, q) {
+    const asParam = q.get('as');
+    const self = asParam ? asLine(asParam) : null;
+    const isOn = (k) => q.get(k) === 'true' || q.get('mode') === k;
+    const mode = pickMode(isOn('strict'), isOn('unclaimed'), isOn('all'), self, () => 'all');
+    const opts = {
+        mode, self, chatFilter: q.get('chat') ?? undefined,
+        stationFilter: q.get('station') ?? undefined,
+        includeWebhooks: q.get('include_webhooks') === 'true',
+    };
+    res.writeHead(200, {
+        'content-type': 'text/event-stream', 'cache-control': 'no-cache, no-transform',
+        'connection': 'keep-alive', 'access-control-allow-origin': '*',
+        /** Cloudflare/proxies buffer SSE without this hint. */
+        'x-accel-buffering': 'no',
+    });
+    /** `since=tail` (default) starts at EOF; `since=0` replays the full file; numeric = byte offset. */
+    const since = q.get('since');
+    const sinceN = since && since !== 'tail' ? Number(since) : NaN;
+    let offset = Number.isFinite(sinceN) && sinceN >= 0 ? sinceN : historySize();
+    /** 4 KiB padding so Cloudflare's HTTP/2 buffer flushes (else holds 30+ s on free tier). */
+    res.write(`: metro monitor tail (mode=${opts.mode}${self ? `, as=${self}` : ''})\n: ${'-'.repeat(4096)}\n\n`);
+    const sse = (e) => {
+        res.write(`id: ${e.id}\nevent: history\ndata: ${JSON.stringify(e)}\n\n`);
+    };
+    offset = drainTail(offset, opts, sse);
+    const stop = followTail(offset, opts, sse, 1_000);
+    const keepalive = setInterval(() => res.write(': keepalive\n\n'), 25_000);
+    const cleanup = () => { stop(); clearInterval(keepalive); try {
+        res.end();
+    }
+    catch { /* ignore */ } };
+    req.on('close', cleanup);
+    req.on('error', cleanup);
+}

package/dist/cli/webhook.js

@@ -1,7 +1,13 @@
-/** CLI subcommands: `metro webhook add|list|remove` + `metro tunnel setup`. */
+/** CLI subcommands: `metro call`, `metro trains list`, `metro webhook ...`, `metro tunnel ...`. */
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
-import { addEndpoint, listEndpoints, removeEndpoint, webhookPort } from '../webhooks.js';
-import { loadTunnelConfig, saveTunnelConfig } from '../tunnel.js';
+import { ipcCall } from '../ipc.js';
+import { loadMetroEnv } from '../paths.js';
+import { TRAINS_DIR } from '../trains/supervisor.js';
+import { addEndpoint, listEndpoints, loadTunnelConfig, removeEndpoint, saveTunnelConfig, webhookPort, } from '../tunnel.js';
 import { emit, exitErr, flagOne, isJson, need, writeJson } from './util.js';
 function urlFor(endpointId) {
     const t = loadTunnelConfig();
@@ -79,3 +85,97 @@ function run(cmd, args, opts = {}) {
     if (r.status !== 0 && !opts.allowFail)
         throw exitErr(`${cmd} ${args.join(' ')} exited ${r.status}`, 2);
 }
+/* ──────────── metro call <train> <action> [args]  +  metro trains list ──────────── */
+async function readArgs(raw) {
+    if (raw === undefined)
+        return {};
+    if (raw === '-') {
+        const chunks = [];
+        for await (const c of process.stdin)
+            chunks.push(c);
+        const s = Buffer.concat(chunks).toString('utf8').trim();
+        return s ? JSON.parse(s) : {};
+    }
+    if (raw.startsWith('@'))
+        return JSON.parse(readFileSync(raw.slice(1), 'utf8'));
+    /** Bare string allowed (handed to the train as-is). */
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+export async function cmdCall(p, f) {
+    need(p, 2, 'metro call <train> <action> [args-json | @file | -]');
+    loadMetroEnv();
+    const [train, action, rawArgs] = p;
+    const resp = await ipcCall({ op: 'forward-call', train, action, args: await readArgs(rawArgs) });
+    if (!resp.ok)
+        throw new Error(resp.error);
+    if (!('response' in resp))
+        throw new Error('daemon returned malformed forward-call response');
+    if (resp.response.error)
+        throw new Error(`train '${train}': ${resp.response.error}`);
+    if (isJson(f))
+        writeJson(resp.response.result ?? null);
+    else
+        process.stdout.write(JSON.stringify(resp.response.result ?? null) + '\n');
+}
+export async function cmdTrains(p, f) {
+    const sub = p[0] ?? 'list';
+    if (sub === 'restart')
+        return cmdTrainsRestart(p.slice(1), f);
+    if (sub === 'new')
+        return cmdTrainsNew(p.slice(1), f);
+    if (sub !== 'list')
+        throw new Error(`metro trains <list|restart|new>   (got '${sub}')`);
+    loadMetroEnv();
+    const resp = await ipcCall({ op: 'trains-list' });
+    if (!resp.ok)
+        throw new Error(resp.error);
+    if (!('trains' in resp))
+        throw new Error('daemon returned malformed trains-list response');
+    if (isJson(f))
+        return writeJson({ trains: resp.trains });
+    if (!resp.trains.length) {
+        process.stdout.write('metro trains\n\n  (no trains in ~/.metro/trains/)\n');
+        return;
+    }
+    process.stdout.write('metro trains\n\n');
+    for (const t of resp.trains) {
+        const mark = t.running ? '●' : '○';
+        const pid = t.pid ? ` pid ${t.pid}` : '';
+        const started = t.startedAt ? ` since ${t.startedAt.slice(11, 19)}` : '';
+        const fails = t.failCount ? ` · ${t.failCount} fail${t.failCount === 1 ? '' : 's'}` : '';
+        process.stdout.write(`  ${mark} ${t.name.padEnd(16)}${pid}${started}${fails}\n        ${t.path}\n`);
+    }
+    process.stdout.write('\n');
+}
+async function cmdTrainsRestart(p, f) {
+    need(p, 1, 'metro trains restart <name>');
+    loadMetroEnv();
+    const resp = await ipcCall({ op: 'train-restart', name: p[0] });
+    if (!resp.ok)
+        throw new Error(resp.error);
+    emit(f, `restarted train '${p[0]}'`, { ok: true, name: p[0] });
+}
+/** dist/cli/webhook.js → <package-root>/examples/telegram.ts */
+const bundledExample = () => join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'examples', 'telegram.ts');
+async function cmdTrainsNew(p, f) {
+    need(p, 1, 'metro trains new <name>');
+    const name = p[0];
+    if (!/^[A-Za-z0-9_-]+$/.test(name))
+        throw exitErr(`bad train name '${name}' (use [A-Za-z0-9_-])`, 1);
+    const src = bundledExample();
+    if (!existsSync(src))
+        throw exitErr(`bundled example missing at ${src} (broken install?)`, 2);
+    mkdirSync(TRAINS_DIR, { recursive: true });
+    const dest = join(TRAINS_DIR, `${name}.ts`);
+    if (existsSync(dest))
+        throw exitErr(`train already exists: ${dest}`, 1);
+    copyFileSync(src, dest);
+    const metroPkg = join(homedir(), '.metro', 'package.json');
+    const pkgHint = existsSync(metroPkg) ? '' : '\n  (run `cd ~/.metro && bun init` first if your train needs deps)';
+    emit(f, `created ${dest}${pkgHint}\n  next: edit the file, then \`metro trains restart ${name}\``, { ok: true, path: dest, pkgInitialized: existsSync(metroPkg) });
+}

package/dist/{codex-rc.js → codex-rc/client.js}

@@ -1,30 +1,10 @@
-/**
- * JSON-RPC/WS client for codex app-server: each event → `turn/start` (Codex's Monitor equivalent).
- */
-import { createConnection } from 'node:net';
-import { WebSocket } from 'ws';
-import { errMsg, log } from './log.js';
+/** JSON-RPC/WS client for codex app-server: each event → `turn/start`. */
+import { errMsg, log } from '../log.js';
+import { buildTurnInput, encodeRpc, extractThreadStartedId, isStatusActive, openSocket, parseUrl, } from './protocol.js';
 const RECONNECT_DELAY_MS = 2_000;
 const MAX_QUEUE = 100;
 /** Backstop in case `turn/completed` never arrives — unstick the single-flight gate. */
 const TURN_TIMEOUT_MS = 120_000;
-/** Accept ws://, wss://, unix:///abs/path, or /abs/path (shorthand for unix). */
-function parseUrl(input) {
-    if (input.startsWith('ws://') || input.startsWith('wss://'))
-        return { kind: 'tcp', url: input };
-    if (input.startsWith('unix://'))
-        return { kind: 'unix', path: input.replace(/^unix:\/+/, '/') };
-    if (input.startsWith('/'))
-        return { kind: 'unix', path: input };
-    throw new Error(`unsupported METRO_CODEX_RC: ${input} (expected ws://, wss://, unix://, or abs path)`);
-}
-function openSocket(endpoint) {
-    if (endpoint.kind === 'tcp')
-        return new WebSocket(endpoint.url);
-    return new WebSocket('ws://localhost/', {
-        createConnection: () => createConnection({ path: endpoint.path }),
-    });
-}
 export class CodexRC {
     url;
     clientVersion;
@@ -115,9 +95,12 @@ export class CodexRC {
                 p.resolve(msg.result);
             return;
         }
+        this.handleNotification(msg);
+    }
+    handleNotification(msg) {
         switch (msg.method) {
             case 'thread/started': {
-                const id = msg.params?.thread?.id;
+                const id = extractThreadStartedId(msg.params);
                 if (id) {
                     this.setThreadId(id);
                     log.info({ thread: id }, 'codex-rc thread started');
@@ -126,12 +109,10 @@ export class CodexRC {
                 break;
             }
             case 'thread/status/changed': {
-                /* Codex 0.130+: status `{active}` means in-flight; anything else is idle. */
-                const p = msg.params;
-                if (p?.threadId !== this.threadId)
+                const s = isStatusActive(msg.params, this.threadId);
+                if (!s.match)
                     break;
-                const active = typeof p.status === 'object' && p.status !== null && 'active' in p.status;
-                if (active)
+                if (s.active)
                     this.turnInFlight = true;
                 else {
                     this.clearTurnTimeout();
@@ -203,8 +184,7 @@ export class CodexRC {
         this.turnInFlight = true;
         this.armTurnTimeout();
         try {
-            const input = [{ type: 'text', text: line, textElements: [] }];
-            await this.call('turn/start', { threadId: this.threadId, input });
+            await this.call('turn/start', { threadId: this.threadId, input: buildTurnInput(line) });
             this.queue.shift();
         }
         catch (err) {
@@ -239,7 +219,7 @@ export class CodexRC {
         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 }));
+            ws.send(encodeRpc(id, method, params));
         });
     }
 }

package/dist/codex-rc/protocol.js

@@ -0,0 +1,38 @@
+/** Codex JSON-RPC over WS: endpoint parsing, socket open, message encode/decode. */
+import { createConnection } from 'node:net';
+import { WebSocket } from 'ws';
+/** Accept ws://, wss://, unix:///abs/path, or /abs/path (shorthand for unix). */
+export function parseUrl(input) {
+    if (input.startsWith('ws://') || input.startsWith('wss://'))
+        return { kind: 'tcp', url: input };
+    if (input.startsWith('unix://'))
+        return { kind: 'unix', path: input.replace(/^unix:\/+/, '/') };
+    if (input.startsWith('/'))
+        return { kind: 'unix', path: input };
+    throw new Error(`unsupported METRO_CODEX_RC: ${input} (expected ws://, wss://, unix://, or abs path)`);
+}
+export function openSocket(endpoint) {
+    if (endpoint.kind === 'tcp')
+        return new WebSocket(endpoint.url);
+    return new WebSocket('ws://localhost/', {
+        createConnection: () => createConnection({ path: endpoint.path }),
+    });
+}
+export function encodeRpc(id, method, params) {
+    return JSON.stringify({ jsonrpc: '2.0', id, method, params });
+}
+/** Extract the active-thread state from a `thread/status/changed` params payload. */
+/** Codex 0.130+: `status: {active}` ⇒ in-flight; any other shape ⇒ idle. */
+export function isStatusActive(params, expectedThreadId) {
+    const p = params;
+    if (p?.threadId !== expectedThreadId)
+        return { match: false, active: false };
+    const active = typeof p.status === 'object' && p.status !== null && 'active' in p.status;
+    return { match: true, active };
+}
+export function extractThreadStartedId(params) {
+    return params?.thread?.id;
+}
+export function buildTurnInput(line) {
+    return [{ type: 'text', text: line, textElements: [] }];
+}