tmux-ide 2.7.0 → 2.9.0-beta.5

package/packages/daemon/src/tui/mirror/semantic-session-view.ts

@@ -0,0 +1,366 @@
+import type { ApplicationShellTerminalInventory, PaneStreamServerFrame } from "@tmux-ide/contracts";
+import type { SessionPaneDescriptor } from "../../terminal/protocol/session-descriptor-discovery.ts";
+import { terminalWindowResourceId } from "../../lib/semantic-resource-id.ts";
+
+import type { MirrorSnapshot } from "./pane-mirror.ts";
+import type { TerminalPaletteProjection } from "./theme.ts";
+import type {
+  SemanticPaneCanonicalSnapshot,
+  SemanticTerminalRenderSource,
+  TerminalCellSearchMatch,
+  TerminalCellTextRow,
+} from "./semantic-pane-render-source.ts";
+import {
+  projectSnapshotRichPlacements,
+  type RichPlacementProjection,
+  type RichPlacementViewport,
+} from "./rich-placement-projection.ts";
+
+export interface LivePane {
+  readonly id: string;
+  readonly left: number;
+  readonly top: number;
+  readonly width: number;
+  readonly height: number;
+  readonly active: boolean;
+  readonly appMouse: boolean;
+  readonly zoomed: boolean;
+  readonly snapshot: MirrorSnapshot;
+  readonly scrollbackDepth: number;
+  readonly version: number;
+}
+
+interface WindowTab {
+  index: number;
+  name: string;
+  active: boolean;
+  sync: boolean;
+  semanticWindowId: string | null;
+  activePaneId: string | null;
+}
+
+export interface SemanticSessionViewOptions {
+  readonly target: string;
+  readonly onDirty?: () => void;
+  readonly onFocusChanged?: (paneId: string, source: "local" | "tmux") => void;
+  readonly onStatus?: (message: string) => void;
+  readonly onExit?: () => void;
+}
+
+/**
+ * Renderer-local projection of daemon-owned SessionRuntime state.
+ *
+ * It owns no tmux process, commands, input, focus mutation, or geometry. The
+ * semantic lane supplies canonical terminal replicas and session layouts; this
+ * class only adapts them to the existing retained OpenTUI view model while the
+ * remaining legacy UI helpers are deleted.
+ */
+export class SemanticSessionView {
+  readonly #options: SemanticSessionViewOptions;
+  #source: SemanticTerminalRenderSource | null = null;
+  #inventoryDescriptors: SessionPaneDescriptor[] = [];
+  #runtimeDescriptors: SessionPaneDescriptor[] = [];
+  #runtimeAuthorityGeneration: string | null = null;
+  #layouts = new Map<string, Extract<PaneStreamServerFrame, { type: "layout" }>>();
+  #focused = "";
+  #richPlacementCache = new Map<
+    string,
+    { key: string; placements: readonly RichPlacementProjection[] }
+  >();
+
+  constructor(options: SemanticSessionViewOptions) {
+    this.#options = options;
+  }
+
+  async start(): Promise<void> {
+    this.#options.onStatus?.("semantic runtime ready");
+  }
+
+  setSource(source: SemanticTerminalRenderSource): void {
+    this.#source = source;
+    this.#options.onDirty?.();
+  }
+
+  setInventory(inventory: ApplicationShellTerminalInventory): void {
+    this.#inventoryDescriptors = inventory.resources
+      .filter((resource) => resource.attachability.status === "available")
+      .map((resource) => ({
+        sessionName: this.#options.target,
+        runtimePaneId: resource.id,
+        runtimeSessionId: "$0",
+        semanticPaneId:
+          resource.attachability.status === "available"
+            ? resource.attachability.semanticPaneId
+            : null,
+        role: resource.kind === "agent" ? "agent" : null,
+        type: resource.kind,
+        currentCommand: null,
+        cwd: null,
+        title: resource.title,
+        windowIndex: null,
+        windowName: null,
+        windowId: resource.windowResourceId ?? null,
+        semanticWindowId: resource.windowResourceId ?? null,
+        paneIndex: 0,
+        name: null,
+        nameSource: null,
+        missionStamp: null,
+        paneActive: false,
+        windowActive: false,
+        windowPaneCount: 1,
+        sessionWindowCount: 1,
+      }));
+    if (this.#inventoryDescriptors.length === 0) {
+      this.#runtimeAuthorityGeneration = null;
+      this.#runtimeDescriptors = [];
+    }
+    const active = inventory.activeResourceId ?? "";
+    this.#focused = active;
+    this.#options.onDirty?.();
+  }
+
+  /** Begin one physical semantic-lane authority generation, retiring every old raw join. */
+  setRuntimeAuthorityGeneration(generation: string): void {
+    if (generation === this.#runtimeAuthorityGeneration) return;
+    this.#runtimeAuthorityGeneration = generation;
+    this.#runtimeDescriptors = [];
+    this.#options.onDirty?.();
+  }
+
+  /** Retire local raw identity before an empty inventory, disconnect, or reconnect. */
+  retireRuntimeAuthority(): void {
+    if (this.#runtimeAuthorityGeneration === null && this.#runtimeDescriptors.length === 0) return;
+    this.#runtimeAuthorityGeneration = null;
+    this.#runtimeDescriptors = [];
+    this.#options.onDirty?.();
+  }
+
+  /** Accept process-local tmux identity proof only for the live physical authority. */
+  setRuntimeDescriptors(
+    authorityGeneration: string,
+    descriptors: readonly SessionPaneDescriptor[],
+  ): boolean {
+    if (authorityGeneration !== this.#runtimeAuthorityGeneration) return false;
+    this.#runtimeDescriptors = descriptors
+      .filter(
+        (descriptor) =>
+          /^%[0-9]+$/u.test(descriptor.runtimePaneId) && descriptor.semanticPaneId !== null,
+      )
+      .map((descriptor) => ({ ...descriptor }));
+    this.#options.onDirty?.();
+    return true;
+  }
+
+  acceptLayout(frame: Extract<PaneStreamServerFrame, { type: "layout" }>): void {
+    const key = frame.semanticWindowId ?? `unverified:${frame.windowName ?? "window"}`;
+    this.#layouts.set(key, frame);
+    const activePane = frame.panes.find((pane) => pane.active)?.pane;
+    if (frame.currentWindow && activePane) {
+      this.#focused = activePane;
+      this.#options.onFocusChanged?.(activePane, "tmux");
+    }
+    this.#options.onDirty?.();
+  }
+
+  paneDescriptors(): SessionPaneDescriptor[] {
+    const runtimeBySemantic = new Map<string, SessionPaneDescriptor[]>();
+    for (const descriptor of this.#runtimeDescriptors) {
+      const semanticPaneId = descriptor.semanticPaneId!;
+      runtimeBySemantic.set(semanticPaneId, [
+        ...(runtimeBySemantic.get(semanticPaneId) ?? []),
+        descriptor,
+      ]);
+    }
+    return this.#inventoryDescriptors.map((descriptor) => {
+      const runtime = descriptor.semanticPaneId
+        ? runtimeBySemantic.get(descriptor.semanticPaneId)
+        : undefined;
+      return this.#joinRuntimeDescriptor(descriptor, runtime?.length === 1 ? runtime[0]! : null);
+    });
+  }
+
+  #joinRuntimeDescriptor(
+    descriptor: SessionPaneDescriptor,
+    runtime: SessionPaneDescriptor | null,
+  ): SessionPaneDescriptor {
+    if (!runtime) return { ...descriptor };
+    return {
+      ...runtime,
+      // ApplicationShell owns product presentation. Local tmux discovery
+      // only supplies process-local runtime/window proof; its pane_title can
+      // be a shell/program title and must not replace the configured label.
+      title: descriptor.title,
+      role: descriptor.role,
+      type: descriptor.type,
+    };
+  }
+
+  panes(
+    scrollOffsets: ReadonlyMap<string, number>,
+    _styledRows: boolean,
+    _palette: TerminalPaletteProjection,
+  ): LivePane[] {
+    const layout = [...this.#layouts.values()].find((candidate) => candidate.currentWindow);
+    if (!layout) return [];
+    return layout.panes.flatMap((pane) => {
+      if (!pane.pane) return [];
+      const replica = this.#source?.replica(pane.pane) ?? null;
+      const cursor = replica?.cursorState() ?? {
+        x: 0,
+        y: 0,
+        hidden: true,
+        style: "block" as const,
+        blink: false,
+      };
+      const scrollbackDepth = replica?.scrollbackDepth() ?? 0;
+      const scrollOffset = Math.min(scrollOffsets.get(pane.pane) ?? 0, scrollbackDepth);
+      return [
+        {
+          id: pane.pane,
+          left: pane.left,
+          top: pane.top,
+          width: pane.width,
+          height: pane.height,
+          active: pane.active,
+          appMouse: replica?.snapshot?.modes.mouseTracking ?? false,
+          zoomed: layout.zoomed,
+          snapshot: {
+            rows: _styledRows
+              ? (replica?.visibleRowTexts(scrollOffset) ?? []).map((text) => [
+                  { text, fg: null, bg: null, attributes: 0 },
+                ])
+              : [],
+            cursorX: cursor.x,
+            cursorY: cursor.y,
+            scrollOffset,
+          },
+          scrollbackDepth,
+          version: replica?.version ?? 0,
+        },
+      ];
+    });
+  }
+
+  focus(paneId: string): void {
+    this.#focused = paneId;
+    this.#options.onFocusChanged?.(paneId, "local");
+  }
+
+  focusedPane(): string {
+    return this.#focused;
+  }
+
+  scrollbackDepth(paneId: string): number {
+    return this.#source?.replica(paneId)?.scrollbackDepth() ?? 0;
+  }
+
+  lineTrim(paneId: string): number {
+    return this.#source?.replica(paneId)?.lineTrim() ?? 0;
+  }
+
+  bufferLines(paneId: string): string[] {
+    return this.#source?.replica(paneId)?.bufferLines() ?? [];
+  }
+
+  bufferTextRows(paneId: string): TerminalCellTextRow[] {
+    return this.#source?.replica(paneId)?.bufferTextRows() ?? [];
+  }
+
+  visibleRowTexts(paneId: string, scrollOffset = 0): string[] {
+    return this.#source?.replica(paneId)?.visibleRowTexts(scrollOffset) ?? [];
+  }
+
+  visibleTextRows(paneId: string, scrollOffset = 0): TerminalCellTextRow[] {
+    return this.#source?.replica(paneId)?.visibleTextRows(scrollOffset) ?? [];
+  }
+
+  findTextMatches(paneId: string, query: string): TerminalCellSearchMatch[] {
+    return this.#source?.replica(paneId)?.findTextMatches(query) ?? [];
+  }
+
+  extractText(
+    paneId: string,
+    start: { row: number; col: number },
+    end: { row: number; col: number },
+    maxBytes: number,
+  ): string {
+    return this.#source?.replica(paneId)?.extractText(start, end, maxBytes) ?? "";
+  }
+
+  richPlacements(
+    paneId: string,
+    viewport: RichPlacementViewport,
+  ): readonly RichPlacementProjection[] {
+    const snapshot = this.#source?.replica(paneId)?.snapshot;
+    if (!snapshot || snapshot.placements.length === 0) {
+      this.#richPlacementCache.delete(paneId);
+      return [];
+    }
+    const key = JSON.stringify([
+      viewport,
+      snapshot.placements.map((placement) => [
+        placement.id,
+        placement.kind,
+        placement.row,
+        placement.column,
+        placement.rows,
+        placement.columns,
+        placement.contentDigest,
+      ]),
+    ]);
+    const cached = this.#richPlacementCache.get(paneId);
+    if (cached?.key === key) return cached.placements;
+    const placements = projectSnapshotRichPlacements(paneId, snapshot, viewport);
+    this.#richPlacementCache.set(paneId, { key, placements });
+    return placements;
+  }
+
+  /** Retained canonical input for the deferred rich-preview feature. */
+  canonicalSnapshot(paneId: string): SemanticPaneCanonicalSnapshot | null {
+    return this.#source?.canonicalSnapshot(paneId) ?? null;
+  }
+
+  windowSize(): { cols: number; rows: number } | null {
+    const layout = [...this.#layouts.values()].find((candidate) => candidate.currentWindow);
+    return layout ? { cols: layout.cols, rows: layout.rows } : null;
+  }
+
+  async windows(): Promise<WindowTab[]> {
+    return [...this.#layouts.values()].map((layout, fallbackIndex) => {
+      const layoutPaneId = layout.panes.find((pane) => pane.active)?.pane ?? null;
+      const windowResourceId = layout.semanticWindowId
+        ? terminalWindowResourceId(layout.semanticWindowId)
+        : null;
+      const inventoryPane =
+        windowResourceId === null
+          ? null
+          : (this.#inventoryDescriptors.find(
+              (descriptor) =>
+                descriptor.windowId === windowResourceId && descriptor.semanticPaneId !== null,
+            ) ?? null);
+      const activePaneId = layoutPaneId ?? inventoryPane?.semanticPaneId ?? null;
+      const runtimePane = activePaneId
+        ? (this.#runtimeDescriptors.find(
+            (descriptor) => descriptor.semanticPaneId === activePaneId,
+          ) ?? null)
+        : null;
+      return {
+        index: runtimePane?.windowIndex ?? fallbackIndex,
+        name: layout.windowName ?? runtimePane?.windowName ?? `Window ${fallbackIndex + 1}`,
+        active: layout.currentWindow,
+        sync: false,
+        semanticWindowId: layout.semanticWindowId,
+        activePaneId,
+      };
+    });
+  }
+
+  dispose(): void {
+    this.#layouts.clear();
+    this.#source = null;
+    this.#inventoryDescriptors = [];
+    this.#runtimeDescriptors = [];
+    this.#runtimeAuthorityGeneration = null;
+    this.#richPlacementCache.clear();
+  }
+}

