@pi-unipi/info-screen 2.12.0 → 2.14.1

package/index.ts

@@ -113,10 +113,19 @@ export default function (pi: ExtensionAPI) {
    */
   function showOverlay(ctx: ExtensionContext, autoCloseMs?: number): void {
     let overlay: InfoOverlay;
+    // Splash mode (auto-close): the overlay must NEVER take keyboard focus —
+    // it lives exactly during the window where the user starts typing their
+    // first prompt. A capturing overlay here eats those keystrokes (worse: its
+    // vim-style keys "work", so command text vanishes into tab switches), and
+    // its first-keypress-cancels-auto-close rule strands it on screen forever
+    // as an unclosable, input-eating zombie. Non-capturing + stack-safe
+    // self-dismiss (see startBootTimer) makes it pure eye-candy.
+    const splashMode = autoCloseMs !== undefined && autoCloseMs > 0;
     ctx.ui.custom<void>(
       (tui, theme, _keybindings, done) => {
         overlay = new InfoOverlay();
         overlay.setTheme(theme);
+        overlay.interactive = !splashMode;
         overlayVisible = true;
         overlay.onClose = () => {
           overlayVisible = false;
@@ -127,14 +136,37 @@ export default function (pi: ExtensionAPI) {
         const component = {
           render: (w: number) => overlay.render(w),
           invalidate: () => overlay.invalidate(),
+          // In splash mode the overlay is non-capturing and never receives
+          // input; keep handleInput wired for interactive ("on") mode.
           handleInput: (data: string) => {
             overlay.handleInput(data);
             tui.requestRender();
           },
         };
-        // Boot dashboard dismisses itself; any keypress cancels the timer.
+        // Splash self-dismiss may only run while this overlay is the topmost
+        // VISIBLE entry of the TUI overlay stack. If the user opens anything
+        // during the splash window (a /unipi:… settings dialog, the updater's
+        // update prompt, …), dismissal must wait — removing a covered entry
+        // breaks the covering overlay (pi retargets focus and orphans its
+        // pending interaction, e.g. a hung ctx.ui.select promise). Re-check
+        // on every timer tick; once the stack clears we dismiss as usual.
+        const isTopmostVisible = (): boolean => {
+          try {
+            const stack = (tui as unknown as { overlayStack?: Array<{ component?: unknown; hidden?: boolean }> }).overlayStack;
+            if (!stack || stack.length === 0) return true;
+            for (let i = stack.length - 1; i >= 0; i--) {
+              const entry = stack[i];
+              if (entry?.hidden) continue;
+              return entry?.component === component;
+            }
+            return true;
+          } catch {
+            return true; // Stack unreadable — assume topmost (legacy behavior).
+          }
+        };
+        // Boot dashboard dismisses itself (splash mode).
         if (autoCloseMs && autoCloseMs > 0) {
-          overlay.startBootTimer(autoCloseMs);
+          overlay.startBootTimer(autoCloseMs, isTopmostVisible);
         }
         return component;
       },
@@ -145,17 +177,24 @@ export default function (pi: ExtensionAPI) {
           minWidth: 60,
           anchor: "center" as const,
           margin: 2,
+          nonCapturing: splashMode,
         },
-        // `done()` (the extension UI's close callback) pops the *topmost* overlay
-        // in the TUI stack, not this one specifically. When another overlay (e.g.
-        // the updater's "Update Available" prompt) is stacked on top, the boot
-        // auto-close timer must not fire `done()` — that would pop the covering
-        // overlay and strand this dashboard with a spent one-shot close the user
-        // can no longer dismiss. `isTopmostOverlay` lets the boot timer defer
-        // until we are the focused (topmost) entry; the user can still press
-        // q/Esc to close once the covering overlay is gone.
+        // In splash mode the timer uses `selfHide` (handle.hide() splices this
+        // entry out by identity) guarded by the topmost-visible check above —
+        // never `done()`, which pops whatever is TOPMOST. `isTopmostOverlay`
+        // remains as the focused-done() fallback for interactive ("on") mode,
+        // where the user drives the dashboard directly: it is topmost while
+        // being driven, so the q/Esc → done() path is correct there.
         onHandle: (handle) => {
           overlay.isTopmostOverlay = () => handle.isFocused();
+          overlay.selfHide = () => {
+            overlayVisible = false;
+            if (typeof handle.hide === "function") {
+              handle.hide();
+            } else if (typeof (handle as { setHidden?: (v: boolean) => void }).setHidden === "function") {
+              (handle as { setHidden: (v: boolean) => void }).setHidden(true);
+            }
+          };
         },
       }
     );

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "2.12.0",
-  "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
+  "version": "2.14.1",
+  "description": "Dashboard and module registry for Unipi \u2014 configurable info overlay with tabbed groups",
   "type": "module",
   "main": "index.ts",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.12.0"
+    "@pi-unipi/core": "2.14.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/tui/info-overlay.ts

@@ -69,6 +69,21 @@ export class InfoOverlay implements Component {
    * `startBootTimer` for why.
    */
   isTopmostOverlay?: () => boolean;
+  /**
+   * Stack-safe self-removal via the overlay handle (`handle.hide()` splices
+   * this entry out of the TUI stack by identity, unlike `done()` which pops
+   * whatever is TOPMOST). Set from `onHandle` in index.ts. When available,
+   * the boot auto-close timer prefers this over `done()` so a splash that
+   * lingers while another overlay opens can never dismiss that overlay
+   * instead of itself.
+   */
+  selfHide?: () => void;
+  /**
+   * False when running as a non-capturing boot splash (auto-close): the
+   * overlay never receives keyboard input, so interactive hints like
+   * "q/Esc close" would be misleading and are replaced accordingly.
+   */
+  interactive = true;
 
   private overlay = new OverlayTheme();
 
@@ -232,31 +247,46 @@ export class InfoOverlay implements Component {
   }
 
   /**
-   * Auto-close the overlay after `ms`, unless the user interacts first.
+   * Auto-close the overlay after `ms`.
    *
-   * Used when the overlay is shown on boot: the dashboard is informational, so
-   * it should get out of the way on its own rather than requiring a keypress.
+   * Used when the overlay is shown as a boot splash: the dashboard is
+   * informational, so it should get out of the way on its own rather than
+   * requiring a keypress.
    *
-   * The close callback (`onClose` → `done`) pops the *topmost* overlay in the
-   * TUI stack, not this one specifically. When another overlay (e.g. the
-   * updater's "Update Available" prompt) is stacked on top, firing `done()`
-   * here would remove the covering overlay and strand this dashboard with a
-   * spent one-shot close the user can no longer trigger — leaving the starting
-   * screen stuck. So we defer the auto-close until we are actually the
-   * focused/topmost overlay; the user can still press q/Esc to dismiss it once
-   * the covering overlay is gone.
+   * Dismissal uses `selfHide` (handle.hide() — removes THIS entry from the
+   * TUI overlay stack by identity) and only fires while `isTopmostVisible`
+   * confirms nothing is stacked above: dismissing a covered overlay breaks
+   * the covering one (pi retargets focus and orphans its pending
+   * interaction, e.g. a ctx.ui.select promise that never resolves while its
+   * overlay vanishes). If covered, the timer re-arms and retries.
+   *
+   * If `selfHide` is unavailable (older host), falls back to the guarded
+   * `onClose` (`done()`) path, which requires focus (topmost) for the same
+   * reason.
    */
-  startBootTimer(ms: number): void {
+  startBootTimer(ms: number, isTopmostVisible?: () => boolean): void {
     this.cancelBootTimer();
     if (!Number.isFinite(ms) || ms <= 0) return;
     const arm = (): void => {
       this.bootTimer = setTimeout(() => {
         this.bootTimer = null;
         if (this._destroyed) return;
+        if (this.selfHide) {
+          if (isTopmostVisible && !isTopmostVisible()) {
+            // Something is stacked on top of us — dismissing now would break
+            // it (orphaned select promise, focus retarget). Retry shortly;
+            // once the stack clears we dismiss as usual.
+            arm();
+            return;
+          }
+          this.selfHide();
+          this.destroy();
+          return;
+        }
         if (this.isTopmostOverlay && !this.isTopmostOverlay()) {
-          // Something is stacked on top of us — closing now would pop it
-          // instead of this dashboard. Retry shortly; once the covering
-          // overlay closes we'll be topmost and can auto-close safely.
+          // Fallback (no selfHide available): closing now would pop the
+          // covering overlay instead of this dashboard. Retry shortly; once
+          // we are topmost the close is safe.
           arm();
           return;
         }
@@ -346,7 +376,7 @@ export class InfoOverlay implements Component {
     lines.push(this.overlay.frameLine(this.overlay.fg("dim", "Modules will register groups on startup."), innerWidth));
     for (let i = 0; i < 4; i++) lines.push(this.overlay.frameLine("", innerWidth));
     lines.push(this.overlay.ruleLine(innerWidth));
-    lines.push(this.overlay.frameLine(this.overlay.fg("dim", "q/Esc close · r refresh"), innerWidth));
+    lines.push(this.overlay.frameLine(this.overlay.fg("dim", this.interactive ? "q/Esc close · r refresh" : "auto-dismissing…"), innerWidth));
     lines.push(this.overlay.borderLine(innerWidth, "bottom"));
     return lines;
   }
@@ -529,12 +559,14 @@ export class InfoOverlay implements Component {
     const lastUp = infoRegistry.getLastUpdated(group?.id ?? "");
     const age = lastUp > 0 ? humanizeAge(Date.now() - lastUp) : "loading…";
 
-    const hints = [
-      `${this.overlay.fg("accent", "←/→")} tabs`,
-      `${this.overlay.fg("success", "↑/↓")} scroll`,
-      `${this.overlay.fg("warning", "r")} refresh`,
-      `${this.overlay.fg("error", "q/Esc")} close`,
-    ];
+    const hints = this.interactive
+      ? [
+          `${this.overlay.fg("accent", "←/→")} tabs`,
+          `${this.overlay.fg("success", "↑/↓")} scroll`,
+          `${this.overlay.fg("warning", "r")} refresh`,
+          `${this.overlay.fg("error", "q/Esc")} close`,
+        ]
+      : [`${this.overlay.fg("dim", "auto-dismissing…")}`];
 
     const hintStr = hints.join(`  ${this.overlay.fg("borderMuted", "•")}  `);