@sickr/cli 0.9.6 → 0.9.7

package/dist/cli.js

@@ -51,113 +51,72 @@ export function buildWorkflowInvocation(rest, command = 'uvx') {
     }
     return { command, args: rest };
 }
-export const HELP = `SICKR Replay — audit & replay what your AI coding agent did.
+export const HELP = `sickr — record, replay, and remote-control your AI coding agents.
 
-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.
+Usage: npx @sickr/cli <command> [options]
 
-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
-replay log helps you — and it — recall exactly what was just done.
+REPLAY (free) — local recording of every prompt, edit and command.
+  replay              Install Claude + Codex recording hooks. Use the agents
+                      as normal — a redacted timeline is captured to
+                      ~/.sickr/runs.
+  replay open [id]    Render the newest run (or a specific id) as a local
+                      HTML timeline. Combine across agents with --today,
+                      --since <2h|30m|1d>, or --all (+ --claude / --codex).
+  replay share [id]   Publish a redacted run to sickr.ai/r/<id> (asks first).
+                      Add --yes to skip the prompt; --open to open after.
+                      Or combine a window: --today / --since <dur> / --all.
+                      Anon links live 24h; signed-in links live 7 days.
+  replay list         List recorded runs, newest first (+ --claude/--codex).
+  replay stop         Remove sickr hooks from this project (keeps runs).
+  replay clear        Delete all local runs in ~/.sickr/runs (asks first).
 
