@crouton-kit/crouter 0.3.78 → 0.3.80

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,10 +218,14 @@ 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');

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__/mermaid-render.test.js

@@ -1,6 +1,14 @@
 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]
@@ -10,7 +18,7 @@ flowchart LR
     B --> C
     C --> U
 \`\`\``;
-test('renders the applet concierge flowchart after provisioning termrender', () => {
+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/);

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+Shift+P'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 {};