@crouton-kit/crouter 0.3.70 → 0.3.79

package/dist/clients/attach/__tests__/attach-chrome-remote.test.js

@@ -29,6 +29,7 @@ import { openFocusRow } from '../../../core/canvas/focuses.js';
 import { jobDir } from '../../../core/canvas/paths.js';
 import { recordFault } from '../../../core/runtime/fault.js';
 import { BG_ATTACHED } from '../../../core/canvas/nav-model.js';
+import { resolveKeybindings } from '../../../core/keybindings/index.js';
 import { dispatchSlashCommand, slashCommandList } from '../slash-commands.js';
 import { resolveInitialMode, requestModeSwitch, tagAttachPane, untagAttachPane, reapOnDetach, } from '../attach-cmd.js';
 import { buildCanvasPanelLines } from '../canvas-panels.js';
@@ -198,7 +199,7 @@ test('GraphOverlay suppresses every local-read adornment for a RemoteCanvasSourc
     t.after(() => server.close());
     const source = new RemoteCanvasSource(server.url, 'tok');
     const { tui } = fakeTui();
-    const overlay = new GraphOverlay(tui, 'root', () => ({}), IDENTITY_PALETTE, source);
+    const overlay = new GraphOverlay(tui, 'root', () => ({}), IDENTITY_PALETTE, resolveKeybindings(), source);
     overlay.open();
     // buildSnapshot() is async (chased through the mock server); poll for it to land.
     for (let i = 0; i < 100 && overlay.snapshot === undefined; i++) {
@@ -217,17 +218,21 @@ test('GraphOverlay suppresses every local-read adornment for a RemoteCanvasSourc
     // effect of a real `focusTarget` dispatch) — it must no-op instead.
     overlay.handleInput('\r');
     assert.equal(overlay.isOpen(), true, 'Enter must not act (close) on a remote graph row');
-    // x must NOT arm the y/n kill confirm — render() would show it in the hint.
+    // x must NOT arm the close confirm on a remote row. The confirmation UI never
+    // literally contains legacy `y/n`, so assert the real state directly:
+    // pendingConfirm stays unset and no `kill …?` accept/cancel prompt renders.
     overlay.handleInput('x');
+    assert.equal(overlay.pendingConfirm, undefined, 'x must not arm pendingConfirm on a remote graph row');
     const afterX = overlay.render(100).join('\n');
-    assert.ok(!afterX.includes('y/n'), `x must not arm a kill confirm on a remote graph row: ${afterX}`);
+    assert.ok(!afterX.includes('kill'), `x must not surface a kill confirm prompt on a remote graph row: ${afterX}`);
+    assert.ok(!/accept|cancel/.test(afterX), `x must not surface an accept/cancel confirm on a remote graph row: ${afterX}`);
     // m must NOT close the overlay either (it would focusTarget the manager).
     overlay.handleInput('m');
     assert.equal(overlay.isOpen(), true, 'm must not act (close) on a remote graph row');
 });
 // ---------------------------------------------------------------------------
 // Phase 3 review 2 — the ENCLOSING attach viewer (slash commands, pane tag,
-// detach-reap, Alt+M mode-switch), not just the GraphOverlay/panel rendering
+// detach-reap, Alt+Shift+P mode-switch), not just the GraphOverlay/panel rendering
 // the fix above already covers. Same adversarial shape: seed colliding LOCAL
 // state for the remote node id `a`, then assert the remote path never touches
 // it — and, symmetrically, that the LOCAL path is byte-for-byte unchanged
@@ -332,10 +337,10 @@ test('resolveInitialMode/requestModeSwitch never touch the local mode-switch rea
         lastWrite = { cwd, nodeId, mode };
     };
     const remoteOk = requestModeSwitch('/tmp/cwd', 'a', true, 'spec', writeRequest);
-    assert.equal(remoteOk, false, 'remote Alt+M must no-op (return false)');
+    assert.equal(remoteOk, false, 'remote Alt+Shift+P must no-op (return false)');
     assert.equal(writes, 0, 'remote must never write the local mode-switch request file');
     const localOk = requestModeSwitch('/tmp/cwd', 'a', false, 'spec', writeRequest);
-    assert.equal(localOk, true, 'local Alt+M must still write through');
+    assert.equal(localOk, true, 'local Alt+Shift+P must still write through');
     assert.equal(writes, 1, 'local must call the injected local writer exactly once');
     assert.deepEqual(lastWrite, { cwd: '/tmp/cwd', nodeId: 'a', mode: 'spec' });
 });