-Usage: npx @sickr/cli <command> [options]
+LIVE LOOK (Replay Pro) — passive streaming to a watching browser.
+  live                Stream the current session to sickr.ai/r/<your-link> in
+                      real time. Browser steer messages land in
+                      ~/.sickr/inbox/<urlid>.md and your terminal prints them.
+                      Requires \`sickr login\` + Replay Pro entitlement.
+  live status         Show pid + connection state.
+  live stop           Stop the sidecar.
 
-Commands:
-  replay        Auto mode: installs Claude + Codex recording hooks. If the
-                signed-in user has Replay Pro, starts Live Look as well.
-  replay init all|claude|codex
-                Install recording hooks under the unified command name.
-  replay share  Publish a redacted replay to sickr.ai/r/<id>.
-  replay status Show Live Look sidecar status.
-  workflow connect --agent-id <id>
-                Connect this machine to a configured SICKR workflow agent.
-  workflow start --agent-id <id>
-                Start the workflow orchestrator for that configured agent.
-  workflow status
-                Show running workflow daemon status.
-  workflow rotate | workflow disconnect
-                Rotate or revoke this machine's workflow agent key.
+REMOTE CONTROL (Replay Pro) — browser keystrokes drive the agent.
+  run <agent>         Wrap an agent in a PTY sickr owns; browser steer
+                      messages are written directly into the agent's stdin.
+                      Real remote control, not pasteboard.
+                        sickr run claude      Claude Code under sickr
+                        sickr run codex       Codex under sickr
+                        sickr run <bin>       arbitrary binary
+                      Flags:
+                        --mode auto   (default) inject the agent's
+                                      "no prompt / full perms" flag so it
+                                      doesn't stall on tool confirms the
+                                      operator can't see.
+                        --mode interactive  pass agent flags through
+                                      verbatim — agent prompts for tool use.
+                      Requires \`sickr login\` + Replay Pro entitlement.
+                      Codex 0.133+ needs \`/hooks\` typed once to trust the
+                      recorder; Claude is silent (hooks auto-installed).
 
-Legacy replay commands remain supported:
-  init <agent>   Install recording hooks for an agent (REQUIRED — no default)
-                 and start capturing to ~/.sickr/runs (secrets redacted):
-                   claude    Claude Code  (.claude/settings.json)
-                   codex     Codex        (.codex/hooks.json — needs Codex 0.133+)
-                   all       both of the above (feeds the combined view)
-                 Flag: --no-name  (label prompts "Human", not your login name)
-  open [run]     Render a run to a local HTML timeline and open it. 100% local.
-                 Defaults to the newest run; pass a run id, or --codex/--claude
-                 for the newest run of that agent. Combine across agents with a
-                 window: --today, --since <2h|30m|1d>, or --all (interleaved,
-                 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
-                 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.
-  clear          Delete all local runs in ~/.sickr/runs (asks first).
-  login          Sign in with GitHub (optional — unlocks persistent shares and
-                 Replay Pro cohort eligibility). Zero-account use still works.
-  logout         Forget the local login. Server-side session stays valid until
-                 it expires; revoke from your account page if needed.
-  whoami         Show who you're logged in as.
-  live           Replay Pro: stream the current session to sickr.ai/r/<your-link>
-                 in real time. Requires \`login\` and Replay Pro entitlement.
-                   replay live            start the sidecar (foreground; ^C exits)
-                   replay live status     show pid + connection state
-                   replay live stop       stop the sidecar
-                 While running, steer messages from the watching browser are
-                 saved to ~/.sickr/inbox/<urlid>.md and printed in your terminal.
-  run <agent>    Replay Pro (Phase 2): wrap an agent in a PTY this CLI owns.
-                 Browser steer messages land directly in the agent's stdin —
-                 real remote control, no copy-paste from inbox.
-                   sickr run claude         spawn Claude Code under sickr (auto-perms)
-                   sickr run codex          same for Codex (auto-perms)
-                   sickr run <bin>          arbitrary command
-                 Modes:
-                   --mode auto  (default)   inject the agent's "no prompt /
-                                            full permissions" flag so it
-                                            doesn't stall on tool confirms
-                                            the operator can't see (claude:
-                                            --dangerously-skip-permissions;
-                                            codex: --dangerously-bypass-
-                                            approvals-and-sandbox)
-                   --mode interactive       pass agent flags through verbatim;
-                                            agent will prompt for tool use
-                 \`node-pty\` ships as an optional dep + auto-installs with the
-                 CLI on supported platforms (mac, Linux, Windows 10+).
-                 Browsers can override per-message: {mode:'queue'|'steer',
-                 submit:true|false}; default is auto-steer with submit.
-  agent connect --agent-id <id>
-                 Connect this machine to a configured SICKR agent using GitHub
-                 browser approval. Stores the agent key in ~/.sickr/agent.json.
-  agent status  Show the connected agent, org and team.
-  agent rotate  Rotate this machine's agent key.
-  agent disconnect
-                 Revoke this machine's agent key and remove it locally.
-  help           Show this help.
+ACCOUNT
+  login               Sign in with GitHub. Unlocks persistent shares
+                      (24h → 7d) and Replay Pro entitlement.
+  logout              Forget the local login.
+  whoami              Show who you're signed in as.
 
-Requires Node 18+. Codex capture needs Codex CLI 0.133+ (run /hooks to trust);
-Claude Code: any hooks-capable build.
+WORKFLOW (sickr-managed agent + ticketing)
+  workflow connect --agent-id <id>   Approve this machine for a configured
+                                     workflow agent (GitHub browser flow).
+  workflow start   --agent-id <id>   Start the orchestrator for an agent.
+  workflow status                    Show running daemon status.
+  workflow rotate | disconnect       Rotate or revoke this machine's key.
 
-────────────────────────────────────────────────────────────────────
-This replays your AI coding agents on ONE machine. SICKR governs your whole team.
-Issue tracking + your team + automation + agents — one governed workflow for
-audit, accountability, productivity and confidence.
+  help                Show this help.
 
-  · Gates & approvals — work holds at plan sign-off, review, merge and
-    validation checks until each one passes.
-  · Humans + agents on one board — agents are first-class teammates with
-    roles, capacity and accountability, not a side channel.
-  · A full, signed-off audit trail across every actor and every change.
-  · Runs 24/7 — produce as much work as you like; the team handles it.
+Requires Node 20+. Codex capture needs Codex CLI 0.133+.
 
-  Free tier available · bring your own Claude or Codex subscription.
-  → https://sickr.ai
+────────────────────────────────────────────────────────────────────
+sickr also governs your whole team — issue tracking + humans + agents on one
+board, gates & approvals, signed audit trail, runs 24/7. Free tier available;
+bring your own Claude or Codex subscription. → https://sickr.ai
 `;
 export function currentRunId(cc) {
     return String(cc.session_id ?? 'session');
@@ -860,6 +819,24 @@ async function fetchReplayProEntitlement() {
         return false;
     }
 }
