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

package/dist/dispatcher/server.js

@@ -0,0 +1,130 @@
+/** Dispatcher's plumbing: outbound event emission + train-envelope translation + HTTP receiver. */
+import { createHmac, randomUUID, timingSafeEqual } from 'node:crypto';
+import { createServer, } from 'node:http';
+import { Line } from '../lines.js';
+import { errMsg, log } from '../log.js';
+import { noteSeen } from '../paths.js';
+import { appendHistory, formatDisplay, mintId, noteUserFromLine, userSelf, } from '../history.js';
+import { handleMonitorRequest } from '../cli/tail.js';
+import { findEndpoint, listEndpoints, webhookPort } from '../tunnel.js';
+export function makeEmit(codexRc) {
+    return function emit(entry) {
+        /** `display` first so it survives Monitor's body truncation — the user must see it to echo it. */
+        const enriched = { display: formatDisplay(entry), ...entry };
+        const json = JSON.stringify(enriched);
+        process.stdout.write(json + '\n');
+        codexRc?.push(json);
+        noteSeen(entry.line, entry.lineName);
+        for (const l of [entry.line, entry.from, entry.to])
+            if (l)
+                noteUserFromLine(l);
+        appendHistory(enriched);
+    };
+}
+/** Translate the snake_case train wire envelope to a camelCase `HistoryEntry`. */
+/** Trains can omit `id`/`station`/`to`; metro fills sensible defaults. */
+/** Forgive trains that use platform-flavored kinds (`message`, `reaction`) — map to the canonical enum. */
+function normalizeKind(k) {
+    if (k === 'message' || k === undefined || k === null)
+        return 'inbound';
+    if (k === 'reaction')
+        return 'react';
+    return k;
+}
+export function trainEventToHistoryEntry(env, trainName) {
+    const line = env.line;
+    if (typeof line !== 'string') {
+        log.warn({ train: trainName }, 'train: dropped event without `line`');
+        return null;
+    }
+    const station = env.station ?? Line.station(line) ?? trainName;
+    const isPrivate = env.is_private === true;
+    return {
+        id: env.id ?? mintId(),
+        ts: env.ts ?? new Date().toISOString(),
+        kind: normalizeKind(env.kind),
+        station,
+        line: line,
+        lineName: env.line_name,
+        from: (env.from ?? `metro://${station}`),
+        fromName: env.from_name,
+        to: (env.to ?? (isPrivate ? userSelf() : line)),
+        text: env.text,
+        emoji: env.emoji,
+        messageId: env.message_id,
+        replyTo: env.reply_to,
+        payload: env.payload,
+    };
+}
+export async function startWebhookServer(emit) {
+    const port = webhookPort();
+    const server = createServer((req, res) => {
+        handleRequest(req, res, emit).catch(err => {
+            log.warn({ err: errMsg(err) }, 'webhook handler error');
+            if (!res.headersSent)
+                res.writeHead(500).end();
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', () => {
+            log.info({ port, endpoints: listEndpoints().length }, 'webhook + monitor ready');
+            resolve();
+        });
+    });
+    return server;
+}
+async function handleRequest(req, res, emit) {
+    if (handleMonitorRequest(req, res))
+        return;
+    const m = req.url?.match(/^\/wh\/([A-Za-z0-9_-]+)/);
+    if (!m) {
+        res.writeHead(404).end();
+        return;
+    }
+    const endpointId = m[1];
+    const endpoint = findEndpoint(endpointId);
+    if (!endpoint) {
+        res.writeHead(404).end();
+        return;
+    }
+    if (req.method === 'GET') {
+        res.writeHead(200).end(`metro webhook ${endpointId} ready\n`);
+        return;
+    }
+    if (req.method !== 'POST') {
+        res.writeHead(405).end();
+        return;
+    }
+    const chunks = [];
+    for await (const c of req)
+        chunks.push(c);
+    const raw = Buffer.concat(chunks);
+    const headers = Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(',') : v ?? '']));
+    if (endpoint.secret && !verifySig(endpoint.secret, raw, headers['x-hub-signature-256'])) {
+        log.warn({ endpoint: endpointId }, 'webhook signature mismatch — rejecting');
+        res.writeHead(401).end('signature mismatch');
+        return;
+    }
+    let body = raw.toString('utf8');
+    try {
+        body = JSON.parse(body);
+    }
+    catch { /* keep as string */ }
+    const line = Line.webhook(endpointId);
+    emit({
+        id: mintId(), ts: new Date().toISOString(), kind: 'inbound', station: 'webhook',
+        line, lineName: endpoint.label, from: line, to: line,
+        messageId: headers['x-github-delivery'] || headers['x-request-id'] || randomUUID(),
+        text: `${headers['x-github-event'] ?? headers['x-intercom-topic'] ?? 'event'} ${req.method} ${req.url}`,
+        payload: { headers, body },
+    });
+    res.writeHead(200).end('ok');
+}
+function verifySig(secret, raw, header) {
+    if (!header?.startsWith('sha256='))
+        return false;
+    const given = Buffer.from(header.slice(7), 'hex');
+    const want = createHmac('sha256', secret).update(raw).digest();
+    return given.length === want.length && timingSafeEqual(given, want);
+}