package/dist/clients/attach/__tests__/attach-keybindings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/attach-keybindings.test.js

@@ -0,0 +1,113 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveKeybindings } from '../../../core/keybindings/index.js';
+import { detachHint, dispatchAttachBinding, matchesAttachBinding, refreshAttachBindingSnapshot, } from '../attach-cmd.js';
+import { GraphOverlay } from '../graph-overlay.js';
+const PALETTE = {
+    accent: (s) => s,
+    active: (s) => s,
+    info: (s) => s,
+    muted: (s) => s,
+    faint: (s) => s,
+    border: (s) => s,
+    bold: (s) => s,
+    error: (s) => s,
+    warning: (s) => s,
+    bashMode: (s) => s,
+    bashModeAlt: (s) => s,
+    surface: (s) => s,
+};
+function fakeTui() {
+    return {
+        showOverlay: () => ({ hide: () => { } }),
+        requestRender: () => { },
+    };
+}
+test('attach input dispatches only the current configured action', () => {
+    const bindings = resolveKeybindings({
+        'crtr.attach.detach': ['ctrl+x'],
+        'crtr.attach.clear-or-detach': [],
+        'crtr.attach.graph.toggle': [],
+        'crtr.mode.cycle': ['alt+x'],
+        'crtr.attach.model-ladder.next': ['alt+z'],
+    });
+    const calls = [];
+    const actions = {
+        'crtr.attach.detach': () => calls.push('detach'),
+        'crtr.attach.clear-or-detach': () => calls.push('clear'),
+        'crtr.attach.graph.toggle': () => calls.push('graph'),
+        'crtr.mode.cycle': () => calls.push('mode'),
+        'crtr.attach.model-ladder.next': () => calls.push('ladder'),
+    };
+    assert.equal(dispatchAttachBinding(bindings, '\x18', actions), true);
+    assert.equal(dispatchAttachBinding(bindings, '\x04', actions), false, 'old detach must not reach the listener action');
+    assert.equal(dispatchAttachBinding(bindings, '\x1bg', actions), false, 'disabled graph must not reach the listener action');
+    assert.equal(dispatchAttachBinding(bindings, '\x1bx', actions), true);
+    assert.equal(dispatchAttachBinding(bindings, '\x1bm', actions), false, 'old mode key must not reach the listener action');
+    assert.equal(dispatchAttachBinding(bindings, '\x1bz', actions), true);
+    assert.equal(dispatchAttachBinding(bindings, '\x1bM', actions), false, 'old ladder key must not reach the listener action');
+    assert.deepEqual(calls, ['detach', 'mode', 'ladder']);
+    assert.equal(detachHint(bindings), 'Ctrl+X', 'disabled clear-or-detach must fall back to enabled detach');
+    const noDetach = resolveKeybindings({ 'crtr.attach.detach': [], 'crtr.attach.clear-or-detach': [] });
+    assert.equal(detachHint(noDetach), undefined, 'a disabled pair must not render "Disabled to detach"');
+});
+test('attach startup and reload replace the dispatch/GRAPH snapshots and install each tmux snapshot', () => {
+    const first = resolveKeybindings({ 'crtr.attach.detach': ['ctrl+x'], 'crtr.graph.focus': ['f'] });
+    const second = resolveKeybindings({ 'crtr.attach.detach': ['ctrl+z'], 'crtr.graph.focus': ['r'] });
+    const snapshots = [first, second];
+    const graphSnapshots = [];
+    const installed = [];
+    let active = refreshAttachBindingSnapshot(() => snapshots.shift(), (bindings) => graphSnapshots.push(bindings), () => true, (bindings) => installed.push(bindings));
+    assert.equal(matchesAttachBinding(active, 'crtr.attach.detach', '\x18'), true, 'startup snapshot drives attach dispatch');
+    assert.equal(active.gestures('crtr.graph.focus')[0], 'f', 'startup snapshot reaches GRAPH');
+    active = refreshAttachBindingSnapshot(() => snapshots.shift(), (bindings) => graphSnapshots.push(bindings), () => true, (bindings) => installed.push(bindings));
+    assert.equal(matchesAttachBinding(active, 'crtr.attach.detach', '\x18'), false, 'reload replaces the old attach snapshot');
+    assert.equal(matchesAttachBinding(active, 'crtr.attach.detach', '\x1a'), true, 'reload dispatches through the new attach snapshot');
+    assert.equal(active.gestures('crtr.graph.focus')[0], 'r', 'reload replaces GRAPH bindings too');
+    assert.deepEqual(graphSnapshots, [first, second]);
+    assert.deepEqual(installed, [first, second], 'the unified tmux installer receives startup and reload snapshots');
+});
+test('GRAPH navigation and hints use effective bindings rather than default literals', () => {
+    const bindings = resolveKeybindings({
+        'crtr.graph.down': ['z'],
+        'crtr.graph.up': [],
+        'crtr.graph.focus': ['f'],
+        'crtr.graph.close-subtree': [],
+        'crtr.graph.dismiss': ['q'],
+        'crtr.graph.confirm.accept': ['t'],
+        'crtr.graph.confirm.cancel': ['c'],
+    });
+    const overlay = new GraphOverlay(fakeTui(), 'a', () => ({}), PALETTE, bindings);
+    const internal = overlay;
+    internal.cursorId = 'a';
+    internal.snapshot = {
+        rows: [
+            { id: 'a', hasKids: false, isSelf: true, branch: '', cycle: false, collapsed: false },
+            { id: 'b', hasKids: false, isSelf: false, branch: '', cycle: false, collapsed: false },
+        ],
+        activeBelow: new Map(),
+        nodes: new Map([['a', null], ['b', null]]),
+        childIds: new Map(),
+        sortedChildIds: new Map(),
+        managerOf: new Map(),
+        focused: new Set(),
+    };
+    overlay.handleInput('j');
+    assert.equal(internal.cursorId, 'a', 'replaced default must stop matching');
+    overlay.handleInput('z');
+    assert.equal(internal.cursorId, 'b', 'replacement must drive navigation');
+    const rendered = overlay.render(58).join('\n');
+    assert.match(rendered, /F focus/, 'narrow GRAPH footer must prioritize remapped local focus');
+    assert.match(rendered, /Q dismiss/, 'narrow GRAPH footer must prioritize remapped dismiss');
+    assert.doesNotMatch(rendered, /close/);
+    assert.doesNotMatch(rendered, /J down/);
+    assert.doesNotMatch(rendered, /Disabled/);
+    let closed = 0;
+    internal.pendingConfirm = { label: 'close b?', action: () => { closed++; } };
+    assert.match(overlay.render(80).join('\n'), /T accept · C cancel/);
+    overlay.handleInput('y');
+    assert.equal(closed, 0, 'replaced accept default must stop confirming');
+    internal.pendingConfirm = { label: 'close b?', action: () => { closed++; } };
+    overlay.handleInput('t');
+    assert.equal(closed, 1, 'replacement must confirm close');
+});

