@sickr/replay 0.3.0 → 0.4.3

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { pathToFileURL } from 'node:url';
 import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
 import { spawn } from 'node:child_process';
 import { appendEvent, loadRun, runsDir, latestRunId } from './recorder.js';
 import { mergeHooks, removeHooks } from './hookConfig.js';
@@ -16,8 +16,8 @@ export function parseCommand(argv) {
 }
 export const HELP = `SICKR Replay — audit & replay what your AI coding agent did.
 
-Records your Claude Code session (prompts, edits, commands) to a local, redacted
-timeline you can replay — and optionally share as a public link.
+Records your Claude Code or Codex session (prompts, edits, commands) to a local,
+redacted timeline you can replay — and optionally share as a public link.
 
 Why: a durable record of every agent action — a dashcam for your coding agent.
 If your agent (Claude or Codex) loses context or can't reload a past chat, the
@@ -26,10 +26,16 @@ replay log helps you — and it — recall exactly what was just done.
 Usage: npx @sickr/replay <command> [options]
 
 Commands:
-  init           Install the Claude Code recording hooks in this project and
-                 start capturing runs to ~/.sickr/runs (secrets redacted).
+  init           Install the recording hooks in this project and start capturing
+                 runs to ~/.sickr/runs (secrets redacted).
+                   --codex      install for Codex (.codex/hooks.json) instead of
+                                Claude Code (.claude/settings.json)
+                   --as "<name>"  label your prompts with <name> on replays
+                                (default "Human"; or set SICKR_HANDLE)
   open [run]     Render a run to a local HTML timeline and open it in your
-                 browser. 100% local — nothing is uploaded.
+                 browser. 100% local — nothing is uploaded. Defaults to the
+                 newest run; pass a run id, or --codex / --claude to open the
+                 newest run for that agent.
   share [run]    Redact and publish ONE run to a public sickr.ai/r/<id> link
                  (shows a preview and asks first). Links expire after 24h.
                    --open   also open the published link in your browser
@@ -58,44 +64,83 @@ audit, accountability, productivity and confidence.
 export function currentRunId(cc) {
     return String(cc.session_id ?? 'session');
 }
-/** Ingest one Claude Code hook payload. Must never throw — a hook error would break the agent. */
-export function handleRecord(input) {
+const PROVIDERS = {
+    claude: { name: 'Claude Code', label: 'Claude', settingsPath: () => join(process.cwd(), '.claude', 'settings.json') },
+    codex: { name: 'Codex', label: 'Codex', settingsPath: () => join(process.cwd(), '.codex', 'hooks.json') },
+};
+function configPath() {
+    return join(homedir(), '.sickr', 'config.json');
+}
+/** Display name for the human: SICKR_HANDLE env, else ~/.sickr/config.json handle, else "Human". */
+function resolveHandle() {
+    if (process.env.SICKR_HANDLE)
+        return process.env.SICKR_HANDLE;
+    try {
+        const c = JSON.parse(readFileSync(configPath(), 'utf8'));
+        if (c.handle)
+            return c.handle;
+    }
+    catch { /* no config */ }
+    return 'Human';
+}
+/** Ingest one hook payload (Claude Code or Codex). Must never throw. */
+export function handleRecord(input, provider = 'claude') {
     try {
         const cc = JSON.parse(input);
-        appendEvent(currentRunId(cc), cc);
+        appendEvent(currentRunId(cc), cc, { human: resolveHandle(), agent: PROVIDERS[provider].label });
     }
     catch {
         /* swallow: recording is best-effort and must not disrupt the session */
     }
 }
-function handleInit() {
-    const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+export function handleInit(provider, handle) {
+    const p = PROVIDERS[provider];
+    const settingsPath = p.settingsPath();
     const settings = existsSync(settingsPath) ? JSON.parse(readFileSync(settingsPath, 'utf8')) : {};
-    const merged = mergeHooks(settings, 'npx @sickr/replay');
-    mkdirSync(join(process.cwd(), '.claude'), { recursive: true });
+    const command = `npx @sickr/replay record${provider === 'codex' ? ' --codex' : ''}`;
+    // Remove any prior SICKR hook first, then install the current command — so
+    // re-running init (or a CLI upgrade that changes the command) self-heals
+    // instead of leaving a stale hook. Scoped to this provider's file.
+    const merged = mergeHooks(removeHooks(settings), command);
+    mkdirSync(dirname(settingsPath), { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + '\n');
     mkdirSync(runsDir(), { recursive: true });
-    process.stdout.write(`sickr: installed Claude Code hooks in ${settingsPath}\n` +
+    if (handle) {
+        let existing = {};
+        try {
+            existing = JSON.parse(readFileSync(configPath(), 'utf8'));
+        }
+        catch { /* none */ }
+        writeFileSync(configPath(), JSON.stringify({ ...existing, handle }, null, 2) + '\n');
+    }
+    process.stdout.write(`sickr: installed ${p.name} recording hooks in ${settingsPath}\n` +
         `Runs are recorded locally to ${runsDir()} (secrets redacted).\n` +
-        `Use Claude Code as normal, then: npx @sickr/replay open\n`);
+        (handle ? `Your prompts will be labelled "${handle}".\n` : 'Tip: set SICKR_HANDLE or run `init --as "<name>"` to label your prompts.\n') +
+        `Use ${p.name} as normal, then: npx @sickr/replay open\n`);
 }
-/** Stop recording: remove SICKR's hooks from this project's settings, keep runs. */
+/** Stop recording: remove SICKR's hooks from this project (both providers), keep runs. */
 export function handleStop() {
-    const settingsPath = join(process.cwd(), '.claude', 'settings.json');
-    if (!existsSync(settingsPath)) {
-        process.stdout.write('sickr: no .claude/settings.json here — not recording in this project.\n');
-        return;
-    }
-    let settings;
-    try {
-        settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const targets = [PROVIDERS.claude.settingsPath(), PROVIDERS.codex.settingsPath()];
+    const cleaned = [];
+    for (const settingsPath of targets) {
+        if (!existsSync(settingsPath))
+            continue;
+        let settings;
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        }
+        catch {
+            process.stderr.write(`sickr: could not parse ${settingsPath}; left it unchanged.\n`);
+            continue;
+        }
+        writeFileSync(settingsPath, JSON.stringify(removeHooks(settings), null, 2) + '\n');
+        cleaned.push(settingsPath);
     }
-    catch {
-        process.stderr.write(`sickr: could not parse ${settingsPath}; left it unchanged.\n`);
+    if (cleaned.length === 0) {
+        process.stdout.write('sickr: no SICKR hooks found here — not recording in this project.\n');
         return;
     }
-    writeFileSync(settingsPath, JSON.stringify(removeHooks(settings), null, 2) + '\n');
-    process.stdout.write('sickr: recording stopped — removed SICKR hooks from .claude/settings.json.\n' +
+    process.stdout.write(`sickr: recording stopped — removed SICKR hooks from ${cleaned.join(', ')}.\n` +
         'Your recorded runs are kept. Run `npx @sickr/replay init` to start again.\n');
 }
 /** Delete all local runs. Destructive — confirms unless `yes` is set. */
@@ -131,17 +176,49 @@ function openInBrowser(file) {
     }
     catch { /* ignore */ }
 }
-function handleOpen(runId) {
-    const id = runId ?? latestRunId();
+/** A short, human-readable summary of a run: agent + first prompt + event count. */
+function runSummary(id) {
+    const run = loadRun(id);
+    const agent = run.events.find((e) => e.kind === 'response')?.label || '—';
+    const prompt = (run.events.find((e) => e.kind === 'prompt')?.detail || '').replace(/\s+/g, ' ').trim();
+    return { agent, prompt, events: run.events.length };
+}
+/** Newest run whose agent (response label) matches `agent`, or null. */
+export function latestRunIdFor(agent) {
+    const dir = runsDir();
+    if (!existsSync(dir))
+        return null;
+    const files = readdirSync(dir)
+        .filter((f) => f.endsWith('.ndjson'))
+        .sort((a, b) => statSync(join(dir, b)).mtimeMs - statSync(join(dir, a)).mtimeMs);
+    for (const f of files) {
+        const id = f.replace(/\.ndjson$/, '');
+        if (loadRun(id).events.some((e) => e.kind === 'response' && e.label === agent))
+            return id;
+    }
+    return null;
+}
+function handleOpen(runId, provider) {
+    let id = runId;
+    if (!id && provider) {
+        id = latestRunIdFor(PROVIDERS[provider].label) ?? undefined;
+        if (!id) {
+            process.stdout.write(`sickr: no ${PROVIDERS[provider].label} runs yet — use ${PROVIDERS[provider].name} with the hooks installed, then try again.\n`);
+            return;
+        }
+    }
+    id = id ?? latestRunId() ?? undefined;
     if (!id) {
-        process.stdout.write('sickr: no runs recorded yet. Run `npx @sickr/replay init`, then use Claude Code.\n');
+        process.stdout.write('sickr: no runs recorded yet. Run `npx @sickr/replay init`, then use Claude Code or Codex.\n');
         return;
     }
     const html = renderRunHtml(loadRun(id));
     const out = join(homedir(), '.sickr', 'last.html');
     mkdirSync(join(homedir(), '.sickr'), { recursive: true });
     writeFileSync(out, html);
-    process.stdout.write(`sickr: opened replay for ${id} → ${out}\n`);
+    const s = runSummary(id);
+    process.stdout.write(`sickr: opened ${s.agent} run ${id} · ${s.events} events${s.prompt ? ` · "${s.prompt.slice(0, 60)}"` : ''}\n` +
+        `→ ${out}  (newest run; use \`list\` to see others, \`open <id>\` to pick one)\n`);
     openInBrowser(out);
 }
 function handleList() {
@@ -153,7 +230,13 @@ function handleList() {
     }
     files
         .sort((a, b) => statSync(join(dir, b)).mtimeMs - statSync(join(dir, a)).mtimeMs)
-        .forEach((f) => process.stdout.write(`${f.replace(/\.ndjson$/, '')}\t${statSync(join(dir, f)).mtime.toISOString()}\n`));
+        .forEach((f) => {
+        const id = f.replace(/\.ndjson$/, '');
+        const s = runSummary(id);
+        const when = statSync(join(dir, f)).mtime.toISOString().replace('T', ' ').slice(0, 16);
+        const snippet = s.prompt ? ` "${s.prompt.slice(0, 48)}"` : '';
+        process.stdout.write(`${id}  ${s.agent.padEnd(7)} ${String(s.events).padStart(4)} ev  ${when}${snippet}\n`);
+    });
 }
 async function handleShare(runId, yes, open) {
     const id = runId ?? latestRunId();
@@ -231,16 +314,22 @@ async function main() {
     }
     const cmd = parseCommand(argv);
     const rest = argv.slice(1);
+    const provider = rest.includes('--codex') ? 'codex' : 'claude';
     switch (cmd) {
         case 'record':
-            handleRecord(await readStdin());
+            handleRecord(await readStdin(), provider);
             return;
-        case 'init':
-            handleInit();
+        case 'init': {
+            const asIdx = rest.indexOf('--as');
+            const handle = asIdx >= 0 ? rest[asIdx + 1] : undefined;
+            handleInit(provider, handle);
             return;
-        case 'open':
-            handleOpen(argv[1]);
+        }
+        case 'open': {
+            const openProvider = rest.includes('--codex') ? 'codex' : rest.includes('--claude') ? 'claude' : undefined;
+            handleOpen(rest.find((a) => !a.startsWith('-')), openProvider);
             return;
+        }
         case 'list':
             handleList();
             return;

package/dist/recorder.js

@@ -80,18 +80,22 @@ function formatQuestions(questions) {
     })
         .join('\n\n');
 }
