@crouton-kit/crouter 0.3.68 → 0.3.78

package/dist/builtin-views/settings/tui.mjs

@@ -61,8 +61,8 @@ export function render(state, draw, content) {
   }
 
   const header = state.edit
-    ? `Replacing ${state.edit.label} — Enter saves, Esc cancels`
-    : 'j/k move · h/l switch matrix cell · enter edit · g refresh';
+    ? `Replacing ${state.edit.label} — submit saves, cancel discards`
+    : 'Move · switch matrix cell · edit · refresh';
   draw.text(content.row, content.col, 'Model ladders', { bold: true });
   draw.text(content.row + 1, content.col, header, { dim: true });
   if (state.edit) {
@@ -76,14 +76,14 @@ export function render(state, draw, content) {
 }
 
 export const keymap = [
-  { keys: ['j', 'down'], intent: 'cursorDown', when: (s) => !s.edit, hint: { keys: 'j/k', label: 'move' } },
-  { keys: ['k', 'up'], intent: 'cursorUp', when: (s) => !s.edit },
-  { keys: ['h', 'left'], intent: 'matrixLeft', when: (s) => !s.edit, hint: { keys: 'h/l', label: 'switch cell' } },
-  { keys: ['l', 'right'], intent: 'matrixRight', when: (s) => !s.edit },
-  { keys: ['g'], intent: 'refresh', when: (s) => !s.edit, hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+  { bindingId: 'crtr.view.settings.down', intent: 'cursorDown', when: (s) => !s.edit, hint: { label: 'move' } },
+  { bindingId: 'crtr.view.settings.up', intent: 'cursorUp', when: (s) => !s.edit },
+  { bindingId: 'crtr.view.settings.cell-previous', intent: 'matrixLeft', when: (s) => !s.edit, hint: { label: 'switch cell' } },
+  { bindingId: 'crtr.view.settings.cell-next', intent: 'matrixRight', when: (s) => !s.edit },
+  { bindingId: 'crtr.view.settings.refresh', intent: 'refresh', when: (s) => !s.edit, hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.settings.quit', intent: 'quit', hint: { label: 'quit' } },
   { capture: 'setDraft', when: (s) => !!s.edit },
-  { keys: ['enter', 'return'], intent: 'submitEdit', when: (s) => !!s.edit },
-  { keys: ['enter', 'return'], intent: 'beginEdit', when: (s) => !s.edit, hint: { keys: 'enter', label: 'edit' } },
-  { keys: ['escape', 'esc'], intent: 'cancelEdit', when: (s) => !!s.edit },
+  { bindingId: 'crtr.view.settings.edit-or-submit', intent: 'submitEdit', when: (s) => !!s.edit },
+  { bindingId: 'crtr.view.settings.edit-or-submit', intent: 'beginEdit', when: (s) => !s.edit, hint: { label: 'edit' } },
+  { bindingId: 'crtr.view.settings.cancel-edit', intent: 'cancelEdit', when: (s) => !!s.edit },
 ];

package/dist/builtin-views/workspace-sidebar/tui.mjs

@@ -115,7 +115,7 @@ export function render(state, draw, content) {
     }
     emptyState(draw, content, {
       headline: 'No agents here',
-      secondary: ['Nothing started in this cwd.', 'Press g to refresh.'],
+      secondary: ['Nothing started in this cwd.', 'Refresh to try again.'],
     });
     return;
   }
@@ -128,15 +128,14 @@ export function render(state, draw, content) {
 // ── keymap ───────────────────────────────────────────────────────────────
 
 /**
- * j/k move the cursor over node rows, ↵ swaps the selected node into the chat
- * pane (the controller action), g refreshes, q quits. Footer hints come from
- * these bindings' `hint` fields (the single source of truth).
+ * Move over node rows, open the selected node in the chat pane, refresh, or
+ * leave the view. Footer hints use the host-resolved binding gestures.
  * @type {import('../../core/view/contract.js').KeyBinding<SidebarState>[]}
  */
 export const keymap = [
-  { keys: ['j', 'down'], intent: 'cursorDown', hint: { keys: 'j/k', label: 'move' } },
-  { keys: ['k', 'up'], intent: 'cursorUp' },
-  { keys: ['return', 'enter'], intent: 'open', hint: { keys: '↵', label: 'open' } },
-  { keys: ['g', 'r'], intent: 'refresh', hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+  { bindingId: 'crtr.view.workspace-sidebar.down', intent: 'cursorDown', hint: { label: 'move' } },
+  { bindingId: 'crtr.view.workspace-sidebar.up', intent: 'cursorUp' },
+  { bindingId: 'crtr.view.workspace-sidebar.open', intent: 'open', hint: { label: 'open' } },
+  { bindingId: 'crtr.view.workspace-sidebar.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.workspace-sidebar.quit', intent: 'quit', hint: { label: 'quit' } },
 ];

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import './suppress-experimental-warnings.js';

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import './suppress-experimental-warnings.js';
 import { enableCompileCache } from 'node:module';
 import { runCli } from './core/command.js';
 import { resolveRoot } from './build-root.js';

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

@@ -152,7 +152,7 @@ function seedPoisonedLocalState() {
         last_activity: 'POISON ACTIVITY — local read leaked into remote attach chrome',
     }));
 }
-test('buildCanvasPanelLines suppresses every local-read adornment for a RemoteCanvasSource, even with conflicting local state for the same node id', async () => {
+test('buildCanvasPanelLines suppresses every local-read adornment for a RemoteCanvasSource, even with conflicting local state for the same node id', async (t) => {
     seedPoisonedLocalState();
     const rootMeta = meta('root');
     const aMeta = meta('a'); // the REMOTE node's meta — unrelated to the poisoned local NodeMeta above
@@ -166,6 +166,10 @@ test('buildCanvasPanelLines suppresses every local-read adornment for a RemoteCa
         }
         return { status: 500, body: {} };
     });
+    // Register the close BEFORE any assertion runs — a listening server left
+    // open by a thrown assertion keeps this test file's process alive forever
+    // (see the CI-hang postmortem on rebuild-coalescer.test.ts).
+    t.after(() => server.close());
     const source = new RemoteCanvasSource(server.url, 'tok');
     // 'root' has 'a' as a live report → row('a') renders into `reports`.
     const { reports } = await buildCanvasPanelLines('root', {}, IDENTITY_PALETTE, source);
@@ -175,9 +179,8 @@ test('buildCanvasPanelLines suppresses every local-read adornment for a RemoteCa
     assert.ok(!line.includes('POISON'), `poisoned local text must never appear in a remote row: ${line}`);
     assert.ok(!line.includes('⚠'), `a local active fault must not surface as the hanging glyph on a remote row: ${line}`);
     assert.ok(!line.includes(BG_ATTACHED), `a local focus/attach must not paint a remote row as attached: ${line}`);
-    await server.close();
 });
-test('GraphOverlay suppresses every local-read adornment for a RemoteCanvasSource AND makes Enter/m/x no-ops, even with conflicting local state for the same node id', async () => {
+test('GraphOverlay suppresses every local-read adornment for a RemoteCanvasSource AND makes Enter/m/x no-ops, even with conflicting local state for the same node id', async (t) => {
     seedPoisonedLocalState();
     const rootMeta = meta('root');
     const aMeta = meta('a');
@@ -191,6 +194,8 @@ test('GraphOverlay suppresses every local-read adornment for a RemoteCanvasSourc
         }
         return { status: 500, body: {} };
     });
+    // Register the close BEFORE any assertion runs — see the note above.
+    t.after(() => server.close());
     const source = new RemoteCanvasSource(server.url, 'tok');
     const { tui } = fakeTui();
     const overlay = new GraphOverlay(tui, 'root', () => ({}), IDENTITY_PALETTE, source);
@@ -219,11 +224,10 @@ test('GraphOverlay suppresses every local-read adornment for a RemoteCanvasSourc
     // 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');
-    await server.close();
 });
 // ---------------------------------------------------------------------------
 // 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
@@ -328,10 +332,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__/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,20 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { transformMermaidFences } from '../mermaid-render.js';
+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', () => {
+    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

@@ -6,7 +6,7 @@ export type Mode = 'normal' | 'spec' | 'plan';
 /** 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 Alt+Shift+P's 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. */