codex-claude-relay 0.1.0

package/dist/providers/codex.js

@@ -0,0 +1,310 @@
+import { readdir, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, sep } from 'node:path';
+import { parseJsonl, peekJsonl, clip } from '../parse/jsonl.js';
+export const CODEX_SESSIONS_DIR = join(homedir(), '.codex', 'sessions');
+/** Recursively collect `rollout-*.jsonl` files under `dir`. */
+async function collectRollouts(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = (await readdir(dir, { withFileTypes: true }));
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const full = join(dir, e.name);
+        if (e.isDirectory()) {
+            const nested = await collectRollouts(full);
+            out.push(...nested);
+        }
+        else if (e.isFile() && e.name.startsWith('rollout-') && e.name.endsWith('.jsonl')) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+/** Read the first object of a rollout JSONL to extract the recorded cwd. */
+async function readCodexMeta(path) {
+    try {
+        const head = await peekJsonl(path, 1);
+        const first = head[0];
+        if (!first || first.type !== 'session_meta')
+            return { cwd: null, ts: null };
+        const payload = first.payload;
+        const cwd = typeof payload?.cwd === 'string' ? payload.cwd : null;
+        const ts = typeof payload?.timestamp === 'string' ? payload.timestamp : null;
+        return { cwd, ts };
+    }
+    catch {
+        return { cwd: null, ts: null };
+    }
+}
+/**
+ * Discover Codex rollout files and rank them by relevance to the current git
+ * context. Returns the candidates sorted best-first.
+ */
+export async function discoverCodexSessions(git) {
+    if (!existsSync(CODEX_SESSIONS_DIR))
+        return [];
+    const paths = await collectRollouts(CODEX_SESSIONS_DIR);
+    const candidates = [];
+    for (const p of paths) {
+        let mtimeMs = 0;
+        try {
+            const st = await stat(p);
+            mtimeMs = st.mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        const meta = await readCodexMeta(p);
+        const reasons = [];
+        let score = 0;
+        if (meta.cwd) {
+            if (meta.cwd === git.root) {
+                score += 60;
+                reasons.push('cwd matches git root exactly');
+            }
+            else if (git.inRepo && meta.cwd.startsWith(git.root + sep)) {
+                score += 50;
+                reasons.push('cwd inside git root');
+            }
+            else if (meta.cwd.includes(git.repoName)) {
+                score += 25;
+                reasons.push(`cwd path mentions repo name "${git.repoName}"`);
+            }
+        }
+        // Recency weight: linear decay over 14 days, max 30 points.
+        const ageDays = (Date.now() - mtimeMs) / (24 * 3600 * 1000);
+        const recency = Math.max(0, 30 * (1 - ageDays / 14));
+        score += recency;
+        reasons.push(`recency +${recency.toFixed(1)} (age ${ageDays.toFixed(1)}d)`);
+        candidates.push({
+            path: p,
+            mtimeMs,
+            recordedCwd: meta.cwd,
+            score,
+            reasons,
+        });
+    }
+    candidates.sort((a, b) => b.score - a.score || b.mtimeMs - a.mtimeMs);
+    return candidates;
+}
+/** Pick the best Codex session. With `forceLast`, always pick the most recent by mtime. */
+export async function pickCodexSession(git, forceLast) {
+    const all = await discoverCodexSessions(git);
+    if (all.length === 0)
+        return null;
+    if (forceLast) {
+        return [...all].sort((a, b) => b.mtimeMs - a.mtimeMs)[0];
+    }
+    return all[0];
+}
+/* ----------------------------- parsing --------------------------------- */
+function asString(v) {
+    if (typeof v === 'string')
+        return v;
+    if (v == null)
+        return '';
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+/** Extract text out of Codex's `content` array on message payloads. */
+function extractMessageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const c of content) {
+        if (!c || typeof c !== 'object')
+            continue;
+        const obj = c;
+        if (typeof obj.text === 'string')
+            parts.push(obj.text);
+        else if (typeof obj.content === 'string')
+            parts.push(obj.content);
+    }
+    return parts.join('\n').trim();
+}
+/** Heuristically pull file paths and a shell command out of a Codex function_call. */
+function describeFunctionCall(payload) {
+    const name = asString(payload.name || 'tool');
+    const rawArgs = payload.arguments;
+    let args = {};
+    if (typeof rawArgs === 'string') {
+        try {
+            args = JSON.parse(rawArgs);
+        }
+        catch {
+            // Some function calls embed plain text — that's fine.
+        }
+    }
+    else if (rawArgs && typeof rawArgs === 'object') {
+        args = rawArgs;
+    }
+    let command;
+    const files = [];
+    // Common Codex tools.
+    if (typeof args.cmd === 'string')
+        command = args.cmd;
+    else if (typeof args.command === 'string')
+        command = args.command;
+    else if (Array.isArray(args.command))
+        command = args.command.join(' ');
+    // File-shaped args
+    for (const key of ['path', 'file', 'filename', 'target']) {
+        const v = args[key];
+        if (typeof v === 'string')
+            files.push(v);
+    }
+    if (Array.isArray(args.paths)) {
+        for (const v of args.paths) {
+            if (typeof v === 'string')
+                files.push(v);
+        }
+    }
+    // apply_patch — try to extract touched paths from a unified-diff-ish input.
+    if (name === 'apply_patch' && typeof args.input === 'string') {
+        const re = /^(?:\*\*\* (?:Update|Add|Delete) File: |\+\+\+ b\/|--- a\/)(.+)$/gm;
+        let m;
+        while ((m = re.exec(args.input)) !== null) {
+            const p = m[1]?.trim();
+            if (p)
+                files.push(p);
+        }
+    }
+    let text = `${name}`;
+    if (command)
+        text += ` $ ${clip(command, 200)}`;
+    if (files.length > 0)
+        text += ` [${files.slice(0, 6).join(', ')}]`;
+    return { text, command, files: files.length ? files : undefined, toolName: name };
+}
+/** Compact a function_call_output payload for the summary. */
+function describeFunctionCallOutput(payload) {
+    const raw = asString(payload.output ?? payload.content ?? '');
+    // Strip Codex's wrapper prefix lines like "Chunk ID:", "Wall time:", etc.
+    const stripped = raw
+        .replace(/^Chunk ID:.*$/gm, '')
+        .replace(/^Wall time:.*$/gm, '')
+        .replace(/^Original token count:.*$/gm, '')
+        .replace(/^Output:\s*/m, '')
+        .trim();
+    const isError = /Process exited with code (?!0)\d+/.test(raw) ||
+        /\bError\b/i.test(stripped.slice(0, 200));
+    return { text: clip(stripped, 400), isError };
+}
+/** Parse a full Codex rollout JSONL into normalized events. */
+export async function parseCodexSession(path) {
+    const events = [];
+    let recordedCwd = null;
+    let sessionId = null;
+    let startedAtMs = null;
+    let endedAtMs = null;
+    const { skipped, records } = await parseJsonl(path, (obj, lineNo) => {
+        if (!obj || typeof obj !== 'object')
+            return null;
+        const rec = obj;
+        const tsStr = typeof rec.timestamp === 'string' ? rec.timestamp : null;
+        const tsMs = tsStr ? Date.parse(tsStr) : NaN;
+        const ts = Number.isFinite(tsMs) ? tsMs : null;
+        if (ts !== null) {
+            if (startedAtMs === null || ts < startedAtMs)
+                startedAtMs = ts;
+            if (endedAtMs === null || ts > endedAtMs)
+                endedAtMs = ts;
+        }
+        const type = rec.type;
+        const payload = (rec.payload ?? {});
+        if (type === 'session_meta') {
+            if (typeof payload.cwd === 'string')
+                recordedCwd = payload.cwd;
+            if (typeof payload.id === 'string')
+                sessionId = payload.id;
+            return null;
+        }
+        if (type === 'response_item') {
+            const pt = payload.type;
+            if (pt === 'message') {
+                const role = payload.role;
+                const text = extractMessageText(payload.content);
+                if (!text)
+                    return null;
+                if (role === 'user') {
+                    // Skip environment_context noise.
+                    if (/^<environment_context>/m.test(text))
+                        return null;
+                    const ev = {
+                        lineNo,
+                        timestampMs: ts,
+                        kind: 'user_message',
+                        text,
+                    };
+                    return ev;
+                }
+                if (role === 'assistant') {
+                    const ev = {
+                        lineNo,
+                        timestampMs: ts,
+                        kind: 'assistant_message',
+                        text,
+                    };
+                    return ev;
+                }
+                if (role === 'developer' || role === 'system') {
+                    return null; // not useful in the handoff
+                }
+            }
+            if (pt === 'reasoning') {
+                // We intentionally skip Codex internal reasoning — too noisy & private.
+                return null;
+            }
+            if (pt === 'function_call') {
+                const d = describeFunctionCall(payload);
+                const ev = {
+                    lineNo,
+                    timestampMs: ts,
+                    kind: 'tool_call',
+                    text: d.text,
+                    toolName: d.toolName,
+                    command: d.command,
+                    files: d.files,
+                };
+                return ev;
+            }
+            if (pt === 'function_call_output') {
+                const d = describeFunctionCallOutput(payload);
+                const ev = {
+                    lineNo,
+                    timestampMs: ts,
+                    kind: 'tool_result',
+                    text: d.text,
+                    isError: d.isError,
+                };
+                return ev;
+            }
+        }
+        // event_msg / turn_context / token_count / etc. — ignore for the handoff.
+        return null;
+    });
+    events.push(...records);
+    return {
+        path,
+        recordedCwd,
+        recordedBranch: null,
+        sessionId,
+        startedAtMs,
+        endedAtMs,
+        parsedLines: events.length,
+        skippedLines: skipped,
+        events,
+    };
+}

package/dist/redact.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Best-effort secret redaction for handoff prompts.
+ *
+ * This is intentionally conservative: it should never block real content from
+ * being passed along, but it must catch the most common leak shapes. Users who
+ * need stronger guarantees can pipe `relay preview` through their own scrubber
+ * or run with `--no-redact` only when they trust the transcript.
+ */
+/** Redact secrets in a string. Returns the (possibly identical) result. */
+export declare function redact(input: string): string;

package/dist/redact.js

@@ -0,0 +1,84 @@
+/**
+ * Best-effort secret redaction for handoff prompts.
+ *
+ * This is intentionally conservative: it should never block real content from
+ * being passed along, but it must catch the most common leak shapes. Users who
+ * need stronger guarantees can pipe `relay preview` through their own scrubber
+ * or run with `--no-redact` only when they trust the transcript.
+ */
+function shortKeep(m) {
+    if (m.length <= 8)
+        return '[REDACTED]';
+    return `${m.slice(0, 4)}…${m.slice(-2)}[REDACTED]`;
+}
+const RULES = [
+    // Authorization headers (Bearer / Basic / opaque token)
+    {
+        name: 'auth-header',
+        pattern: /\b(Authorization\s*[:=]\s*)(Bearer\s+|Basic\s+)?([A-Za-z0-9._\-+/=]{8,})/gi,
+        replacer: (_m, prefix, scheme = '') => `${prefix}${scheme}[REDACTED]`,
+    },
+    // OpenAI-style keys
+    {
+        name: 'openai-key',
+        pattern: /\bsk-(?:proj-|live-|test-)?[A-Za-z0-9_\-]{16,}\b/g,
+        replacer: () => 'sk-[REDACTED]',
+    },
+    // Anthropic keys
+    {
+        name: 'anthropic-key',
+        pattern: /\bsk-ant-[A-Za-z0-9_\-]{16,}\b/g,
+        replacer: () => 'sk-ant-[REDACTED]',
+    },
+    // GitHub tokens
+    {
+        name: 'github-token',
+        pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+        replacer: () => 'gh_[REDACTED]',
+    },
+    // AWS access key id
+    {
+        name: 'aws-access-key',
+        pattern: /\bAKIA[0-9A-Z]{12,}\b/g,
+        replacer: () => 'AKIA[REDACTED]',
+    },
+    // Google API key
+    {
+        name: 'google-api-key',
+        pattern: /\bAIza[0-9A-Za-z_\-]{20,}\b/g,
+        replacer: () => 'AIza[REDACTED]',
+    },
+    // JWT (three base64url segments separated by dots)
+    {
+        name: 'jwt',
+        pattern: /\beyJ[A-Za-z0-9_\-]{6,}\.[A-Za-z0-9_\-]{6,}\.[A-Za-z0-9_\-]{6,}\b/g,
+        replacer: () => 'eyJ[REDACTED-JWT]',
+    },
+    // PEM private keys (multi-line)
+    {
+        name: 'pem-private-key',
+        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----/g,
+        replacer: () => '[REDACTED-PRIVATE-KEY]',
+    },
+    // KEY=VALUE env-var-style secrets. The name must *contain* one of the
+    // secret tokens as a substring, anywhere in the identifier.
+    {
+        name: 'env-secret',
+        pattern: /\b([A-Z][A-Z0-9_]*(?:SECRET|TOKEN|PASSWORD|PASSWD|API[_-]?KEY|APIKEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY|CLIENT[_-]?SECRET|CREDENTIAL)[A-Z0-9_]*)(\s*[=:]\s*)(["']?)([^\s"']{6,})(\3)/g,
+        replacer: (_m, name, sep, q, value) => `${name}${sep}${q}${shortKeep(value)}${q}`,
+    },
+    // Set-Cookie headers
+    {
+        name: 'set-cookie',
+        pattern: /\b(Set-Cookie:\s*[^=]+=)([^\s;]+)/gi,
+        replacer: (_m, prefix) => `${prefix}[REDACTED]`,
+    },
+];
+/** Redact secrets in a string. Returns the (possibly identical) result. */
+export function redact(input) {
+    let out = input;
+    for (const rule of RULES) {
+        out = out.replace(rule.pattern, rule.replacer);
+    }
+    return out;
+}

package/dist/summarize.d.ts

@@ -0,0 +1,13 @@
+import type { AgentName, GitContext, HandoffContent, ParsedSession, RelayOptions } from './types.js';
+export interface RenderInput {
+    sourceAgent: AgentName;
+    targetAgent: AgentName;
+    git: GitContext;
+    session: ParsedSession;
+    /** Optional extra memory blob (Claude project memory). */
+    memorySummary?: string | null;
+    /** Optional current `git diff` blob to append. */
+    diff?: string | null;
+    options: RelayOptions;
+}
+export declare function renderHandoff(input: RenderInput): HandoffContent;

package/dist/summarize.js

@@ -0,0 +1,241 @@
+import { clip } from './parse/jsonl.js';
+import { redact } from './redact.js';
+const STALE_MS = 24 * 60 * 60 * 1000;
+/** Pull a compact digest out of a parsed session. */
+function digest(session) {
+    const out = {
+        originalTask: '',
+        userInstructions: [],
+        assistantPlans: [],
+        filesTouched: [],
+        commands: [],
+        todos: [],
+        errors: [],
+        recentMessages: [],
+    };
+    const events = session.events;
+    if (events.length === 0)
+        return out;
+    // First substantial user message is the original task — remember its lineNo
+    // so we exclude exactly that event (not by text, which loses identity after clipping).
+    let originalTaskLineNo = null;
+    for (const ev of events) {
+        if (ev.kind !== 'user_message')
+            continue;
+        if (ev.text.trim().length < 12)
+            continue;
+        out.originalTask = clip(ev.text.trim(), 1500);
+        originalTaskLineNo = ev.lineNo;
+        break;
+    }
+    // Walk events to bucketize.
+    const seenFiles = new Set();
+    for (let i = 0; i < events.length; i++) {
+        const ev = events[i];
+        if (ev.kind === 'user_message' && ev.lineNo !== originalTaskLineNo) {
+            out.userInstructions.push(clip(ev.text.trim(), 600));
+        }
+        if (ev.kind === 'assistant_message') {
+            const txt = ev.text.trim();
+            // Heuristic: short assistant messages are status pings; longer ones often
+            // contain plans, decisions, summaries. Keep the longer ones.
+            if (txt.length > 80) {
+                out.assistantPlans.push(clip(txt, 800));
+            }
+            // Pull explicit TODO/plan markers regardless of length.
+            const todoMatches = txt.match(/^[\-*]\s*(?:TODO|FIXME|Next)[:.\-]?\s+.+$/gim);
+            if (todoMatches) {
+                for (const m of todoMatches)
+                    out.todos.push(m.trim());
+            }
+        }
+        if (ev.kind === 'tool_call') {
+            if (ev.files) {
+                for (const f of ev.files) {
+                    if (!seenFiles.has(f)) {
+                        seenFiles.add(f);
+                        out.filesTouched.push(f);
+                    }
+                }
+            }
+            if (ev.command) {
+                // Determine if a subsequent result indicates failure.
+                let failed = false;
+                for (let j = i + 1; j < Math.min(events.length, i + 4); j++) {
+                    const next = events[j];
+                    if (next.kind === 'tool_result') {
+                        failed = !!next.isError;
+                        break;
+                    }
+                    if (next.kind === 'tool_call')
+                        break;
+                }
+                out.commands.push({ cmd: clip(ev.command, 200), failed });
+            }
+        }
+        if (ev.kind === 'tool_result' && ev.isError && ev.text) {
+            out.errors.push(clip(ev.text, 240));
+        }
+    }
+    // Recent conversation slice: last 6 user/assistant messages.
+    const tail = events.filter((e) => e.kind === 'user_message' || e.kind === 'assistant_message');
+    out.recentMessages = tail.slice(-6).map((e) => {
+        const who = e.kind === 'user_message' ? 'User' : 'Assistant';
+        return `${who}: ${clip(e.text.trim(), 500)}`;
+    });
+    // De-duplicate while keeping order.
+    out.userInstructions = dedupe(out.userInstructions).slice(-6);
+    out.assistantPlans = dedupe(out.assistantPlans).slice(-4);
+    out.todos = dedupe(out.todos).slice(0, 10);
+    out.errors = dedupe(out.errors).slice(-5);
+    out.filesTouched = dedupe(out.filesTouched).slice(0, 25);
+    // Keep the last N commands; failed ones get priority.
+    out.commands = pickCommands(out.commands, 12);
+    return out;
+}
+function dedupe(xs) {
+    const seen = new Set();
+    const out = [];
+    for (const x of xs) {
+        const key = x.trim();
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(x);
+    }
+    return out;
+}
+function pickCommands(cmds, limit) {
+    const seen = new Set();
+    const unique = [];
+    for (const c of cmds) {
+        if (seen.has(c.cmd))
+            continue;
+        seen.add(c.cmd);
+        unique.push(c);
+    }
+    if (unique.length <= limit)
+        return unique;
+    // Keep all failed + most recent successful commands.
+    const failed = unique.filter((c) => c.failed);
+    const ok = unique.filter((c) => !c.failed);
+    const okTail = ok.slice(-(limit - failed.length));
+    return [...failed, ...okTail].slice(-limit);
+}
+function bullet(items, fallback) {
+    if (items.length === 0)
+        return `- ${fallback}`;
+    return items.map((x) => `- ${x.replace(/\n+/g, ' ')}`).join('\n');
+}
+export function renderHandoff(input) {
+    const { sourceAgent, targetAgent, git, session, options } = input;
+    const d = digest(session);
+    const mtime = session.endedAtMs ?? session.startedAtMs ?? 0;
+    const stale = mtime > 0 ? Date.now() - mtime > STALE_MS : false;
+    const sourceLine = `${session.path} (last activity ${mtime ? new Date(mtime).toISOString() : 'unknown'})`;
+    const sourceLabel = sourceAgent === 'codex' ? 'OpenAI Codex CLI' : 'Anthropic Claude Code';
+    const targetLabel = targetAgent === 'codex' ? 'OpenAI Codex CLI' : 'Anthropic Claude Code';
+    const sections = [];
+    sections.push(`You are continuing work in this repository after a context handoff from ${sourceLabel} to ${targetLabel}.`);
+    sections.push(`This handoff was synthesized by \`codex-claude-relay\` from the prior agent's native local transcript. ` +
+        `It is a *summary*, not a literal session import — treat it as background context, then verify the current repository state before acting.`);
+    if (stale) {
+        sections.push(`⚠ Source session is stale (last activity > 24h ago at ${new Date(mtime).toISOString()}). Other changes may have happened since.`);
+    }
+    if (!git.inRepo) {
+        sections.push(`⚠ The current working directory is not inside a git repository — file paths from the transcript may not resolve here.`);
+    }
+    sections.push([
+        'Repository:',
+        `- Path: ${git.root}`,
+        `- Branch: ${git.branch ?? '(unknown)'}`,
+        `- Repo name: ${git.repoName}`,
+        git.statusShort
+            ? `- Git status summary:\n${indent(clip(git.statusShort, 1200), '  ')}`
+            : '- Git status summary: (clean or unavailable)',
+    ].join('\n'));
+    sections.push([
+        'Original task:',
+        d.originalTask ? indent(d.originalTask, '  ') : '  - (no user message recorded)',
+    ].join('\n'));
+    sections.push([
+        'Subsequent user instructions:',
+        bullet(d.userInstructions, '(no further instructions captured)'),
+    ].join('\n'));
+    sections.push([
+        'What has already been done / key decisions:',
+        bullet(d.assistantPlans, '(no substantial assistant summaries captured)'),
+    ].join('\n'));
+    sections.push([
+        'Files touched or inspected:',
+        bullet(d.filesTouched, '(none captured)'),
+    ].join('\n'));
+    sections.push([
+        'Commands run (★ = errored):',
+        d.commands.length === 0
+            ? '- (none captured)'
+            : d.commands.map((c) => `- ${c.failed ? '★ ' : ''}\`${c.cmd}\``).join('\n'),
+    ].join('\n'));
+    if (d.errors.length > 0) {
+        sections.push([
+            'Errors observed:',
+            d.errors.map((e) => `- ${e.replace(/\n+/g, ' ')}`).join('\n'),
+        ].join('\n'));
+    }
+    if (d.todos.length > 0) {
+        sections.push([
+            'Open TODOs from transcript:',
+            d.todos.map((t) => `- ${t}`).join('\n'),
+        ].join('\n'));
+    }
+    sections.push([
+        'Recent conversation tail:',
+        d.recentMessages.length === 0
+            ? '- (no recent messages)'
+            : d.recentMessages.map((m) => `- ${m}`).join('\n'),
+    ].join('\n'));
+    if (input.memorySummary) {
+        sections.push([
+            'Claude Code auto-memory for this project:',
+            '```',
+            clip(input.memorySummary, 4000),
+            '```',
+        ].join('\n'));
+    }
+    if (input.diff) {
+        sections.push([
+            'Current git diff (HEAD vs working tree):',
+            '```diff',
+            input.diff,
+            '```',
+        ].join('\n'));
+    }
+    sections.push([
+        'Safety notes for you, the receiving agent:',
+        '- Do not assume the prior agent\'s conclusions are still correct.',
+        '- Re-check current file contents and `git status` / `git diff` before editing.',
+        '- Prefer the live repository state over anything implied by this transcript.',
+        '- If something here looks wrong or outdated, ask the user before destructive action.',
+    ].join('\n'));
+    sections.push(`(Handoff generated by codex-claude-relay; source: ${sourceLine})`);
+    let text = sections.join('\n\n');
+    if (!options.noRedact)
+        text = redact(text);
+    // Hard cap. We try not to chop mid-section: if we overshoot, drop the
+    // memory + recent conversation tail first.
+    if (text.length > options.maxChars) {
+        text = text.slice(0, options.maxChars) + '\n... (handoff truncated)';
+    }
+    return {
+        text,
+        stale,
+        source: sourceLine,
+        sourceAgent,
+    };
+}
+function indent(s, prefix) {
+    return s
+        .split('\n')
+        .map((line) => prefix + line)
+        .join('\n');
+}