package/packages/daemon/src/tui/mirror/settings-model.ts

@@ -12,37 +12,12 @@
  * never left guessing.
  */
 import type { AppConfig, AppConfigPatch, AppKeys } from "../../lib/app-config.ts";
-import { parseHHMM, type NotificationPrefs } from "../chrome/notify.ts";
+import type { ThemeModeSetting } from "./theme.ts";
+import { parseHHMM, type NotificationPrefs } from "../chrome/notify-prefs.ts";
 import type { DialogSelectItem } from "./dialog-model.ts";
+import { APPLICATION_KEYBINDING_ROWS, prefixTwinFor } from "./application-keybindings.ts";
 
-// ── Command registry (what the palette offers) ───────────────────────────────
-
-export type SettingsCommandId =
-  | "settings"
-  | "settings-theme"
-  | "settings-notifications"
-  | "settings-quiet-hours"
-  | "settings-updates"
-  | "settings-restore"
-  | "settings-keys"
-  | "settings-reset";
-
-/** The palette entries, one per settings command (+ the umbrella first). The
- *  "Settings" category prefix is how the palette's flat fuzzy list reads as a
- *  category — typing "set" narrows to all of them. */
-export const SETTINGS_PALETTE_COMMANDS: ReadonlyArray<{
-  id: SettingsCommandId;
-  label: string;
-}> = [
-  { id: "settings", label: "Settings…" },
-  { id: "settings-theme", label: "Settings: Accent color" },
-  { id: "settings-notifications", label: "Settings: Notifications" },
-  { id: "settings-quiet-hours", label: "Settings: Quiet hours" },
-  { id: "settings-updates", label: "Settings: Updates & background refresh" },
-  { id: "settings-restore", label: "Settings: Crash restore" },
-  { id: "settings-keys", label: "Settings: Keyboard shortcuts (view)" },
-  { id: "settings-reset", label: "Settings: Reset to defaults" },
-];
+export { prefixTwinFor } from "./application-keybindings.ts";
 
 // ── Where changes land (footer copy) ─────────────────────────────────────────
 
