@sickr/replay 0.5.0 → 0.5.2

package/dist/cli.js

@@ -7,7 +7,7 @@ import { spawn, execFileSync } from 'node:child_process';
 import { appendEvent, loadRun, runsDir, latestRunId } from './recorder.js';
 import { mergeHooks, removeHooks } from './hookConfig.js';
 import { renderRunHtml, renderCombinedHtml } from './render.js';
-import { buildSharePayload, publish, PublishError } from './share.js';
+import { buildSharePayload, buildCombinedPayload, publish, PublishError } from './share.js';
 const REPLAY_ENDPOINT = process.env.SICKR_REPLAY_ENDPOINT ?? 'https://sickr.ai/api/replay';
 const COMMANDS = ['init', 'record', 'open', 'list', 'share', 'stop', 'clear', 'help'];
 export function parseCommand(argv) {
@@ -30,6 +30,9 @@ Commands:
                  runs to ~/.sickr/runs (secrets redacted).
                    --codex      install for Codex (.codex/hooks.json) instead of
                                 Claude Code (.claude/settings.json)
+                   --both       install for BOTH Claude Code and Codex (so the
+                                combined `, open;
+--today ` view sees everything)
                    --no-name    label your prompts "Human" instead of your
                                 login/git name (default is your login name)
   open [run]     Render a run to a local HTML timeline and open it. 100% local.
@@ -39,8 +42,10 @@ Commands:
                  filterable by agent, sortable by prompt/response time).
   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
-                   --yes    skip the confirmation prompt
+                   --open    also open the published link in your browser
+                   --yes     skip the confirmation prompt
+                 Or publish a COMBINED multi-agent view with a window:
+                 --today / --since <2h|30m|1d> / --all (+ --claude/--codex).
   list           List recorded runs, newest first.
   stop           Stop recording — removes SICKR's hooks from this project.
                  Your recorded runs are kept; run \`init\` to start again.
@@ -323,56 +328,80 @@ function handleList(provider) {
         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();
-    if (!id) {
-        process.stderr.write('sickr: no runs to share. Use Claude Code first.\n');
+async function confirmPublish(yes, what) {
+    if (yes)
+        return true;
+    if (!process.stdin.isTTY) {
+        process.stderr.write('sickr: re-run with --yes to publish non-interactively.\n');
         process.exit(1);
-        return;
+        return false;
     }
-    const run = loadRun(id);
-    const payload = buildSharePayload(run);
-    process.stdout.write(`sickr: about to publish run "${id}" (${payload.run.events.length} events, secrets already redacted) to ${REPLAY_ENDPOINT}\n` +
-        `sickr: tip — run \`npx @sickr/replay open ${id}\` to review the full timeline locally before sharing.\n`);
-    if (!yes) {
-        if (!process.stdin.isTTY) {
-            process.stderr.write('sickr: re-run with --yes to publish non-interactively.\n');
-            process.exit(1);
-            return;
-        }
-        process.stdout.write('Publish this run publicly? [y/N] ');
-        const answer = await promptLine();
-        if (answer !== 'y' && answer !== 'yes') {
-            process.stdout.write('sickr: cancelled.\n');
-            return;
-        }
+    process.stdout.write(`Publish ${what} publicly? [y/N] `);
+    const a = await promptLine();
+    if (a !== 'y' && a !== 'yes') {
+        process.stdout.write('sickr: cancelled.\n');
+        return false;
     }
-    let url;
+    return true;
+}
+/** Publish with a single friendly retry on 429 (the WAF allows ~1/10s). Returns the URL. */
+async function publishWithRetry(payload) {
     try {
-        ({ url } = await publish(payload, REPLAY_ENDPOINT));
+        return (await publish(payload, REPLAY_ENDPOINT)).url;
     }
     catch (err) {
         if (err instanceof PublishError && err.status === 429) {
             process.stdout.write('sickr: rate-limited — you can publish about once every 10s. Waiting to retry once...\n');
             await new Promise((r) => setTimeout(r, 11_000));
             try {
-                ({ url } = await publish(payload, REPLAY_ENDPOINT));
+                return (await publish(payload, REPLAY_ENDPOINT)).url;
             }
             catch (retryErr) {
                 if (retryErr instanceof PublishError && retryErr.status === 429) {
                     process.stderr.write('sickr: still rate-limited. Give it a minute and run `share` again.\n');
                     process.exit(1);
-                    return;
                 }
                 throw retryErr;
             }
         }
-        else {
-            throw err;
-        }
+        throw err;
+    }
+}
+async function handleShare(runId, yes, open) {
+    const id = runId ?? latestRunId();
+    if (!id) {
+        process.stderr.write('sickr: no runs to share. Use Claude Code or Codex first.\n');
+        process.exit(1);
+        return;
+    }
+    const payload = buildSharePayload(loadRun(id));
+    process.stdout.write(`sickr: about to publish run "${id}" (${payload.run.events.length} events, secrets already redacted) to ${REPLAY_ENDPOINT}\n` +
+        `sickr: tip — run \`npx @sickr/replay open ${id}\` to review the full timeline locally before sharing.\n`);
+    if (!(await confirmPublish(yes, 'this run')))
+        return;
+    const url = await publishWithRetry(payload);
+    process.stdout.write(`sickr: published → ${url}\nsickr: this link expires in 24h.\n`);
+    if (open)
+        openInBrowser(url);
+}
+async function handleShareCombined(sel, yes, open) {
+    const runs = sel.ids
+        .map((id) => ({ id, events: loadRun(id).events }))
+        .filter((r) => r.events.length)
+        .map((r) => ({ agent: runSummary(r.id).agent, events: r.events }));
+    if (runs.length === 0) {
+        process.stdout.write(`sickr: no runs in ${sel.label} to share.\n`);
+        return;
     }
-    process.stdout.write(`sickr: published → ${url}\n`);
-    process.stdout.write('sickr: this link expires in 24h.\n');
+    const turns = runs.reduce((n, r) => n + r.events.filter((e) => e.kind === 'prompt').length, 0);
+    const agents = Array.from(new Set(runs.map((r) => r.agent))).join(', ');
+    const payload = buildCombinedPayload(runs, sel.label);
+    process.stdout.write(`sickr: about to publish a combined replay (${sel.label}) — ${runs.length} runs, ~${turns} turns across ${agents}, secrets already redacted, to ${REPLAY_ENDPOINT}\n` +
+        `sickr: tip — run the matching \`open\` window to review locally before sharing.\n`);
+    if (!(await confirmPublish(yes, 'this combined replay')))
+        return;
+    const url = await publishWithRetry(payload);
+    process.stdout.write(`sickr: published → ${url}\nsickr: this link expires in 24h.\n`);
     if (open)
         openInBrowser(url);
 }
