claude-code-runrate 0.2.0 → 0.2.1

package/bin/ccr.js

@@ -59,6 +59,7 @@ function main(argv) {
         json: { type: 'boolean' },
         'state-dir': { type: 'string' },
         hint: { type: 'boolean' },
+        'exit-on-end': { type: 'boolean' },
         mary: { type: 'boolean' },
       },
     });
@@ -80,7 +81,7 @@ function main(argv) {
     case 'economy': return cmdEconomy(!!values.json);
     case 'resume': return cmdResume(positionals[1]);
     case 'statusline': return cmdStatusline();
-    case 'sidecar': return cmdSidecar(values['state-dir'], !!values.hint);
+    case 'sidecar': return cmdSidecar(values['state-dir'], !!values.hint, !!values['exit-on-end']);
     case 'doctor': return require('../src/doctor').run();
     case 'launch': return cmdLaunch(positionals[1]);
     default: return cmdLaunch(cmd);               // anything else → treat as a CCS profile
@@ -163,14 +164,17 @@ function cmdResume(arg) {
  * `--state-dir <dir>` targets a specific session (used by the VS Code split-pane
  * one-liner, which is shell-agnostic). `--hint` reprints the VS Code split
  * instructions + re-copies the one-liner instead of running the panel.
+ * `--exit-on-end` closes the panel shortly after the session ends (the Windows
+ * Terminal launcher passes it so its `cmd /c` pane sweeps closed like tmux).
  * @param {string | undefined} stateDir
  * @param {boolean} [showHint]
+ * @param {boolean} [exitOnEnd]
  * @returns {number | undefined}
  */
-function cmdSidecar(stateDir, showHint) {
+function cmdSidecar(stateDir, showHint, exitOnEnd) {
   if (stateDir) process.env.CCR_STATE_DIR = stateDir;
   if (showHint) return require('../src/launch-vscode').hint(process.env.CCR_STATE_DIR || STATE_DIR);
-  require('../src/sidecar').run();
+  require('../src/sidecar').run({ exitOnEnd: !!exitOnEnd });
   return undefined;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-runrate",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Claude Code run-rate — subscription burn-rate & economy for your Claude Code sessions.",
   "license": "MIT",
   "author": "Bing Ho <reps-attic-riot@duck.com>",

package/src/launch-win.js

@@ -129,22 +129,57 @@ function paneCommand(stateDir, body) {
   return `set "CCR_STATE_DIR=${stateDir}"&& ${body}`;
 }
 
+/**
+ * Compute the column budget for the sidecar pane so it can clamp every line and
+ * never soft-wrap. `process.stdout.columns` inside the `cmd /c` conpty pane is
+ * unreliable (often undefined or the FULL window width, not the narrow split),
+ * so the launcher — whose own stdout DOES report the live terminal width —
+ * computes the pane width here and injects it as CCR_SIDECAR_COLS.
+ *
+ * A vertical split (-V, sidebar on the right) gets `frac` of the width, minus one
+ * column for the pane divider. A horizontal split (-H, sidebar on the bottom)
+ * keeps the full width. Returns null when the terminal width is unknown (non-TTY
+ * launch) — the sidecar then falls back to whatever it can detect.
+ *
+ * @param {number|undefined} termCols the launcher's own terminal width
+ * @param {number} fracNum the sidebar fraction (e.g. 0.34)
+ * @param {'-V'|'-H'} splitFlag
+ * @returns {number|null}
+ */
+function sidecarCols(termCols, fracNum, splitFlag) {
+  const t = Number(termCols);
+  if (!Number.isFinite(t) || t <= 0) return null;
+  if (splitFlag === '-H') return Math.max(20, Math.floor(t)); // bottom split keeps full width
+  return Math.max(20, Math.floor(t * fracNum) - 1);            // right split: fraction, less the divider
+}
+
 /**
  * Build the argv passed to wt.exe (excluding the wt.exe path itself):
- *   new-tab --title Claude cmd /k "<pane0>" ; split-pane -H -s <frac> cmd /k "<pane1>"
+ *   -w 0 new-tab --title Claude cmd /c "<pane0>" ; split-pane -H -s <frac> cmd /c "<pane1>"
+ *
+ * `-w 0` targets the CURRENT Windows Terminal window (open a tab in the window
+ * you ran `ccr` from) instead of spawning a separate window. The ";" pane
+ * separator is its own argv token (wt re-parses it); per-pane env is injected via
+ * `cmd /c set ...` rather than wt global env.
+ *
+ * Teardown mirrors the tmux launcher's sweep (launch.sh: `… ; touch exited; …;
+ * kill-session`): both panes run under `cmd /c`, so each closes when its command
+ * ends. On Claude exit pane 0 drops the `exited` sentinel and deletes the temp
+ * settings file; the sidecar runs with `--exit-on-end` so it detects the exit
+ * within ~120ms and closes pane 1 after a ~200ms grace (see sidecar.run).
  *
- * The ";" pane separator is its own argv token (wt re-parses it). Per-pane env
- * is injected via `cmd /k set ...` rather than wt global env. After Claude
- * exits, pane 0 (unconditional `&`) drops the `exited` sentinel (so the sidecar
- * can show a clean "session ended" state) and deletes the temp settings file
- * (cleanup-after-window-closes; the file was only needed at Claude startup).
+ * Close ORDER drives the sweep: pane 0 then lingers (SWEEP_LINGER ≈ 1s) past the
+ * sidecar's ~320ms close so the RIGHT pane collapses FIRST and Claude expands
+ * rightward to fill it — the sidebar border sweeps left→right and the tab folds,
+ * instead of pane 0 vanishing first and the sidecar ballooning right→left.
  *
  * Throws if any interpolated value contains a character that would break (or, in
- * the case of %, hijack) the cmd /k payload — see isWtArgSafe. run() catches
+ * the case of %, hijack) the cmd /c payload — see isWtArgSafe. run() catches
  * this and reports a clean error instead of spawning a broken command.
  *
  * @param {{ ccCmd: string, settingsFile: string, stateDir: string,
- *   node: string, ccrJs: string, sidebarPct?: number, sidebarSide?: string }} o
+ *   node: string, ccrJs: string, sidebarPct?: number, sidebarSide?: string,
+ *   termCols?: number }} o
  * @returns {string[]}
  */
 function buildWtArgs(o) {
@@ -167,16 +202,31 @@ function buildWtArgs(o) {
   const splitFlag = sidebarSplitFlag(o.sidebarSide);
   const exited = path.win32.join(stateDir, 'exited');
 
+  // After Claude exits we drop the sentinel + clean the settings file, then idle
+  // ~1s so pane 1 (which now detects the exit within ~120ms and closes after a
+  // ~200ms grace) folds FIRST and the border sweeps left→right. `ping -n 2`
+  // loopback is a reliable ~1s — its fixed inter-ping gap can't undershoot the
+  // sidecar's close the way `timeout /t 1` (0–1s, second-aligned) could, and it
+  // has none of `timeout`'s stdin quirks. ~1s is the floor: cmd.exe's wait
+  // primitives have 1-second granularity, so a tighter robust delay isn't
+  // available without fragile tricks. Silent under `>nul`.
+  const SWEEP_LINGER = 'ping -n 2 127.0.0.1 >nul';
   const pane0 = paneCommand(
     stateDir,
-    `${ccCmd} --settings "${settingsFile}" & type nul > "${exited}" & del /q "${settingsFile}"`,
+    `${ccCmd} --settings "${settingsFile}" & type nul > "${exited}" & del /q "${settingsFile}" & ${SWEEP_LINGER}`,
   );
-  const pane1 = paneCommand(stateDir, `"${node}" "${ccrJs}" sidecar`);
+  // Inject the computed pane width so the sidecar clamps cleanly even when its own
+  // process.stdout.columns is unreliable inside the cmd /c conpty pane.
+  const cols = sidecarCols(o.termCols, Number(frac), splitFlag);
+  const sidecarBody =
+    (cols != null ? `set "CCR_SIDECAR_COLS=${cols}"&& ` : '') +
+    `"${node}" "${ccrJs}" sidecar --exit-on-end`;
+  const pane1 = paneCommand(stateDir, sidecarBody);
 
   return [
-    'new-tab', '--title', 'Claude', 'cmd', '/k', pane0,
+    '-w', '0', 'new-tab', '--title', 'Claude', 'cmd', '/c', pane0,
     ';',
-    'split-pane', splitFlag, '-s', frac, 'cmd', '/k', pane1,
+    'split-pane', splitFlag, '-s', frac, 'cmd', '/c', pane1,
   ];
 }
 
@@ -221,6 +271,9 @@ function withDefaults(deps) {
   return {
     env,
     home,
+    // The launcher's own stdout reports the live terminal width — the sidecar's
+    // does not, inside its cmd /c pane (see sidecarCols). undefined on non-TTY.
+    cols: deps.cols != null ? deps.cols : process.stdout.columns,
     node: deps.node || process.execPath,
     ccrJs: deps.ccrJs || path.join(__dirname, '..', 'bin', 'ccr.js'),
     out: deps.out || ((s) => { process.stdout.write(s); }),
@@ -350,6 +403,7 @@ function run(profile, deps = {}) {
       ccrJs: d.ccrJs,
       sidebarPct: Number.isFinite(pct) ? pct : DEFAULT_SIDEBAR_PCT,
       sidebarSide: d.env.CCR_SIDEBAR_SIDE || DEFAULT_SIDEBAR_SIDE,
+      termCols: d.cols,
     });
   } catch (e) {
     d.err(`ccr: ${e instanceof Error ? e.message : String(e)}\n`);
@@ -370,6 +424,7 @@ function run(profile, deps = {}) {
  * @typedef {object} Deps
  * @property {NodeJS.ProcessEnv} env
  * @property {string} home
+ * @property {number|undefined} cols
  * @property {string} node
  * @property {string} ccrJs
  * @property {(s: string) => void} out
@@ -394,6 +449,7 @@ module.exports = {
   resolveProfileState,
   sidebarFraction,
   sidebarSplitFlag,
+  sidecarCols,
   buildWtArgs,
   findWindowsTerminal,
   run,

package/src/sidecar.js

@@ -105,17 +105,100 @@ function composeFrame(stateDir, opts = {}) {
   return clamp(out.endsWith('\n') ? out : out + '\n');
 }
 
+/**
+ * Resolve the column budget to clamp the panel to. `process.stdout.columns` is
+ * authoritative when present (live resize re-flows on the next frame), but inside
+ * the Windows launcher's `cmd /c` conpty pane it is unreliable — often undefined
+ * or the FULL window width rather than the narrow split. So the launcher injects
+ * the computed pane width as CCR_SIDECAR_COLS; we take the SMALLER of the two,
+ * which is safe whichever is wrong: a bogus full-width `columns` can't defeat the
+ * hint, and a missing hint (Linux/tmux, standalone `ccr sidecar`) leaves the live
+ * value untouched. Returns undefined only when neither is known (no clamp).
+ *
+ * @returns {number|undefined}
+ */
+function resolveCols() {
+  const live = process.stdout.columns;
+  const haveLive = typeof live === 'number' && live > 0;
+  const hint = parseInt(process.env.CCR_SIDECAR_COLS || '', 10);
+  const haveHint = Number.isFinite(hint) && hint > 0;
+  if (haveLive && haveHint) return Math.min(live, hint);
+  if (haveHint) return hint;
+  return haveLive ? live : undefined;
+}
+
 function frame() {
   // Read columns each tick so a live resize re-flows on the next frame.
-  draw(composeFrame(STATE_DIR, { now: Date.now(), cols: process.stdout.columns }));
+  draw(composeFrame(STATE_DIR, { now: Date.now(), cols: resolveCols() }));
 }
 
-function run() {
-  frame();
-  const id = setInterval(frame, 1000);
-  const stop = () => { clearInterval(id); process.exit(0); };
-  process.on('SIGINT', stop);
-  process.on('SIGTERM', stop);
+/**
+ * The live loop. With `exitOnEnd` (the Windows launcher passes `--exit-on-end`),
+ * the sidecar closes its own pane as soon as the `exited` sentinel appears — so a
+ * `cmd /c` pane folds away on session end rather than lingering, matching the tmux
+ * launcher's kill-session sweep. Without it (Linux/tmux, standalone `ccr sidecar`)
+ * the loop runs until signalled, exactly as before.
+ *
+ * For the fastest, correctly-ordered close, the sentinel is POLLED faster than the
+ * render cadence when `exitOnEnd` (a redraw is ~1s; waiting a full second just to
+ * NOTICE the exit would dominate the close time). A single interval ticks at
+ * `pollMs`; the expensive redraw is throttled to ~1s, while the cheap sentinel
+ * check runs every poll. On exit we paint "session ended" once and close after a
+ * short `graceMs`. The launcher's pane 0 then lingers slightly longer (see
+ * buildWtArgs) so this RIGHT pane closes first and the border sweeps left→right.
+ * Side effects are injectable so the end-sweep is unit-testable.
+ *
+ * @param {{ exitOnEnd?: boolean, stateDir?: string, graceMs?: number,
+ *   tick?: () => void, sentinelExists?: () => boolean,
+ *   setIntervalFn?: Function, setTimeoutFn?: Function,
+ *   clearIntervalFn?: Function, clearTimeoutFn?: Function,
+ *   exit?: () => void, onSignal?: (sig: string, handler: () => void) => void }} [opts]
+ * @returns {() => void} the stop handler (exposed for tests)
+ */
+function run(opts = {}) {
+  const stateDir = opts.stateDir || STATE_DIR;
+  const exitOnEnd = opts.exitOnEnd != null ? opts.exitOnEnd : (process.env.CCR_SIDECAR_EXIT_ON_END === '1');
+  // Tiny grace so the "session ended" frame paints before we close — kept short
+  // since this drives the close speed (the launcher tunes pane 0 to outlast it).
+  const graceMs = opts.graceMs != null ? opts.graceMs : 200;
+  const tick = opts.tick || frame;
+  const sentinelExists = opts.sentinelExists || (() => fs.existsSync(path.join(stateDir, 'exited')));
+  const setIntervalFn = opts.setIntervalFn || setInterval;
+  const setTimeoutFn = opts.setTimeoutFn || setTimeout;
+  const clearIntervalFn = opts.clearIntervalFn || clearInterval;
+  const clearTimeoutFn = opts.clearTimeoutFn || clearTimeout;
+  const exit = opts.exit || (() => process.exit(0));
+  const onSignal = opts.onSignal || ((sig, handler) => process.on(sig, handler));
+
+  // Poll the sentinel fast when we have to detect the end; keep the redraw at ~1s.
+  const RENDER_MS = 1000;
+  const pollMs = exitOnEnd ? 120 : RENDER_MS;
+
+  let id = null;
+  let endTimer = null;
+  let sinceRender = RENDER_MS; // render on the first loop
+  const stop = () => {
+    if (id != null) clearIntervalFn(id);
+    if (endTimer != null) clearTimeoutFn(endTimer);
+    exit();
+  };
+  const checkEnd = () => {
+    // Once the session has ended, paint it once then sweep this pane closed.
+    if (exitOnEnd && endTimer == null && sentinelExists()) {
+      tick();
+      endTimer = setTimeoutFn(stop, graceMs);
+    }
+  };
+  const loop = () => {
+    sinceRender += pollMs;
+    if (sinceRender >= RENDER_MS) { sinceRender = 0; tick(); }
+    checkEnd();
+  };
+  loop();
+  id = setIntervalFn(loop, pollMs);
+  onSignal('SIGINT', stop);
+  onSignal('SIGTERM', stop);
+  return stop;
 }
 
 // `updateFeed` + `composeFrame` are exported for tests (the incremental tail +