+/** Gate a Pro-only command. Returns true if the user is allowed; otherwise
+ *  prints a friendly explanation and returns false. Distinguishes the three
+ *  failure modes (not-logged-in / logged-in-no-pro / network-fail) so the
+ *  operator knows exactly what to do next. */
+async function requireReplayPro(commandLabel) {
+    const creds = readCredentials();
+    if (!creds) {
+        process.stderr.write(`sickr: \`${commandLabel}\` is a Replay Pro feature.\n` +
+            `       run \`sickr login\` first — your Pro entitlement is attached to your GitHub account.\n`);
+        return false;
+    }
+    if (await fetchReplayProEntitlement())
+        return true;
+    process.stderr.write(`sickr: \`${commandLabel}\` is a Replay Pro feature.\n` +
+        `       you are signed in as ${creds.login}, but your account isn't on Replay Pro.\n` +
+        `       join the rolling-cohort waitlist → https://sickr.ai/#waitlist\n`);
+    return false;
+}
 async function handleReplay(rest) {
     const sub = replaySubcommand(rest);
     if (!sub) {
@@ -933,6 +910,10 @@ async function handleReplay(rest) {
             liveStatus();
             return;
         }
+        if (!(await requireReplayPro('sickr replay live'))) {
+            process.exit(3);
+            return;
+        }
         await startLive({ verbose: replayRest.includes('--verbose') || replayRest.includes('-v'), background: replayRest.includes('--background') });
         return;
     }
@@ -1132,6 +1113,10 @@ async function main() {
                 liveStatus();
                 return;
             }
+            if (!(await requireReplayPro('sickr live'))) {
+                process.exit(3);
+                return;
+            }
             // default: start (foreground)
             const opts = { verbose: rest.includes('--verbose') || rest.includes('-v'), background: rest.includes('--background') };
             await startLive(opts);
@@ -1180,6 +1165,10 @@ async function main() {
             const passthroughFlags = flags.filter((f) => f !== '--verbose' && f !== '-v');
             const agentArgs = [...passthroughFlags, ...positional.slice(1)];
             const verbose = flags.includes('--verbose') || flags.includes('-v');
+            if (!(await requireReplayPro('sickr run'))) {
+                process.exit(3);
+                return;
+            }
             const { startRun } = await import('./run.js');
             try {
                 await startRun({ agent, agentArgs, verbose, mode });

package/dist/run.js

@@ -295,6 +295,11 @@ export async function startRun(opts) {
     else if (mode === 'interactive') {
         process.stdout.write(`       mode=interactive — agent will prompt for tool use; you confirm in the PTY\n`);
     }
+    if (opts.agent === 'codex') {
+        // Codex 0.133+ gates new hooks until trusted; without trust the recorder
+        // is dormant and /r/<urlid> stays empty even though the PTY is live.
+        process.stdout.write(`       codex hooks: type \`/hooks\` once inside codex to trust the recorder.\n`);
+    }
     process.stdout.write(`       browser steer messages land directly in your agent. ^C exits.\n\n`);
     const pty = ptySpawn(agentBin, effectiveArgs, {
         name: 'xterm-256color',
@@ -388,12 +393,28 @@ export async function startRun(opts) {
                 if (m.kind === 'steer' && m.text) {
                     const decision = decideSteer(m);
                     if (decision.target === 'pty' && decision.bytes != null) {
+                        // Submit-fix (2026-06-01): Claude Code's TUI treats a burst of
+                        // characters arriving with no inter-keystroke gap as a paste
+                        // — and within a paste, \r is an inline newline, NOT a submit.
+                        // Text appeared in the input box but never got sent until the
+                        // operator manually hit Enter. Split the write: body first,
+                        // then a short delay, then a standalone \r so it lands as a
+                        // discrete Enter keypress instead of "tail of a paste".
+                        const bytes = decision.bytes;
+                        const bodyOnly = bytes.endsWith('\r') ? bytes.slice(0, -1) : bytes;
+                        const submit = bytes.endsWith('\r');
                         try {
-                            pty.write(decision.bytes);
+                            if (bodyOnly.length > 0)
+                                pty.write(bodyOnly);
+                            if (submit)
+                                setTimeout(() => { try {
+                                    pty.write('\r');
+                                }
+                                catch { /* pty exited */ } }, 80);
                         }
                         catch { /* PTY may have exited */ }
                         if (opts.verbose)
-                            process.stderr.write(`sickr: pty steer ${decision.bytes.length}b\n`);
+                            process.stderr.write(`sickr: pty steer ${bytes.length}b${submit ? ' (split for submit)' : ''}\n`);
                     }
                     else {
                         appendInbox(urlid, m.text, m.at ?? new Date().toISOString());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sickr/cli",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "type": "module",
   "description": "npx @sickr/cli - replay, live look, and workflow orchestration for AI coding agents.",
   "bin": { "replay": "dist/cli.js", "sickr": "dist/cli.js" },