-/** Map one Claude Code hook payload to a redacted run event. */
-export function mapEvent(cc, now = new Date()) {
+/**
+ * Map one hook payload (Claude Code OR Codex — same field names) to a redacted
+ * run event. `ctx` supplies the human/agent display labels.
+ */
+export function mapEvent(cc, now = new Date(), ctx = {}) {
     const at = now.toISOString();
     const name = String(cc.hook_event_name ?? '');
     switch (name) {
         case 'SessionStart':
             return { kind: 'start', label: 'Session', detail: redact(String(cc.cwd ?? '')), at };
         case 'UserPromptSubmit':
-            return { kind: 'prompt', label: 'Prompt', detail: redact(String(cc.prompt ?? '')).slice(0, 400), at };
+            return { kind: 'prompt', label: (ctx.human || 'Human').slice(0, 40), detail: redact(String(cc.prompt ?? '')).slice(0, 400), at };
         case 'Stop': {
-            const text = cc.transcript_path ? extractLastAssistantText(String(cc.transcript_path)) : '';
-            return { kind: 'response', label: 'Response', detail: redact(text).slice(0, 2000), at };
+            // Codex hands us the reply directly; Claude Code we read from the transcript.
+            const text = String(cc.last_assistant_message ?? '') || (cc.transcript_path ? extractLastAssistantText(String(cc.transcript_path)) : '');
+            return { kind: 'response', label: (ctx.agent || 'Agent').slice(0, 40), detail: redact(text).slice(0, 2000), at };
         }
         case 'PreToolUse':
         case 'PostToolUse': {
@@ -113,10 +117,10 @@ export function mapEvent(cc, now = new Date()) {
             return { kind: 'tool', label: name || 'event', detail: '', at };
     }
 }
-export function appendEvent(runId, cc) {
+export function appendEvent(runId, cc, ctx = {}) {
     const dir = runsDir();
     mkdirSync(dir, { recursive: true });
-    appendFileSync(join(dir, `${runId}.ndjson`), JSON.stringify(mapEvent(cc)) + '\n');
+    appendFileSync(join(dir, `${runId}.ndjson`), JSON.stringify(mapEvent(cc, new Date(), ctx)) + '\n');
 }
 export function loadRun(runId) {
     const file = join(runsDir(), `${runId}.ndjson`);

package/dist/render.js

@@ -108,6 +108,16 @@ const STYLES = `
   .msg .bubble{padding:10px 14px;border-radius:0 8px 8px 0;white-space:pre-wrap;word-break:break-word;font-size:14px;line-height:1.6}
   .msg.human .bubble{border-left:2px solid rgba(255,207,107,.55);background:rgba(255,207,107,.05);color:#f3ead7}
   .msg.agent .bubble{border-left:2px solid rgba(52,224,255,.55);background:rgba(52,224,255,.05);color:#d7e6ee}
+  .bubble.md{white-space:normal}
+  .bubble.md p{margin:0 0 8px}.bubble.md p:last-child{margin-bottom:0}
+  .bubble.md code{font-family:"JetBrains Mono",monospace;font-size:.92em;background:rgba(255,255,255,.07);padding:1px 5px;border-radius:4px}
+  .bubble.md pre{background:#04060b;border:1px solid #1b2435;border-radius:8px;padding:10px 12px;overflow:auto;margin:8px 0}
+  .bubble.md pre code{background:none;padding:0;font-size:12.5px;line-height:1.5}
+  .bubble.md ul,.bubble.md ol{margin:6px 0;padding-left:20px}.bubble.md li{margin:3px 0}
+  .bubble.md a{color:var(--plasma);text-decoration:underline}
+  .bubble.md blockquote{margin:8px 0;padding:2px 12px;border-left:2px solid #2a3850;color:#9aa6b6}
+  .bubble.md .md-h{font-family:"Chakra Petch","Sora",sans-serif;font-weight:700;color:#fff;font-size:15px;margin:10px 0 6px}
+  .bubble.md strong{color:#fff;font-weight:700}
   details.work{margin:10px 0;border:1px solid #16202f;border-radius:10px;background:rgba(8,12,20,.4)}
   details.work>summary{cursor:pointer;list-style:none;padding:10px 14px;display:flex;align-items:center;gap:10px;font-family:"JetBrains Mono",monospace;font-size:12px;color:#9aa6b6}
   details.work>summary::-webkit-details-marker{display:none}
@@ -210,10 +220,109 @@ function fmtTime(at) {
     return at ? esc(at.replace('T', ' ').slice(0, 19) + 'Z') : '';
 }
 const COPY_ICON = '<svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="11" height="11" rx="2"/><path d="M5 15V5a2 2 0 0 1 2-2h10"/></svg>';
+// Inline markdown on an ALREADY-ESCAPED string. Code spans are protected from
+// emphasis. Only http(s) links are emitted. No raw HTML can survive (input is
+// pre-escaped), so this is XSS-safe — it only adds a fixed set of safe tags.
+function inlineMd(s) {
+    return s.split(/(`[^`]+`)/).map((p) => {
+        if (p.length >= 2 && p[0] === '`' && p[p.length - 1] === '`')
+            return `<code>${p.slice(1, -1)}</code>`;
+        return p
+            .replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, '<a href="$2" rel="noopener noreferrer" target="_blank">$1</a>')
+            .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
+            .replace(/__([^_]+)__/g, '<strong>$1</strong>')
+            .replace(/\*([^*\s][^*]*)\*/g, '<em>$1</em>')
+            .replace(/(^|[^a-zA-Z0-9_])_([^_\s][^_]*)_/g, '$1<em>$2</em>');
+    }).join('');
+}
+/** Minimal, XSS-safe markdown → HTML for chat bubbles (prompt/response). */
+export function mdToHtml(raw) {
+    const lines = esc(raw).split('\n');
+    const out = [];
+    let para = [];
+    let code = [];
+    let inCode = false;
+    let list = null;
+    const flushPara = () => { if (para.length) {
+        out.push(`<p>${inlineMd(para.join('<br>'))}</p>`);
+        para = [];
+    } };
+    const flushList = () => { if (list) {
+        out.push(`</${list}>`);
+        list = null;
+    } };
+    for (const line of lines) {
+        const fence = /^```/.test(line.trim());
+        if (inCode) {
+            if (fence) {
+                out.push(`<pre><code>${code.join('\n')}</code></pre>`);
+                code = [];
+                inCode = false;
+            }
+            else
+                code.push(line);
+            continue;
+        }
+        if (fence) {
+            flushPara();
+            flushList();
+            inCode = true;
+            continue;
+        }
+        if (/^\s*$/.test(line)) {
+            flushPara();
+            flushList();
+            continue;
+        }
+        let m;
+        if ((m = line.match(/^#{1,6}\s+(.*)$/))) {
+            flushPara();
+            flushList();
+            out.push(`<div class="md-h">${inlineMd(m[1])}</div>`);
+            continue;
+        }
+        if ((m = line.match(/^\s*[-*]\s+(.*)$/))) {
+            flushPara();
+            if (list !== 'ul') {
+                flushList();
+                out.push('<ul>');
+                list = 'ul';
+            }
+            out.push(`<li>${inlineMd(m[1])}</li>`);
+            continue;
+        }
+        if ((m = line.match(/^\s*\d+\.\s+(.*)$/))) {
+            flushPara();
+            if (list !== 'ol') {
+                flushList();
+                out.push('<ol>');
+                list = 'ol';
+            }
+            out.push(`<li>${inlineMd(m[1])}</li>`);
+            continue;
+        }
+        if ((m = line.match(/^>\s?(.*)$/))) {
+            flushPara();
+            flushList();
+            out.push(`<blockquote>${inlineMd(m[1])}</blockquote>`);
+            continue;
+        }
+        para.push(line);
+    }
+    if (inCode)
+        out.push(`<pre><code>${code.join('\n')}</code></pre>`);
+    flushPara();
+    flushList();
+    return out.join('\n');
+}
+// The speaker name travels on the event label; fall back for legacy generic labels.
+function speaker(label, generic, fallback) {
+    return label && label !== generic ? label : fallback;
+}
 function bubble(kind, who, e) {
     return `<div class="msg ${kind}">
-    <div class="who"><span class="badge ${kind === 'human' ? 'h' : 'a'}">${who}</span><span class="ts">${fmtTime(e.at)}</span><button class="copy" type="button" aria-label="Copy text" title="Copy">${COPY_ICON}</button></div>
-    <div class="bubble">${esc(e.detail)}</div>
+    <div class="who"><span class="badge ${kind === 'human' ? 'h' : 'a'}">${esc(who)}</span><span class="ts">${fmtTime(e.at)}</span><button class="copy" type="button" aria-label="Copy text" title="Copy">${COPY_ICON}</button></div>
+    <div class="bubble md">${mdToHtml(e.detail)}</div>
   </div>`;
 }
 function workBlock(work) {
@@ -238,9 +347,9 @@ function renderTimeline(events) {
         : '';
     const preTools = workBlock(pre.filter((e) => e.kind === 'tool'));
     const body = turns.map((t) => `<section class="turn">
-    ${t.prompt ? bubble('human', 'You', t.prompt) : ''}
+    ${t.prompt ? bubble('human', speaker(t.prompt.label, 'Prompt', 'Human'), t.prompt) : ''}
     ${workBlock(t.work)}
-    ${t.response && t.response.detail ? bubble('agent', 'Claude', t.response) : ''}
+    ${t.response && t.response.detail ? bubble('agent', speaker(t.response.label, 'Response', 'Agent'), t.response) : ''}
   </section>`).join('\n');
     return preamble + preTools + body;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sickr/replay",
-  "version": "0.3.0",
+  "version": "0.4.3",
   "type": "module",
   "description": "npx @sickr/replay — local Claude Code audit + one-click share. The free wedge into SICKR.",
   "bin": { "replay": "dist/cli.js" },