package/dist/clients/attach/__tests__/crtr-output-render.test.js

@@ -1996,7 +1996,7 @@ const SYS_SETUP_OUTPUT = [
     '',
     'Packages:',
     '- pi-crtr-extensions — crtr companion extensions. (installed)',
-    '- pi-mode-switch — Alt+M mode cycling. (installed)',
+    '- pi-mode-switch — Alt+Shift+P mode cycling. (installed)',
     '- pi-claude-oauth-adapter — OAuth adapter. (not installed)',
     '',
     'System deps:',

package/dist/clients/attach/__tests__/mermaid-render.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/mermaid-render.test.js

@@ -0,0 +1,28 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { ensureRenderer, isRendererReady } from '@crouton-kit/humanloop';
+import { transformMermaidFences } from '../mermaid-render.js';
+// This asserts a REAL termrender render (box-drawing glyphs), so it only holds
+// once the managed renderer is provisioned — true in the full tier and on a dev
+// box, but the fast tier is deliberately termrender-free (no uv to provision the
+// venv). Skip cleanly when the renderer is unavailable, exactly as the tmux
+// tests skip when tmux is absent, rather than failing on the environment.
+ensureRenderer();
+const SKIP = !isRendererReady() ? 'termrender renderer unavailable' : false;
+const APPLET_CONCIERGE_FLOW = `\`\`\`mermaid
+flowchart LR
+    U[User] --> C[Applet concierge]
+    C --> B[Applet-builder developer node<br/>cwd = app repo]
+    B --> D[Platform deploy command]
+    D --> B
+    B --> C
+    C --> U
+\`\`\``;
+test('renders the applet concierge flowchart after provisioning termrender', { skip: SKIP }, () => {
+    const rendered = transformMermaidFences(APPLET_CONCIERGE_FLOW, 200);
+    assert.match(rendered, /Applet-builder/);
+    assert.match(rendered, /cwd = app repo/);
+    assert.match(rendered, /Platform deploy/);
+    assert.match(rendered, /[\u2500-\u259F\u25A0-\u25FF]/);
+    assert.doesNotMatch(rendered, /```mermaid/);
+});

package/dist/clients/attach/__tests__/oauth-dialog-lifecycle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/oauth-dialog-lifecycle.test.js

@@ -0,0 +1,110 @@
+// oauth-dialog-lifecycle.test.ts — review mrf68z4h (OAuth dialog lifecycle).
+//
+// Two attach-viewer regressions, proven against a REAL InputController built from
+// minimal fakes:
+//
+//   A. An unrelated extension `notify` must NOT tear down a blocking dialog whose
+//      broker request is still pending. (The old code dismissed the active dialog
+//      on ANY notify — leaving the request unanswered in the broker and the user
+//      with no way to answer it.)
+//   B. A broker-driven `extension_ui_dismiss` (the correlated cleanup emitted when
+//      a dialog's request is aborted/timed out out-of-band) tears down ONLY the
+//      overlay whose id matches, never an unrelated one.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { initTheme } from '@earendil-works/pi-coding-agent';
+import { InputController } from '../input-controller.js';
+// pi's ExtensionInputComponent reads the process-global theme in its constructor
+// (the broker calls initTheme() at boot); initialize it once so renderDialog can
+// build a real dialog component here.
+initTheme(undefined, false);
+function fakeEditor() {
+    const actions = new Map();
+    const obj = {
+        onSubmit: undefined,
+        onEscape: undefined,
+        onPasteImage: undefined,
+        onAction: (name, cb) => { actions.set(name, cb); },
+        getText: () => '',
+        setText: () => { },
+        addToHistory: () => { },
+        insertTextAtCursor: () => { },
+    };
+    return { obj };
+}
+/** A TUI fake whose `showOverlay` returns a handle whose `hide()` is observable,
+ *  so a test can tell whether a dialog was actually torn down. */
+function fakeTui() {
+    const hides = [];
+    let seq = 0;
+    const tui = {
+        requestRender: () => { },
+        setFocus: () => { },
+        showOverlay: () => {
+            const label = `overlay-${seq++}`;
+            return { hide: () => hides.push(label), label };
+        },
+        start: () => { },
+        stop: () => { },
+    };
+    return { tui, hides };
+}
+function buildController() {
+    const notices = [];
+    const editor = fakeEditor();
+    const { tui, hides } = fakeTui();
+    const ic = new InputController(tui, editor.obj, {}, {
+        onCommand: () => { },
+        onDialogResponse: () => { },
+        onNotice: (m) => notices.push(m),
+    });
+    return { ic, notices, hides };
+}
+const inputDialog = (id) => ({
+    type: 'extension_ui_request',
+    id,
+    method: 'input',
+    title: 'Paste the redirect URL or code',
+    placeholder: 'http://localhost/callback?...',
+});
+const notify = (message) => ({
+    type: 'extension_ui_request',
+    id: 'notify-1',
+    method: 'notify',
+    message,
+    notifyType: 'info',
+});
+test('an unrelated notify does NOT dismiss an active blocking dialog (its broker request stays live)', () => {
+    const { ic, notices, hides } = buildController();
+    ic.attachDialog(inputDialog('oauth-manual-1'));
+    assert.equal(hides.length, 0, 'the dialog overlay is up, not torn down');
+    // An unrelated extension fires a notify while the blocking dialog is showing.
+    ic.attachDialog(notify('Some unrelated background progress'));
+    assert.equal(hides.length, 0, 'the blocking dialog must remain on screen — a notify is NOT a dismissal signal');
+    assert.ok(notices.some((n) => /unrelated background progress/i.test(n)), `the notify still shows as a notice line, got: ${JSON.stringify(notices)}`);
+});
+test('extension_ui_dismiss tears down ONLY the overlay whose request id matches', () => {
+    const { ic, hides } = buildController();
+    ic.attachDialog(inputDialog('oauth-manual-1'));
+    assert.equal(hides.length, 0);
+    // A dismiss for a DIFFERENT request id must be a no-op.
+    ic.dismissDialog('some-other-request');
+    assert.equal(hides.length, 0, 'a non-matching dismiss must not tear down the current dialog');
+    // The correlated dismiss for THIS dialog's id tears it down.
+    ic.dismissDialog('oauth-manual-1');
+    assert.equal(hides.length, 1, 'the matching correlated dismiss tears down exactly the current overlay');
+    // Idempotent: a repeat dismiss (or a late one after teardown) is inert.
+    ic.dismissDialog('oauth-manual-1');
+    assert.equal(hides.length, 1, 'a repeat dismiss must not double-tear-down');
+});
+test('a new blocking dialog still supersedes the previous one (control-handoff re-route unaffected)', () => {
+    const { ic, hides } = buildController();
+    ic.attachDialog(inputDialog('dialog-a'));
+    ic.attachDialog(inputDialog('dialog-b'));
+    assert.equal(hides.length, 1, 'the first dialog is superseded (dismissed) when a second blocking dialog arrives');
+    // Now a correlated dismiss for the OLD id must not touch the current one.
+    ic.dismissDialog('dialog-a');
+    assert.equal(hides.length, 1, 'a stale dismiss for the superseded dialog does not tear down the current one');
+    ic.dismissDialog('dialog-b');
+    assert.equal(hides.length, 2, 'the current dialog is torn down by its own correlated dismiss');
+});

package/dist/clients/attach/attach-cmd.d.ts

@@ -1,12 +1,19 @@
 import { CombinedAutocompleteProvider } from '@earendil-works/pi-tui';
 import type { BranchDef } from '../../core/command.js';
 import type { BrokerSnapshot, ClientRole } from '../../core/runtime/broker-protocol.js';
+import { type BindingId, type BindingResolution } from '../../core/keybindings/index.js';
 import { type AttachPalette } from './config-load.js';
 export type Mode = 'normal' | 'spec' | 'plan';
+type AttachBindingId = Extract<BindingId, `crtr.attach.${string}` | 'crtr.mode.cycle'>;
+type AttachBindings = BindingResolution<BindingId>;
+export declare function matchesAttachBinding(bindings: AttachBindings, id: AttachBindingId, data: string): boolean;
+export declare function dispatchAttachBinding(bindings: AttachBindings, data: string, actions: Record<AttachBindingId, () => void>): boolean;
+export declare function detachHint(bindings: AttachBindings): string | undefined;
+export declare function refreshAttachBindingSnapshot(resolve: () => AttachBindings, setGraphBindings: (bindings: AttachBindings) => void, inTmuxNow: () => boolean, install: (bindings: AttachBindings) => void): AttachBindings;
 /** Resolve the mode badge's initial state. Remote never reads the local
  *  mode-switch `current` file for `nodeId` — always starts 'normal'. */
 export declare function resolveInitialMode(cwd: string, nodeId: string, remote: boolean, readMode?: (cwd: string, nodeId: string) => Mode | undefined): Mode;
-/** Handle Alt+M's mode-cycle request. Remote no-ops entirely (returns `false`,
+/** Handle a configured mode-cycle request. Remote no-ops entirely (returns `false`,
  *  so the caller leaves `modeState`/the badge untouched) — there is no
  *  remote-safe mode-switch protocol, and writing the local `request.json` for a
  *  remote node id would target the wrong (or a colliding local) node. */
@@ -46,3 +53,4 @@ export declare function buildAttachAutocompleteProvider(cwd: string, fdPath: str
     description?: string;
 }>, cwd: string, fdPath: string | null) => CombinedAutocompleteProvider): CombinedAutocompleteProvider;
 export declare function registerAttach(): BranchDef;
+export {};