@@ -105,26 +80,104 @@ export function themePatch(accent: string): AppConfigPatch {
   return { theme: { accent } };
 }
 
+export const THEME_MODE_LABELS: Readonly<Record<ThemeModeSetting, string>> = {
+  dark: "Dark",
+  light: "Light",
+  system: "System",
+};
+
+export function themeModeItems(cfg: AppConfig): DialogSelectItem[] {
+  return (["dark", "light", "system"] as const).map((mode) => ({
+    id: mode,
+    label: THEME_MODE_LABELS[mode],
+    detail: mode === "system" ? "follow terminal theme_mode" : `${mode} palette`,
+    current: cfg.theme.mode === mode,
+  }));
+}
+
+export function themeModePatch(mode: ThemeModeSetting): AppConfigPatch {
+  return { theme: { mode } };
+}
+
 // ── Notifications ────────────────────────────────────────────────────────────
 
-export type NotificationToggleId = "enabled" | "toast" | "macos" | "onBlocked" | "onDone";
+export type NotificationToggleId =
+  | "enabled"
+  | "toast"
+  | "macos"
+  | "terminal"
+  | "onBlocked"
+  | "onDone";
 
 const onOff = (v: boolean) => (v ? "on" : "off");
 
 /** PURE — the notification toggle rows (the REAL fields notify.ts reads: the
- *  typed toast/macos plus the polish-era raw fields), and a quiet-hours row
- *  that descends into its own flow. Enter toggles in place. */
+ *  typed channel fields plus the polish-era raw fields), plus the rows that
+ *  descend into their own flows (sound tri-choice, delay prompt, quiet hours).
+ *  Enter toggles the boolean rows in place. */
 export function notificationItems(prefs: NotificationPrefs): DialogSelectItem[] {
   return [
     { id: "enabled", label: "All notifications", detail: onOff(prefs.enabled) },
     { id: "toast", label: "In-terminal toasts", detail: onOff(prefs.toast) },
-    { id: "macos", label: "macOS banners", detail: onOff(prefs.macos) },
+    { id: "macos", label: "System banners", detail: onOff(prefs.macos) },
+    { id: "terminal", label: "Terminal banners (OSC)", detail: onOff(prefs.terminal) },
     { id: "onBlocked", label: "Alert when an agent needs you", detail: onOff(prefs.onBlocked) },
     { id: "onDone", label: "Alert when an agent finishes", detail: onOff(prefs.onDone) },
+    { id: "sound", label: "Sound…", detail: soundSummary(prefs) },
+    { id: "delaySeconds", label: "Alert delay…", detail: delaySummary(prefs) },
     { id: "quietHours", label: "Quiet hours…", detail: quietHoursSummary(prefs) },
   ];
 }
 