@@ -404,9 +433,16 @@ async function main() {
         case 'record':
             handleRecord(await readStdin(), provider);
             return;
-        case 'init':
-            handleInit(provider, rest.includes('--no-name'));
+        case 'init': {
+            const noName = rest.includes('--no-name');
+            if (rest.includes('--both')) {
+                handleInit('claude', noName);
+                handleInit('codex', noName);
+                return;
+            }
+            handleInit(provider, noName);
             return;
+        }
         case 'open': {
             const sel = selectWindow(rest);
             if (sel) {
@@ -428,9 +464,17 @@ async function main() {
         case 'clear':
             await handleClear(rest.includes('--yes') || rest.includes('-y'));
             return;
-        case 'share':
-            await handleShare(rest.find((a) => !a.startsWith('-')), rest.includes('--yes') || rest.includes('-y'), rest.includes('--open'));
+        case 'share': {
+            const yes = rest.includes('--yes') || rest.includes('-y');
+            const openAfter = rest.includes('--open');
+            const sel = selectWindow(rest);
+            if (sel) {
+                await handleShareCombined(sel, yes, openAfter);
+                return;
+            }
+            await handleShare(rest.find((a) => !a.startsWith('-')), yes, openAfter);
             return;
+        }
         default:
             process.stderr.write('sickr: unknown command. Run `npx @sickr/replay help`.\n');
             process.exit(1);

package/dist/share.js

@@ -2,6 +2,10 @@
 export function buildSharePayload(run) {
     return { run: { cwd: run.cwd, startedAt: run.startedAt, events: run.events } };
 }
+/** Combined multi-agent payload: tagged runs + the window label. */
+export function buildCombinedPayload(runs, window) {
+    return { window, runs: runs.map((r) => ({ agent: r.agent, events: r.events })) };
+}
 export class PublishError extends Error {
     status;
     constructor(status) {

package/package.json

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