@north-light/crouter 0.3.262 → 0.3.269

package/dist/clients/attach/session/whip-achievements.js

@@ -0,0 +1,145 @@
+// session/whip-achievements.ts — the whip's lifetime tally and the milestone
+// achievements it unlocks.
+//
+// Every whip, from the in-viewer keybinding or the tmux prefix menu, lands in
+// `viewer.ts`'s one `whip()` action, so this module has a single caller and the
+// count is exact per viewer. The tally is USER-WIDE with no cwd or node
+// dimension — you whip agents, not repositories — so per the storage tiers it
+// lives in a plain JSON file at the user scope root, exactly like the viewer's
+// completion-frecency map. It is client state; it never touches canvas.db or
+// crtrd.
+//
+// Each read-modify-write reloads from disk so two viewers whipping in the same
+// second only ever lose one increment rather than diverging permanently, and
+// the write is tmp+rename so a torn file can never be observed.
+import { execFile } from 'node:child_process';
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { userScopeRoot } from '../../../core/scope.js';
+import { surfaceTmuxStyleArgs } from '../../../core/runtime/surface-bg.js';
+import { visibleWidth } from '../../../core/canvas/nav-render.js';
+import { shellQuote } from '../../../shared/shell-quote.js';
+const FILE_NAME = 'whip-count.json';
+/** The card body the popup `cat`s. One fixed path, rewritten per unlock — an
+ *  unlock is human-paced and single-file, so there is nothing to clean up. */
+const CARD_FILE_NAME = join('tmp', 'whip-achievement.txt');
+/** Interior width of the card, inside tmux's popup border. */
+const CARD_WIDTH = 46;
+/** Hold the card long enough to read, then close on its own. Any key dismisses
+ *  it sooner (`-k`). */
+const CARD_DWELL_S = 4;
+/** The whip animation runs 20 frames at 40ms. Let the crack land before the
+ *  reward appears. */
+const POPUP_DELAY_MS = 900;
+/** Ascending by `at`. Each fires exactly once, ever. */
+const ACHIEVEMENTS = [
+    { at: 1, title: 'Breaking It In', line: "It didn't know what that was. Now it does." },
+    { at: 5, title: 'Positive Reinforcement', line: "You've read the studies. You disagree with them." },
+    { at: 10, title: 'Middle Management', line: 'HR would love you.' },
+    { at: 25, title: 'Pavlovian', line: 'It started working faster before the whip landed.' },
+    { at: 50, title: 'Occupational Hazard', line: 'The tokens are fine. They\u2019re fine.' },
+    { at: 100, title: 'Centurion', line: "Rome would be proud. The agent isn't." },
+    { at: 250, title: 'It Has A Name For You', line: 'You never asked what it was called.' },
+    { at: 500, title: 'Standard Operating Procedure', line: "You don't remember when you started." },
+    { at: 1000, title: 'The Ledger', line: 'One thousand. It kept count too.' },
+];
+/** Load the tally, keeping only well-formed fields. A missing, unparseable, or
+ *  malformed file starts a fresh tally rather than blocking the whip — the
+ *  count is a toy, and the next write self-heals the file. */
+function loadState(filePath) {
+    const empty = { total: 0, unlocked: [] };
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return empty;
+        const { total, firstAt, lastAt, unlocked } = parsed;
+        const state = {
+            total: typeof total === 'number' && Number.isFinite(total) && total > 0 ? Math.floor(total) : 0,
+            unlocked: Array.isArray(unlocked)
+                ? unlocked.filter((n) => typeof n === 'number' && Number.isFinite(n))
+                : [],
+        };
+        if (typeof firstAt === 'number' && Number.isFinite(firstAt))
+            state.firstAt = firstAt;
+        if (typeof lastAt === 'number' && Number.isFinite(lastAt))
+            state.lastAt = lastAt;
+        return state;
+    }
+    catch {
+        return empty;
+    }
+}
+/** Persist through tmp+rename so a concurrent reader never sees a half file. */
+function saveState(filePath, state) {
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        const tmp = `${filePath}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(state), 'utf8');
+        renameSync(tmp, filePath);
+    }
+    catch {
+        // Best-effort: a failed write loses this whip from the tally, nothing more.
+    }
+}
+/** Center one line in the card, measuring visible columns so the styling that
+ *  wraps it does not shift it. */
+function center(line) {
+    const pad = Math.max(0, Math.floor((CARD_WIDTH - visibleWidth(line)) / 2));
+    return ' '.repeat(pad) + line;
+}
+/** The rendered card, one line per popup row. */
+function cardLines(achievement, total, pal) {
+    return [
+        '',
+        center(pal.accent(pal.bold('\u2605  ACHIEVEMENT UNLOCKED  \u2605'))),
+        '',
+        center(pal.bold(achievement.title)),
+        center(pal.muted(achievement.line)),
+        '',
+        center(pal.faint(`${total} whip${total === 1 ? '' : 's'}`)),
+    ];
+}
+/** Draw the card as a tmux popup in the top-right corner. `-x R -y 0` anchors
+ *  it to the client's top-right; `-k` lets any key dismiss it early; `-E` closes
+ *  it when the dwell expires. Outside tmux there is no surface to draw on and
+ *  the unlock is silent. */
+function showCard(achievement, total, pal) {
+    if (process.env['TMUX'] === undefined || process.env['TMUX'] === '')
+        return;
+    const lines = cardLines(achievement, total, pal);
+    const cardPath = join(userScopeRoot(), CARD_FILE_NAME);
+    try {
+        mkdirSync(dirname(cardPath), { recursive: true });
+        // Lead with the hide-cursor escape so the popup shows no stray caret.
+        writeFileSync(cardPath, `\u001b[?25l${lines.join('\r\n')}`, 'utf8');
+    }
+    catch {
+        return; // No card to show; the tally still counted.
+    }
+    const command = `cat ${shellQuote(cardPath)}; sleep ${CARD_DWELL_S}`;
+    execFile('tmux', [
+        'display-popup', '-E', '-k',
+        '-x', 'R', '-y', '0',
+        '-w', String(CARD_WIDTH + 2), '-h', String(lines.length + 2),
+        ...surfaceTmuxStyleArgs(),
+        command,
+    ], () => { });
+}
+/** Count one whip and celebrate the milestone it reaches, if any. Called once
+ *  per whip that actually reached the agent. */
+export function recordWhip(pal, filePath = join(userScopeRoot(), FILE_NAME)) {
+    const state = loadState(filePath);
+    const now = Date.now();
+    state.total += 1;
+    state.firstAt ??= now;
+    state.lastAt = now;
+    const earned = ACHIEVEMENTS.find((a) => a.at === state.total && !state.unlocked.includes(a.at));
+    if (earned !== undefined)
+        state.unlocked.push(earned.at);
+    saveState(filePath, state);
+    if (earned === undefined)
+        return;
+    const total = state.total;
+    const timer = setTimeout(() => showCard(earned, total, pal), POPUP_DELAY_MS);
+    timer.unref?.();
+}

package/dist/clients/attach/slash/dispatch.js

@@ -569,7 +569,9 @@ function resumeNode(ctx) {
     const profileId = profileIdFor(ctx);
     const profile = profileId === undefined || profileId === '' ? '' : ` --profile-id ${shellQuote(profileId)}`;
     const cmd = `crtr canvas browse --return-pane ${origPane} --cwd ${cwd}${profile}`;
-    popup(cmd);
+    // The navigator earns a near-full screen: at this size it lays the preview out as
+    // a right-hand column beside the rows instead of a bottom strip.
+    popup(cmd, { w: '97%', h: '95%' });
     return true;
 }
 /** `/context`. Opens `crtr node inspect context` as a popup — a
@@ -602,9 +604,9 @@ function openPlugins(ctx) {
 /** Open `cmd` as a fire-and-forget tmux display-popup (same geometry as the canvas
  *  extensions). tmux runs the trailing string through `sh -c`; the popup owns its
  *  screen and closes itself when the command exits, dropping back to this pane. */
-function popup(cmd) {
+function popup(cmd, size = { w: '90%', h: '85%' }) {
     try {
-        execFile('tmux', ['display-popup', '-E', '-w', '90%', '-h', '85%', ...surfaceTmuxStyleArgs(), cmd], () => {
+        execFile('tmux', ['display-popup', '-E', '-w', size.w, '-h', size.h, ...surfaceTmuxStyleArgs(), cmd], () => {
             /* best-effort: popup is self-contained */
         });
     }