+/** PURE — plain words for the sound tri-state. */
+export function soundSummary(prefs: NotificationPrefs): string {
+  return prefs.sound === "blocked" ? "when blocked" : prefs.sound === "all" ? "always" : "off";
+}
+
+/** PURE — the sound chooser rows (● on the saved choice). */
+export function soundItems(prefs: NotificationPrefs): DialogSelectItem[] {
+  return [
+    {
+      id: "blocked",
+      label: "When an agent needs you",
+      detail: "sound + terminal bell on blocked",
+      current: prefs.sound === "blocked",
+    },
+    {
+      id: "all",
+      label: "Every alert",
+      detail: "blocked and finished",
+      current: prefs.sound === "all",
+    },
+    { id: "none", label: "Off — no sound", current: prefs.sound === "none" },
+  ];
+}
+
+/** PURE — persist a picked sound mode. */
+export function soundPatch(id: string): AppConfigPatch {
+  return { notifications: { sound: id } };
+}
+
+/** PURE — "2 s" / "immediately". */
+export function delaySummary(prefs: NotificationPrefs): string {
+  return prefs.delaySeconds > 0 ? `${prefs.delaySeconds} s` : "immediately";
+}
+
+/** PURE — 0–60 whole seconds (0 = fire immediately; the delay exists to swallow
+ *  flappy transitions, and a minute is already generous). */
+export function validateDelaySeconds(value: string): string | null {
+  const n = Number(value.trim());
+  if (!Number.isInteger(n) || n < 0 || n > 60) {
+    return "Use a whole number of seconds between 0 and 60 (0 alerts immediately)";
+  }
+  return null;
+}
+
+/** PURE — persist a validated delay. */
+export function delaySecondsPatch(value: string): AppConfigPatch {
+  return { notifications: { delaySeconds: Number(value.trim()) } };
+}
+
 /** PURE — flip one notification toggle. */
 export function notificationTogglePatch(
   id: NotificationToggleId,
@@ -144,7 +197,7 @@ export function quietHoursItems(prefs: NotificationPrefs): DialogSelectItem[] {
     { id: "off", label: "Off — always notify", current: prefs.quietHours === null },
     {
       id: "window",
-      label: "Silence banners during a daily window…",
+      label: "Silence banners & sounds during a daily window…",
       detail: prefs.quietHours ? quietHoursSummary(prefs) : undefined,
       current: prefs.quietHours !== null,
     },
@@ -245,23 +298,12 @@ export function restorePatch(id: string): AppConfigPatch {
 /** Mirrors {@link ../chrome/statusline.ts}'s prefix-twin derivation — the
  *  letters tmux binds by default (never clobbered) and the documented remaps.
  *  A drift test asserts agreement with `prefixKeyBinds` for the defaults. */
-const PREFIX_TAKEN = new Set([..."cdfilmnopqrstwxz"]);
-const PREFIX_REMAP: Record<string, string> = { "M-m": "u", "M-p": "j", "M-,": "v" };
-
-/** PURE — the reliable `prefix <letter>` twin for an Alt key, or null when the
- *  letter is taken by a stock tmux bind and has no documented remap. */
-export function prefixTwinFor(altKey: string): string | null {
-  const remapped = PREFIX_REMAP[altKey];
-  if (remapped) return remapped;
-  const letter = /^M-([a-z])$/.exec(altKey)?.[1];
-  if (!letter || PREFIX_TAKEN.has(letter)) return null;
-  return letter;
-}
-
 /** PURE — the read-only shortcut rows: the chrome actions from the LIVE config
  *  (prefix-first, the Alt fast path second — the prefix form is the one that
- *  survives every keyboard protocol) and then the app's fixed keys. */
-export function keybindingItems(keys: AppKeys): DialogSelectItem[] {
+ *  survives every keyboard protocol) and then the app's fixed keys
+ *  ({@link APPLICATION_KEYBINDING_ROWS}). `superK` appends the kitty-protocol ⌘K fast path to
+ *  the palette row — shown only when the renderer actually enables it. */
+export function keybindingItems(keys: AppKeys, superK = false): DialogSelectItem[] {
   const chrome: Array<{ label: string; altKey: string }> = [
     { label: "Home cockpit", altKey: keys.home },
     { label: "Session switcher", altKey: keys.popup },
@@ -280,14 +322,10 @@ export function keybindingItems(keys: AppKeys): DialogSelectItem[] {
       detail: twin ? `prefix ${twin} · ${altKey}` : altKey,
     };
   });
-  const app: Array<[string, string]> = [
-    ["Command palette", "F5 · ^p"],
-    ["Home / Terminal / Files / Diff tabs", "F1–F4"],
-    ["Back to Home", "^g"],
-    ["Toggle editor", "^e"],
-    ["Detach from the app", "^q"],
-  ];
-  for (const [label, detail] of app) rows.push({ id: `app:${label}`, label, detail });
+  for (const { label, keycap } of APPLICATION_KEYBINDING_ROWS) {
+    const detail = superK && label === "Command palette" ? `${keycap} · ⌘K` : keycap;
+    rows.push({ id: `app:${label}`, label, detail });
+  }
   return rows;
 }