package/dist/dispatcher.js

@@ -1,43 +1,26 @@
-/**
- * Daemon: chat inbound → JSON on stdout; optional codex-rc push; cross-user `notify` over Unix socket.
- */
-import { copyFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+/** Daemon: supervises ~/.metro/trains/*, multiplexes their stdout to one JSON event stream, */
+/** routes outbound `forward-call` IPC back to trains' stdin. Two builtin event sources stay */
+/** in core: the HTTP webhook receiver + cross-user `notify` IPC. */
+import { join } from 'node:path';
 import pkg from '../package.json' with { type: 'json' };
-import { DiscordStation } from './stations/discord.js';
-import { TelegramStation } from './stations/telegram.js';
-import { WebhookStation } from './stations/webhook.js';
-import { asLine, Line } from './stations/index.js';
-import { CodexRC } from './codex-rc.js';
+import { Line } from './lines.js';
+import { CodexRC } from './codex-rc/client.js';
 import { startIpcServer, stopIpcServer } from './ipc.js';
-import { userSelf, appendHistory, formatDisplay, mintId, selfLine } from './history.js';
-import { noteSeen, saveBotId } from './cache.js';
+import { mintId, noteUserFromLine, selfLine, userSelf } from './history.js';
 import { errMsg, log } from './log.js';
-import { acquireLock, configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
-import { setCodexSessionId } from './stations/codex.js';
-import { noteUserFromLine } from './registry.js';
-import { listEndpoints, webhookPort } from './webhooks.js';
-import { loadTunnelConfig, Tunnel } from './tunnel.js';
+import { acquireLock, loadMetroEnv, STATE_DIR } from './paths.js';
+import { setCodexSessionId } from './local-identity.js';
+import { loadTunnelConfig, Tunnel, webhookPort } from './tunnel.js';
+import { TrainSupervisor, TRAINS_DIR } from './trains/supervisor.js';
+import { makeEmit, startWebhookServer, trainEventToHistoryEntry } from './dispatcher/server.js';
 loadMetroEnv();
-const platforms = configuredPlatforms();
-const endpoints = listEndpoints();
-requireConfiguredPlatform(platforms, endpoints.length > 0);
 acquireLock(join(STATE_DIR, '.tail-lock'));
-// Fail fast if launched from Claude Code without a logged-in account.
 const self = userSelf();
 log.info({ self, line: selfLine() }, 'user identity');
 const seedSelf = () => { const l = selfLine(); if (l)
     noteUserFromLine(l); };
 seedSelf();
-const USERS_MD = join(STATE_DIR, 'USERS.md');
-try {
-    copyFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'docs', 'users.md'), USERS_MD);
-}
-catch (err) {
-    log.warn({ err: errMsg(err), path: USERS_MD }, 'failed to install user skill');
-}
-/** Suppress EPIPE so the daemon survives the user (Monitor reader) restarting / dying. */
+/** Suppress EPIPE so the daemon survives the reader (Monitor) restarting. */
 process.stdout.on('error', err => {
     if (err.code !== 'EPIPE')
         log.warn({ err: errMsg(err) }, 'stdout error');
@@ -45,66 +28,54 @@ process.stdout.on('error', err => {
 const codexRc = process.env.METRO_CODEX_RC ? new CodexRC(process.env.METRO_CODEX_RC, pkg.version) : null;
 codexRc?.onThread(id => { setCodexSessionId(id); seedSelf(); });
 codexRc?.start();
-const discord = new DiscordStation();
-const telegram = new TelegramStation();
-const webhook = new WebhookStation();
+const supervisor = new TrainSupervisor();
+const emit = makeEmit(codexRc);
+supervisor.onTrainEvent((env, train) => {
+    const entry = trainEventToHistoryEntry(env, train);
+    if (entry)
+        emit(entry);
+});
+let webhookServer = null;
 const tunnelCfg = loadTunnelConfig();
 const tunnel = tunnelCfg ? new Tunnel(tunnelCfg, webhookPort()) : null;
-function emit(entry) {
-    /** `display` first so it survives Monitor's ~500-char body truncation — the user must see it to echo it. */
-    const enriched = { display: formatDisplay(entry), ...entry };
-    const json = JSON.stringify(enriched);
-    process.stdout.write(json + '\n');
-    codexRc?.push(json);
-    noteSeen(entry.line, entry.lineName);
-    for (const l of [entry.line, entry.from, entry.to])
-        if (l)
-            noteUserFromLine(l);
-    appendHistory(enriched);
-}
-const destinationFor = (m) => m.isPrivate ? userSelf() : m.line;
-const onInbound = (m) => emit({ ...m, kind: 'inbound', to: destinationFor(m) });
-const onReaction = (r) => emit({ ...r, kind: 'react', to: destinationFor(r) });
 const ipc = startIpcServer(async (req) => {
     if (req.op === 'notify') {
-        const line = asLine(req.line);
+        const line = req.line;
         emit({
             id: mintId(), ts: new Date().toISOString(), kind: 'inbound',
             station: Line.station(line) ?? '?', line,
-            from: req.from ? asLine(req.from) : userSelf(), to: line, text: req.text,
+            from: (req.from ?? userSelf()), to: line, text: req.text,
         });
         return { ok: true };
     }
-    if (req.op === 'download') {
-        const line = asLine(req.line);
-        const station = req.line.startsWith('metro://telegram/') ? telegram : discord;
-        const files = await station.download(line, req.messageId, req.outDir);
-        return { ok: true, files };
+    if (req.op === 'forward-call') {
+        try {
+            const r = await supervisor.call(req.train, req.action, req.args);
+            return { ok: true, response: r };
+        }
+        catch (err) {
+            return { ok: false, error: errMsg(err) };
+        }
     }
-    return { ok: false, error: 'unknown op' };
-});
-async function main() {
-    if (platforms.discord) {
-        discord.onMessage(onInbound);
-        discord.onReaction(onReaction);
-        const [, me] = await Promise.all([discord.start(), discord.getMe()]);
-        saveBotId('discord', me.id);
-        log.info({ bot: me.username }, 'discord ready');
-    }
-    if (platforms.telegram) {
-        telegram.onMessage(onInbound);
-        telegram.onReaction(onReaction);
-        const [me] = await Promise.all([telegram.getMe(), telegram.start()]);
-        saveBotId('telegram', String(me.id));
-        log.info({ bot: `@${me.username}` }, 'telegram ready');
+    if (req.op === 'trains-list') {
+        return { ok: true, trains: supervisor.list() };
     }
-    /** Start the HTTP receiver only when ≥1 endpoint is registered — no point binding a port nobody listens to. */
-    if (endpoints.length) {
-        webhook.onMessage(onInbound);
-        await webhook.start();
-        tunnel?.start();
+    if (req.op === 'train-restart') {
+        try {
+            await supervisor.restart(req.name);
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: errMsg(err) };
+        }
     }
-    log.info({ codexRc: !!codexRc, tunnel: !!tunnel }, 'dispatcher ready');
+    return { ok: false, error: `unknown op: ${req.op ?? '(none)'}` };
+});
+async function main() {
+    supervisor.start();
+    webhookServer = await startWebhookServer(emit);
+    tunnel?.start();
+    log.info({ codexRc: !!codexRc, tunnel: !!tunnel, trainsDir: TRAINS_DIR }, 'dispatcher ready');
 }
 let shuttingDown = false;
 async function shutdown() {
@@ -115,11 +86,9 @@ async function shutdown() {
     codexRc?.stop();
     tunnel?.stop();
     await stopIpcServer(ipc).catch(() => { });
-    await webhook.stop().catch(() => { });
-    if (platforms.discord)
-        await discord.stop().catch(() => { });
-    if (platforms.telegram)
-        await telegram.stop().catch(() => { });
+    if (webhookServer)
+        await new Promise(r => webhookServer.close(() => r()));
+    await supervisor.stop();
     process.exit(0);
 }
 process.stdin.on('end', shutdown).on('close', shutdown);

package/dist/history.js

@@ -1,12 +1,11 @@
 /** Append-only JSONL history of every message that flows through metro (inbound + outbound). */
 import { randomBytes } from 'node:crypto';
-import { appendFileSync, existsSync, readFileSync } from 'node:fs';
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { errMsg, log } from './log.js';
 import { STATE_DIR } from './paths.js';
-import { Line } from './stations/index.js';
-import { claudeUserId, claudeSessionId } from './stations/claude.js';
-import { codexUserId, codexSessionId } from './stations/codex.js';
+import { Line } from './lines.js';
+import { claudeUserId, claudeSessionId, codexUserId, codexSessionId } from './local-identity.js';
 /** Pre-render a chat-bubble line — the user echoes `event.display` verbatim instead of composing markdown itself. */
 export function formatDisplay(e) {
     const headerFor = (icon, parts) => `**${icon} ${parts.filter(Boolean).join(' · ')}**`;
@@ -82,20 +81,6 @@ function matches(e, f) {
         return false;
     return true;
 }
-/** Find an entry by universal id OR platform message id. */
-export function lookupEntry(id) {
-    const entries = readHistory({ limit: 5_000 });
-    return entries.find(e => e.id === id || e.messageId === id);
-}
-/** Look up the platform messageId for a universal `msg_*` id; returns the input unchanged otherwise. */
-export function resolvePlatformId(id) {
-    if (!id.startsWith('msg_'))
-        return id;
-    const hit = lookupEntry(id);
-    if (hit?.messageId)
-        return hit.messageId;
-    throw new Error(`unknown universal id: ${id} (run \`metro history --limit=50\` to see recent ids)`);
-}
 /** The current user's **participant** URI for `from`/`to`. Precedence: METRO_FROM > runtime env > generic. */
 export function userSelf() {
     const explicit = process.env.METRO_FROM;
@@ -119,3 +104,43 @@ export function selfLine() {
     }
     return null;
 }
+/* ──────────── user-registry: append-only (station, userId, sessions[]) tuples ──────────── */
+const REGISTRY_FILE = join(STATE_DIR, 'user-registry.json');
+function readRegistry() {
+    if (!existsSync(REGISTRY_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err) }, 'user-registry: malformed, resetting');
+        return {};
+    }
+}
+function record(station, userId, sessionId) {
+    const reg = readRegistry();
+    const rows = (reg[station] ??= []);
+    let row = rows.find(r => r.userId === userId);
+    if (!row) {
+        row = { userId, sessions: [], lastSeen: '' };
+        rows.push(row);
+    }
+    if (sessionId && !row.sessions.includes(sessionId))
+        row.sessions.push(sessionId);
+    row.lastSeen = new Date().toISOString();
+    try {
+        writeFileSync(REGISTRY_FILE, JSON.stringify(reg, null, 2));
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err) }, 'user-registry: write failed');
+    }
+}
+/** Scan a line URI for `(station, userId, sessionId)` and record it. No-op on non-user or participant URIs. */
+export function noteUserFromLine(line) {
+    const station = Line.station(line);
+    if (station !== 'claude' && station !== 'codex')
+        return;
+    const p = station === 'claude' ? Line.parseClaude(line) : Line.parseCodex(line);
+    if (p)
+        record(station, p.userId, p.sessionId);
+}

package/dist/ipc.js

@@ -1,4 +1,5 @@
-/** Unix-socket IPC: `notify` re-emits on daemon stdout; `download` resolves Telegram attachments. */
+/** Unix-socket IPC: `notify` re-emits a cross-user message, `forward-call` reaches a train's */
+/** stdin and awaits its response, `trains-list` snapshots supervisor state. */
 import { createConnection, createServer } from 'node:net';
 import { existsSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
@@ -27,24 +28,31 @@ export async function stopIpcServer(server) {
     catch { /* ignore */ }
 }
 async function handleConnection(socket, handler) {
+    /** Newline-delimited request/response. Avoids races between `end()` writes and FIN under Bun. */
     let buf = '';
     socket.setEncoding('utf8');
-    socket.on('data', chunk => { buf += chunk; });
-    socket.on('end', async () => {
+    socket.on('data', async (chunk) => {
+        buf += chunk;
+        const nl = buf.indexOf('\n');
+        if (nl === -1)
+            return;
+        const line = buf.slice(0, nl).trim();
+        buf = buf.slice(nl + 1);
         let resp;
         try {
-            const req = JSON.parse(buf.trim());
+            const req = JSON.parse(line);
             resp = await handler(req);
         }
         catch (err) {
             resp = { ok: false, error: errMsg(err) };
         }
-        socket.end(JSON.stringify(resp) + '\n');
+        socket.write(JSON.stringify(resp) + '\n');
+        socket.end();
     });
     socket.on('error', err => log.debug({ err: errMsg(err) }, 'ipc connection error'));
 }
 /** CLI-side: send one request, get one response. Throws if the daemon isn't running. */
-export function ipcCall(req, timeoutMs = 30_000) {
+export function ipcCall(req, timeoutMs = 60_000) {
     return new Promise((resolve, reject) => {
         if (!existsSync(SOCKET_PATH)) {
             reject(new Error('metro daemon is not running (start it with `metro`)'));
@@ -56,17 +64,27 @@ export function ipcCall(req, timeoutMs = 30_000) {
             socket.destroy();
             reject(new Error(`ipc timeout after ${timeoutMs}ms`));
         }, timeoutMs);
-        socket.on('connect', () => { socket.end(JSON.stringify(req)); });
-        socket.on('data', chunk => { buf += chunk.toString('utf8'); });
-        socket.on('end', () => {
+        socket.on('connect', () => { socket.write(JSON.stringify(req) + '\n'); });
+        socket.on('data', chunk => {
+            buf += chunk.toString('utf8');
+            const nl = buf.indexOf('\n');
+            if (nl === -1)
+                return;
             clearTimeout(timer);
+            const line = buf.slice(0, nl).trim();
+            socket.end();
             try {
-                resolve(JSON.parse(buf.trim()));
+                resolve(JSON.parse(line));
             }
             catch (err) {
                 reject(new Error(`ipc bad response: ${errMsg(err)}`));
             }
         });
+        socket.on('end', () => {
+            clearTimeout(timer);
+            if (!buf)
+                reject(new Error('ipc connection closed without response'));
+        });
         socket.on('error', err => { clearTimeout(timer); reject(err); });
     });
 }

package/dist/lines.js

@@ -0,0 +1,54 @@
+/** Line URI helpers. The whole metro:// vocabulary. */
+export const asLine = (s) => s;
+const PREFIX = 'metro://';
+const build = (station, ...seg) => asLine(`${PREFIX}${station}/${seg.map(String).join('/')}`);
+/** Shared parser for `metro://{claude,codex}/<userId>/<sessionId>`. Skips the `/user/…` participant URI. */
+function parseLocalSession(line, station) {
+    const p = Line.parse(line);
+    if (p?.station !== station || p.path[0] === 'user' || p.path.length < 2)
+        return null;
+    return { userId: p.path[0], sessionId: p.path[1] };
+}
+/** URI helpers. Lives on a const that doubles as the `Line` type's value-side namespace. */
+export const Line = {
+    discord: (channelId) => build('discord', channelId),
+    telegram: (chatId, topicId) => topicId !== undefined ? build('telegram', chatId, topicId) : build('telegram', chatId),
+    claude: (orgId, sessionId) => build('claude', orgId, sessionId),
+    codex: (accountId, threadId) => build('codex', accountId, threadId),
+    webhook: (endpointId) => build('webhook', endpointId),
+    /** Participant URI — `metro://<station>/user/<id>`. */
+    user: (station, id) => build(station, 'user', id),
+    parse(line) {
+        if (!line.startsWith(PREFIX))
+            return null;
+        const rest = line.slice(PREFIX.length);
+        const slash = rest.indexOf('/');
+        if (slash <= 0)
+            return null;
+        const path = rest.slice(slash + 1).split('/').filter(Boolean);
+        return path.length ? { station: rest.slice(0, slash), path } : null;
+    },
+    station: (line) => Line.parse(line)?.station ?? null,
+    parseTelegram(line) {
+        const p = Line.parse(line);
+        if (p?.station !== 'telegram')
+            return null;
+        const chatId = Number(p.path[0]);
+        if (!Number.isFinite(chatId))
+            return null;
+        if (p.path.length === 1)
+            return { chatId };
+        const topicId = Number(p.path[1]);
+        return Number.isFinite(topicId) ? { chatId, topicId } : null;
+    },
+    parseClaude: (line) => parseLocalSession(line, 'claude'),
+    parseCodex: (line) => parseLocalSession(line, 'codex'),
+    parseWebhook(line) {
+        const p = Line.parse(line);
+        return p?.station === 'webhook' && p.path.length === 1 ? p.path[0] : null;
+    },
+    isLocal: (line) => {
+        const s = Line.station(line);
+        return s === 'claude' || s === 'codex';
+    },
+};

package/dist/local-identity.js

@@ -0,0 +1,80 @@
+/** Resolve the local user identity for Claude Code / Codex hosts — used to mint */
+/** `metro://claude/<orgId>/<sessionId>` and `metro://codex/<accountId>/<threadId>` URIs. */
+import { execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { STATE_DIR } from './paths.js';
+const TTL_MS = 5_000;
+/** Memoize an account-id resolver for TTL_MS to avoid hammering `claude auth` / re-reading auth.json. */
+function memo(loader) {
+    let cache = null;
+    return () => {
+        if (cache && Date.now() - cache.at < TTL_MS)
+            return cache.id;
+        const id = loader();
+        cache = { id, at: Date.now() };
+        return id;
+    };
+}
+const claudeAccountId = memo(() => {
+    let raw;
+    try {
+        raw = execFileSync('claude', ['auth', 'status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    catch (e) {
+        throw new Error(`metro: failed to run 'claude auth status --json' — is Claude Code installed? (${e.message})`);
+    }
+    let p;
+    try {
+        p = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`metro: 'claude auth status --json' returned non-JSON: ${raw.slice(0, 200)}`);
+    }
+    if (!p.loggedIn || !p.orgId)
+        throw new Error('metro: Claude Code is not logged in — run \'claude auth login\'');
+    return p.orgId;
+});
+const codexAccountId = memo(() => {
+    const path = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'auth.json');
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (e) {
+        throw new Error(`metro: failed to read ${path} — is Codex logged in? (${e.message})`);
+    }
+    let p;
+    try {
+        p = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`metro: ${path} is not valid JSON`);
+    }
+    const id = p.tokens?.account_id;
+    if (!id)
+        throw new Error(`metro: no Codex account_id in ${path} (auth_mode=${p.auth_mode ?? 'unknown'}) — sign in with 'codex login' (ChatGPT mode required)`);
+    return id;
+});
+export const claudeUserId = () => process.env.METRO_USER_ID || claudeAccountId();
+export const codexUserId = () => process.env.METRO_USER_ID || codexAccountId();
+export const claudeSessionId = () => process.env.METRO_USER_SESSION_ID || process.env.CLAUDE_CODE_SESSION_ID || null;
+const CODEX_SESSION_FILE = join(STATE_DIR, 'codex-session-id');
+export function codexSessionId() {
+    if (process.env.METRO_USER_SESSION_ID)
+        return process.env.METRO_USER_SESSION_ID;
+    try {
+        return readFileSync(CODEX_SESSION_FILE, 'utf8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function setCodexSessionId(threadId) {
+    try {
+        mkdirSync(dirname(CODEX_SESSION_FILE), { recursive: true });
+        writeFileSync(CODEX_SESSION_FILE, threadId ?? '');
+    }
+    catch { /* CLI just won't have a session segment */ }
+}