@crouton-kit/crouter 0.3.28 → 0.3.30

package/dist/clients/attach/graph-overlay.d.ts

@@ -1,8 +1,10 @@
 import { type Component, type TUI } from '@earendil-works/pi-tui';
+import type { AttachPalette } from './config-load.js';
 export declare class GraphOverlay implements Component {
     private readonly tui;
     private readonly self;
     private readonly getAsks;
+    private readonly palette;
     private handle;
     /** Manual fold OVERRIDES (h collapses → userCollapsed, l expands → userExpanded);
      *  both override the default activity-driven policy and survive open/close. */
@@ -15,7 +17,7 @@ export declare class GraphOverlay implements Component {
     private scrollTop;
     /** Transient y/n confirm gate (kill). */
     private pendingConfirm;
-    constructor(tui: TUI, self: string, getAsks: () => Record<string, number>);
+    constructor(tui: TUI, self: string, getAsks: () => Record<string, number>, palette: AttachPalette);
     isOpen(): boolean;
     open(): void;
     close(): void;
@@ -24,11 +26,18 @@ export declare class GraphOverlay implements Component {
     refresh(): void;
     invalidate(): void;
     render(width: number): string[];
+    /** A top/bottom border row: `<lc>─ <label> ────<rc>`, frame in the theme border
+     *  color, the label keeping its own styling. The label is visible-truncated to
+     *  the available span so a long label (a narrow pane, or a long `kill <name>?`
+     *  confirm) never spills past the corner. */
+    private borderRow;
     handleInput(data: string): void;
     private dispatch;
-    /** Swap `id` into THIS viewer's tmux pane (mirrors canvas browse's return-pane
-     *  shell). Default --pane is the caller TMUX_PANE; we pass it explicitly when
-     *  set so the focus lands here even if env resolution differs. */
+    /** Focus node `id` from the overlay by shelling `crtr node focus <id> --pane <here>`.
+     *  Under the one-viewer-per-node model `--pane` is the ANCHOR to open beside: if
+     *  `id` has no viewer yet a fresh one splits beside this pane; if it already has
+     *  one, that viewer is navigated in place (this pane is left as-is). We pass
+     *  TMUX_PANE explicitly so the anchor is THIS pane even if env resolution differs. */
     private focusTarget;
     private shellCrtr;
 }

package/dist/clients/attach/graph-overlay.js

@@ -2,7 +2,8 @@
 //
 // Native reimplementation of canvas-nav.ts's GRAPH modal as a pi-tui OVERLAY
 // (the viewer has no pi extension host). `tui.showOverlay(this, …)` mounts this
-// Component full-screen and CAPTURES keyboard focus (mirrors extension-dialogs.ts);
+// Component as a BOUNDED, centered modal (~72% of the terminal, themed frame) and
+// CAPTURES keyboard focus (mirrors extension-dialogs.ts);
 // `OverlayHandle.hide()` tears it down and restores focus to the editor. While
 // shown, every key routes to handleInput() — a fold-aware NERDTree of the local
 // subscription graph with the canvas-nav keymap:
@@ -13,28 +14,30 @@
 // decoded with pi-tui's canonical matchesKey (kitty/CSI-u aware).
 //
 // Enter/m/x SHELL `crtr` out-of-process (node focus / node close) — the viewer
-// itself never spawns pi or opens a session (the §0 one-writer invariant); it
-// runs inside a tmux pane, so `crtr node focus --pane` swaps the chosen node in.
+// itself never spawns pi or opens a session (the §0 one-writer invariant). It
+// passes its own pane as `crtr node focus --pane <anchor>`: under the
+// one-viewer-per-node model the target's existing viewer is navigated in place,
+// or a fresh viewer opens BESIDE this pane — never a second pane for the same node.
 import { execFile } from 'node:child_process';
-import { matchesKey } from '@earendil-works/pi-tui';
+import { matchesKey, truncateToWidth } from '@earendil-works/pi-tui';
 import { fullName } from '../../core/canvas/index.js';
 import { beginFrame, cNode, managerOf, sortedChildIds, climbRoot, computeSubtreeActivity, buildGraphModel, renderGraphRow, focusedNodeIds, shortId, visibleWidth, VIEWPORT_FALLBACK_ROWS, DIM, RESET, BOLD, YELLOW, } from '../../core/canvas/nav-model.js';
-const OVERLAY_OPTIONS = { anchor: 'top-left', width: '100%', maxHeight: '100%' };
+// A BOUNDED, centered modal (CTO ruling: not full-bleed). Width/height are capped
+// at ~72% of the terminal; the overlay clips our lines to maxHeight, and render()
+// budgets the panel to the SAME fraction (HEIGHT_PCT) so the framed box is never
+// clipped. margin keeps it off the screen edges.
+const HEIGHT_PCT = 0.72;
+const OVERLAY_OPTIONS = { anchor: 'center', width: '72%', minWidth: 48, maxHeight: '72%', margin: 1 };
 // Viewer-specific hint: nav-model's shared GRAPH_HINT advertises "e expand",
 // but that key is the tmux pane-expand prefix-bind canvas-nav installs in its
 // host pane — the attach overlay has no such bind and swallows `e`, so the key
 // would do nothing here. Drop it.
 const GRAPH_HINT = `${DIM}jk move · hl fold · ↵ focus · x kill · m mgr · esc${RESET}`;
-/** Pad `s` out to `width` VISIBLE columns so the overlay line is opaque (no base
- *  content bleeds through the right edge). Lines already wider are left as-is. */
-function padTo(s, width) {
-    const pad = width - visibleWidth(s);
-    return pad > 0 ? s + ' '.repeat(pad) : s;
-}
 export class GraphOverlay {
     tui;
     self;
     getAsks;
+    palette;
     handle;
     /** Manual fold OVERRIDES (h collapses → userCollapsed, l expands → userExpanded);
      *  both override the default activity-driven policy and survive open/close. */
@@ -47,10 +50,11 @@ export class GraphOverlay {
     scrollTop = 0;
     /** Transient y/n confirm gate (kill). */
     pendingConfirm;
-    constructor(tui, self, getAsks) {
+    constructor(tui, self, getAsks, palette) {
         this.tui = tui;
         this.self = self;
         this.getAsks = getAsks;
+        this.palette = palette;
     }
     isOpen() {
         return this.handle !== undefined;
@@ -102,9 +106,15 @@ export class GraphOverlay {
                 cursorIdx = 0;
         }
         this.cursorId = rows[cursorIdx]?.id ?? this.self;
-        // Full-screen budget: 1 title line + 1 footer hint, the rest for tree rows.
-        const totalH = Math.max(6, process.stdout.rows ?? VIEWPORT_FALLBACK_ROWS);
-        const treeArea = Math.max(2, totalH - 2);
+        // Bounded panel budget (centered modal, not full-bleed): the box height
+        // shrinks to content but is capped at HEIGHT_PCT of the terminal — matching
+        // the overlay's maxHeight so our framed lines are never clipped. 2 rows go to
+        // the top/bottom border, the rest to tree rows.
+        const term = process.stdout.rows ?? VIEWPORT_FALLBACK_ROWS;
+        // Never exceed the overlay's own maxHeight (term-2 after the margin), so the
+        // bottom border is never slice-clipped even on a very short terminal.
+        const maxPanelH = Math.max(3, Math.min(Math.floor(term * HEIGHT_PCT), term - 2));
+        const treeArea = Math.max(2, Math.min(rows.length, maxPanelH - 2));
         // Track the cursor within treeArea, reserving ↑/↓ "more" indicators. Up to
         // 4 passes converge the mutual dependency between window size and indicators
         // (an indicator steals a tree row → can re-home scrollTop → toggles the other
@@ -137,7 +147,35 @@ export class GraphOverlay {
         const hint = this.pendingConfirm !== undefined
             ? `${YELLOW}${this.pendingConfirm.label} ${BOLD}y/n${RESET}`
             : GRAPH_HINT;
-        return [title, ...body, hint].map((line) => padTo(line, width));
+        // Frame the panel: title in the top border, hint in the bottom border, tree
+        // rows boxed with themed side bars (truncate/pad to the inner width so the
+        // right edge stays flush and opaque).
+        const B = this.palette.border;
+        const innerW = Math.max(1, width - 4); // "│ " + content + " │"
+        // Hard-cut (empty ellipsis) + pad to innerW: ANSI-aware, so the cursor fill
+        // bar reaches the right border flush with no stray "…" and the box edge is
+        // opaque.
+        const boxed = body.map((line) => `${B('│')} ${truncateToWidth(line, innerW, '', true)} ${B('│')}`);
+        // Paint the WHOLE modal — border rows + boxed body + opaque space-fill — on
+        // the theme's distinct-surface background (selectedBg) so the float reads as
+        // a separate surface, not a hole in the viewer behind it (CTO ruling).
+        const S = this.palette.surface;
+        return [
+            this.borderRow('╭', '╮', title, width),
+            ...boxed,
+            this.borderRow('╰', '╯', hint, width),
+        ].map(S);
+    }
+    /** A top/bottom border row: `<lc>─ <label> ────<rc>`, frame in the theme border
+     *  color, the label keeping its own styling. The label is visible-truncated to
+     *  the available span so a long label (a narrow pane, or a long `kill <name>?`
+     *  confirm) never spills past the corner. */
+    borderRow(lc, rc, label, width) {
+        const B = this.palette.border;
+        const span = Math.max(1, width - 5); // lc ─ _ <span> _ ─… rc
+        const lbl = truncateToWidth(label, span, '…');
+        const fill = Math.max(0, width - 5 - visibleWidth(lbl));
+        return `${B(`${lc}─`)} ${lbl} ${B('─'.repeat(fill) + rc)}`;
     }
     // -------------------------------------------------------------------------
     handleInput(data) {
@@ -245,9 +283,11 @@ export class GraphOverlay {
         // key never reaches the editor underneath.
     }
     // -------------------------------------------------------------------------
-    /** Swap `id` into THIS viewer's tmux pane (mirrors canvas browse's return-pane
-     *  shell). Default --pane is the caller TMUX_PANE; we pass it explicitly when
-     *  set so the focus lands here even if env resolution differs. */
+    /** Focus node `id` from the overlay by shelling `crtr node focus <id> --pane <here>`.
+     *  Under the one-viewer-per-node model `--pane` is the ANCHOR to open beside: if
+     *  `id` has no viewer yet a fresh one splits beside this pane; if it already has
+     *  one, that viewer is navigated in place (this pane is left as-is). We pass
+     *  TMUX_PANE explicitly so the anchor is THIS pane even if env resolution differs. */
     focusTarget(id) {
         const argv = ['node', 'focus', id];
         const pane = process.env['TMUX_PANE'];

package/dist/clients/attach/input-controller.d.ts

@@ -1,6 +1,8 @@
 import type { CustomEditor } from '@earendil-works/pi-coding-agent';
-import type { KeybindingsManager, TUI } from '@earendil-works/pi-tui';
-import { type BrokerSnapshot, type ClientToBroker, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from '../../core/runtime/broker-protocol.js';
+import type { Component, KeybindingsManager, TUI } from '@earendil-works/pi-tui';
+import { type BrokerDataFrame, type BrokerSnapshot, type ClientToBroker, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from '../../core/runtime/broker-protocol.js';
+import type { ReadOpRequest } from './view-socket.js';
+import { type Picker, type PickerControls } from './pickers.js';
 export interface InputControllerHooks {
     /** Send a command frame to the broker. */
     onCommand: (frame: ClientToBroker) => void;
@@ -17,20 +19,50 @@ export interface InputControllerHooks {
     /** OPTIONAL: toggle the GRAPH overlay — forwarded to the slash context so
      *  `/graph` opens/closes it (Unit Q wires it from runAttach). */
     onGraph?: () => void;
+    /** OPTIONAL: detach the viewer — forwarded to the slash context so `/quit`
+     *  tears down the TUI/socket (the engine keeps running). Wired by attach-cmd. */
+    onQuit?: () => void;
+    /** OPTIONAL: copy the last assistant message to the clipboard — forwarded to
+     *  the slash context so `/copy` works. Wired by attach-cmd (it owns ChatView). */
+    onCopy?: () => void;
+    /** OPTIONAL: Ctrl+O / app.tools.expand — flip global tool-output expansion in
+     *  the render layer (ChatView owns the components). Absent → the key no-ops. */
+    onToggleToolsExpand?: () => void;
+    /** OPTIONAL: Ctrl+T / app.thinking.toggle — flip thinking-block visibility in
+     *  the render layer. Absent → the key no-ops. */
+    onToggleThinking?: () => void;
+    /** OPTIONAL: issue a correlated read-op and resolve with the broker's `data`
+     *  reply. MUST be wired by attach-cmd (`onRequest: (f) => socket.request(f)`)
+     *  for the native pickers to work; when absent every picker degrades to a
+     *  text-arg notice. */
+    onRequest?: (frame: ReadOpRequest) => Promise<BrokerDataFrame>;
+    /** OPTIONAL pair: mount/unmount a native picker INLINE in the viewer's layout
+     *  (attach-cmd slots it directly under the editor). When BOTH are wired,
+     *  showPicker uses them instead of a centered overlay; absent → overlay
+     *  fallback. The controller stays layout-agnostic either way (T5/T7 own it). */
+    onMountPicker?: (component: Component) => void;
+    onUnmountPicker?: () => void;
+    /** OPTIONAL: open the native /login provider picker (viewer-local auth flow). */
+    openLoginPicker?: () => void;
+    /** OPTIONAL: open the native /logout provider picker (viewer-local auth flow). */
+    openLogoutPicker?: () => void;
 }
 export declare class InputController {
     private readonly tui;
     private readonly editor;
     private readonly keybindings;
     private readonly hooks;
-    /** Images pasted since the last send, attached to the next prompt/follow-up. */
-    private pendingImages;
-    /** Running base64-byte total of `pendingImages` (review M2 aggregate budget). */
-    private pendingImageBytes;
     /** The currently-rendered blocking dialog, if any (for supersede/dismiss). */
     private dialog;
+    /** The currently-open native picker overlay, if any (for supersede/dismiss). */
+    private picker;
+    /** Monotonic open counter — a slow read-op reply whose `seq` is no longer the
+     *  latest is dropped, so an earlier picker never pops over a later request. */
+    private openSeq;
     /** Latest engine state from `welcome`/`session_info_changed` (for `/session`). */
     private state;
+    /** Timestamp of the last lone Esc, for double-tap → tree detection (0 = none). */
+    private lastEscapeAt;
     constructor(tui: TUI, editor: CustomEditor, keybindings: KeybindingsManager, hooks: InputControllerHooks);
     /** Render a blocking extension dialog and route its answer to the broker.
      *  Supersedes any dialog already on screen (e.g. a re-route on control
@@ -41,20 +73,50 @@ export declare class InputController {
     setState(state: BrokerSnapshot['state']): void;
     private wire;
     private slashContext;
+    /** Send a command frame to the broker (picker selection sink). */
+    private send;
+    /** Fetch a picker payload (narrowed on `kind`), then build + show its overlay
+     *  iff this open is still the latest (m4: a stale slow reply is dropped). Any
+     *  failure — unwired channel, wrong kind, request error, or a throwing builder
+     *  — surfaces a notice instead of an unhandled rejection (m5). */
+    private openPicker;
+    /** Show a picker built by `build` (given a `close` that tears it down).
+     *  Mounted INLINE under the editor when attach-cmd wires onMountPicker/
+     *  onUnmountPicker (the integrated chrome path); otherwise falls back to a
+     *  centered overlay. Supersedes any picker already on screen. Routes focus to
+     *  the builder's declared focus target (an inner list for fork/settings) and
+     *  ALWAYS restores editor focus on close — `OverlayHandle.hide()` only
+     *  auto-restores when the OUTER component held focus, which is not the case
+     *  once we focus an inner child. A throwing builder is caught into a notice (m5). */
+    private showPicker;
+    private openModelPicker;
+    private openSessionPicker;
+    private openTreePicker;
+    private openForkPicker;
+    private openSettingsPicker;
+    private openScopedModelsPicker;
+    /** Open a viewer-local auth picker (login/logout) — uses the same showPicker
+     *  machinery as read-op pickers, but with a locally-built component (no read-op
+     *  request; auth operations are viewer-local in tmux-local attach). */
+    openAuthPicker(build: (controls: PickerControls) => Picker): void;
     private handleSubmit;
     private handleFollowUp;
+    /** Ctrl+G / app.editor.external — open the current editor text in $VISUAL/$EDITOR
+     *  and load the saved result back. Ported from pi's `openExternalEditor`: stop
+     *  the TUI to release the terminal, run the editor with inherited stdio, and on
+     *  a clean exit (status 0) replace the editor text; the socket keeps running in
+     *  the background throughout. */
+    private openExternalEditor;
+    /** Alt+Up / app.message.dequeue — clear the broker's queued steering + follow-up
+     *  messages and restore them to the editor, prepended to any in-progress text
+     *  (pi's `restoreQueuedMessagesToEditor`: queued text first, joined by blank
+     *  lines). A read-AND-mutate op over the correlated request channel. */
+    private handleDequeue;
     /** Send a drive frame iff the WHOLE encoded frame fits under MAX_FRAME_BYTES
      *  (the broker destroys the socket on any line over its 24 MiB read cap). Over
      *  the ceiling → notify + refuse so the caller leaves the editor + pending
      *  images intact for the user to trim, never a socket-destroying overflow. */
     private emitDrive;
     private handlePaste;
-    /** Snapshot the pending images as an `images?` payload (undefined when none)
-     *  WITHOUT clearing — so a frame refused by `emitDrive` (too large) keeps them
-     *  for the user to trim. The caller clears via `clearPendingImages` only after a
-     *  successful send. */
-    private pendingImagesPayload;
-    /** Drop all pending images + reset the aggregate byte counter (after a send). */
-    private clearPendingImages;
     private notify;
 }