tmux-ide 2.8.0 → 2.9.0-beta.6

package/packages/daemon/src/tui/mirror/renderer-commands.ts

@@ -0,0 +1,344 @@
+import {
+  COMMAND_PROTOCOL_VERSION,
+  WORKSPACE_WINDOW_MODE_COMMAND_IDS,
+  type CommandArguments,
+  type CommandDescriptor,
+  type CommandInvocation,
+  type CommandResolutionError,
+  type CommandSource,
+} from "@tmux-ide/contracts";
+import { z } from "zod";
+import { CommandRegistry, type CommandDefinition } from "../../lib/command-registry.ts";
+import type { TuiGlobalCommand, TuiLifecycleCommand } from "./input-lifecycle.ts";
+import type { WorkbenchCanvasPanel } from "./workspace/workbench-controller.ts";
+import type { WorkbenchDockTabId } from "./workspace/workbench-shell.ts";
+
+export const RENDERER_COMMAND_IDS = {
+  openPalette: "app.palette.open",
+  quit: "app.quit",
+  cycleCompositeFocus: "workspace.composite.focusCycle",
+  activateShortcut: "workspace.shortcut.activate",
+  activateView: "workspace.view.activate",
+  activateCanvas: "workspace.canvas.activate",
+  activateDock: "workspace.dock.activate",
+  openHome: "workspace.home.open",
+  toggleEditor: "workspace.editor.toggle",
+  togglePerformanceHud: "app.performanceHud.toggle",
+} as const;
+
+export type RendererCommandId = (typeof RENDERER_COMMAND_IDS)[keyof typeof RENDERER_COMMAND_IDS];
+
+/** Raw terminal channels are transport/data paths, never semantic commands. */
+export const RENDERER_COMMAND_BYPASS_CHANNELS = [
+  "ctrl-c",
+  "paste",
+  "pty-output",
+  "resize",
+] as const;
+
+export interface RendererCommandContext {
+  compositeFocusAvailable: boolean;
+  editorAvailable: boolean;
+}
+
+export interface RendererCommandEffects {
+  openPalette: () => void;
+  runLifecycle: (command: TuiLifecycleCommand) => void;
+  cycleCompositeFocus: () => void;
+  activateShortcut: (key: string) => void;
+  activateView: (viewId: string) => void;
+  activateCanvas: (panel: WorkbenchCanvasPanel) => void;
+  activateDock: (tab: WorkbenchDockTabId) => void;
+  openHome: () => void;
+  toggleEditor: () => void;
+  togglePerformanceHud: () => void;
+}
+
+export type RendererCommandExecution =
+  | { ok: true; commandId: RendererCommandId }
+  | { ok: false; error: CommandResolutionError };
+
+const EmptyInputSchemaZ = z.object({}).strict();
+const LifecycleInputSchemaZ = z.discriminatedUnion("kind", [
+  z
+    .object({
+      kind: z.literal("destroy-renderer"),
+      source: z.enum(["keyboard", "palette", "error"]),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("hosted-detach"),
+      source: z.literal("keyboard"),
+    })
+    .strict(),
+]);
+const ShortcutInputSchemaZ = z.object({ key: z.string().min(1).max(32) }).strict();
+const ViewInputSchemaZ = z.object({ viewId: z.string().min(1).max(160) }).strict();
+const CanvasInputSchemaZ = z.object({ panel: z.enum(["home", "terminals"]) }).strict();
+const DockInputSchemaZ = z
+  .object({ tab: z.enum(["files", "changes", "missions", "activity"]) })
+  .strict();
+
+interface RendererCommandMetadata {
+  id: RendererCommandId;
+  label: string;
+  category: string;
+  inputSchema: z.ZodType;
+  availability?: CommandDefinition<RendererCommandContext>["availability"];
+}
+
+const metadata: readonly RendererCommandMetadata[] = [
+  {
+    id: RENDERER_COMMAND_IDS.openPalette,
+    label: "Open command palette",
+    category: "application",
+    inputSchema: EmptyInputSchemaZ,
+  },
+  {
+    id: RENDERER_COMMAND_IDS.quit,
+    label: "Quit or detach",
+    category: "application",
+    inputSchema: LifecycleInputSchemaZ,
+  },
+  {
+    id: RENDERER_COMMAND_IDS.cycleCompositeFocus,
+    label: "Cycle composite focus",
+    category: "workspace",
+    inputSchema: EmptyInputSchemaZ,
+    availability: (context) =>
+      context.compositeFocusAvailable
+        ? { available: true }
+        : { available: false, reason: "composite focus is unavailable" },
+  },
+  {
+    id: RENDERER_COMMAND_IDS.activateShortcut,
+    label: "Activate workspace shortcut",
+    category: "workspace",
+    inputSchema: ShortcutInputSchemaZ,
+  },
+  {
+    id: RENDERER_COMMAND_IDS.activateView,
+    label: "Activate workspace view",
+    category: "workspace",
+    inputSchema: ViewInputSchemaZ,
+  },
+  {
+    id: RENDERER_COMMAND_IDS.activateCanvas,
+    label: "Activate canvas panel",
+    category: "workspace",
+    inputSchema: CanvasInputSchemaZ,
+  },
+  {
+    id: RENDERER_COMMAND_IDS.activateDock,
+    label: "Activate dock panel",
+    category: "workspace",
+    inputSchema: DockInputSchemaZ,
+  },
+  {
+    id: RENDERER_COMMAND_IDS.openHome,
+    label: "Open Home",
+    category: "workspace",
+    inputSchema: EmptyInputSchemaZ,
+  },
+  {
+    id: RENDERER_COMMAND_IDS.toggleEditor,
+    label: "Toggle editor",
+    category: "workspace",
+    inputSchema: EmptyInputSchemaZ,
+    availability: (context) =>
+      context.editorAvailable
+        ? { available: true }
+        : { available: false, reason: "no file is open" },
+  },
+  {
+    id: RENDERER_COMMAND_IDS.togglePerformanceHud,
+    label: "Toggle performance HUD",
+    category: "application",
+    inputSchema: EmptyInputSchemaZ,
+  },
+];
+
+function descriptor(item: RendererCommandMetadata): CommandDescriptor {
+  return Object.freeze({
+    version: COMMAND_PROTOCOL_VERSION,
+    id: item.id,
+    owner: "renderer",
+    label: item.label,
+    category: item.category,
+    schemas: Object.freeze({ input: `${item.id}.input.v1` }),
+    dangerous: false,
+    confirmation: "none",
+  });
+}
+
+export const RENDERER_COMMAND_DEFINITIONS: readonly CommandDefinition<RendererCommandContext>[] =
+  Object.freeze(
+    metadata.map((item) =>
+      Object.freeze({
+        descriptor: descriptor(item),
+        inputSchema: item.inputSchema,
+        ...(item.availability ? { availability: item.availability } : {}),
+      }),
+    ),
+  );
+
+export function createRendererCommandRegistry(): CommandRegistry<RendererCommandContext> {
+  return new CommandRegistry(RENDERER_COMMAND_DEFINITIONS);
+}
+
+const canonicalRendererCommandRegistry = createRendererCommandRegistry();
+
+const rendererCommandIds = new Set<string>(Object.values(RENDERER_COMMAND_IDS));
+
+function isRendererCommandId(id: string): id is RendererCommandId {
+  return rendererCommandIds.has(id);
+}
+
+export function rendererCommandInvocation(
+  id: RendererCommandId,
+  args: CommandArguments,
+  source: CommandSource,
+): CommandInvocation {
+  return {
+    version: COMMAND_PROTOCOL_VERSION,
+    id,
+    source,
+    args,
+  };
+}
+
+export function rendererInvocationForLifecycle(command: TuiLifecycleCommand): CommandInvocation {
+  return rendererCommandInvocation(
+    RENDERER_COMMAND_IDS.quit,
+    { kind: command.kind, source: command.source },
+    {
+      kind:
+        command.source === "keyboard"
+          ? "keyboard"
+          : command.source === "palette"
+            ? "palette"
+            : "program",
+      surface: "application",
+    },
+  );
+}
+
+export function rendererInvocationForGlobal(command: TuiGlobalCommand): CommandInvocation {
+  const source: CommandSource = { kind: "keyboard", surface: "workbench" };
+  switch (command.kind) {
+    case "cycle-composite-focus":
+      return rendererCommandInvocation(RENDERER_COMMAND_IDS.cycleCompositeFocus, {}, source);
+    case "open-palette":
+      return rendererCommandInvocation(RENDERER_COMMAND_IDS.openPalette, {}, source);
+    case "select-hosted-view":
+      return rendererCommandInvocation(
+        RENDERER_COMMAND_IDS.activateShortcut,
+        { key: command.key },
+        source,
+      );
+    case "go-home":
+      return rendererCommandInvocation(RENDERER_COMMAND_IDS.openHome, {}, source);
+    case "toggle-editor":
+      return rendererCommandInvocation(RENDERER_COMMAND_IDS.toggleEditor, {}, source);
+    case "toggle-performance-hud":
+      return rendererCommandInvocation(RENDERER_COMMAND_IDS.togglePerformanceHud, {}, source);
+  }
+}
+
+export function rendererInvocationForCanvas(
+  panel: WorkbenchCanvasPanel,
+  source: CommandSource,
+): CommandInvocation {
+  return rendererCommandInvocation(RENDERER_COMMAND_IDS.activateCanvas, { panel }, source);
+}
+
+export function rendererInvocationForDock(
+  tab: WorkbenchDockTabId,
+  source: CommandSource,
+): CommandInvocation {
+  return rendererCommandInvocation(RENDERER_COMMAND_IDS.activateDock, { tab }, source);
+}
+
+export function rendererInvocationForView(
+  viewId: string,
+  source: CommandSource,
+): CommandInvocation {
+  return rendererCommandInvocation(RENDERER_COMMAND_IDS.activateView, { viewId }, source);
+}
+
+export function createRendererCommandExecutor(input: {
+  context: () => RendererCommandContext;
+  effects: RendererCommandEffects;
+  onRejected?: (error: CommandResolutionError) => void;
+}): { execute(invocation: CommandInvocation): RendererCommandExecution } {
+  // Keep execution closed over the canonical catalog. Tests can inject state,
+  // effects, and rejection observation, but never alternate IDs or schemas.
+  return {
+    execute(invocation) {
+      const resolved = canonicalRendererCommandRegistry.resolve(invocation, input.context());
+      if (!resolved.ok) {
+        input.onRejected?.(resolved.error);
+        return resolved;
+      }
+      if (resolved.command.descriptor.owner !== "renderer") {
+        const error: CommandResolutionError = {
+          code: "unavailable",
+          commandId: resolved.command.descriptor.id,
+          message: `Command is owned by ${resolved.command.descriptor.owner}`,
+        };
+        input.onRejected?.(error);
+        return { ok: false, error };
+      }
+      const commandId = resolved.command.descriptor.id;
+      if (!isRendererCommandId(commandId)) {
+        const error: CommandResolutionError = {
+          code: "unknown-command",
+          commandId,
+          message: `Unknown renderer command: ${commandId}`,
+        };
+        input.onRejected?.(error);
+        return { ok: false, error };
+      }
+      switch (commandId) {
+        case RENDERER_COMMAND_IDS.openPalette:
+          input.effects.openPalette();
+          break;
+        case RENDERER_COMMAND_IDS.quit:
+          input.effects.runLifecycle(LifecycleInputSchemaZ.parse(resolved.command.input));
+          break;
+        case RENDERER_COMMAND_IDS.cycleCompositeFocus:
+          input.effects.cycleCompositeFocus();
+          break;
+        case RENDERER_COMMAND_IDS.activateShortcut:
+          input.effects.activateShortcut(ShortcutInputSchemaZ.parse(resolved.command.input).key);
+          break;
+        case RENDERER_COMMAND_IDS.activateView:
+          input.effects.activateView(ViewInputSchemaZ.parse(resolved.command.input).viewId);
+          break;
+        case RENDERER_COMMAND_IDS.activateCanvas:
+          input.effects.activateCanvas(CanvasInputSchemaZ.parse(resolved.command.input).panel);
+          break;
+        case RENDERER_COMMAND_IDS.activateDock:
+          input.effects.activateDock(DockInputSchemaZ.parse(resolved.command.input).tab);
+          break;
+        case RENDERER_COMMAND_IDS.openHome:
+          input.effects.openHome();
+          break;
+        case RENDERER_COMMAND_IDS.toggleEditor:
+          input.effects.toggleEditor();
+          break;
+        case RENDERER_COMMAND_IDS.togglePerformanceHud:
+          input.effects.togglePerformanceHud();
+          break;
+      }
+      return { ok: true, commandId };
+    },
+  };
+}
+
+/** Drift guard: Card07 only reserves these names; Card12 owns their behavior. */
+export function rendererRegistersReservedWindowModeCommand(): boolean {
+  const registered = new Set(RENDERER_COMMAND_DEFINITIONS.map((item) => item.descriptor.id));
+  return WORKSPACE_WINDOW_MODE_COMMAND_IDS.some((id) => registered.has(id));
+}

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

@@ -3,11 +3,12 @@
  *  between adjacent panes show the canvas background as a SEPARATOR. A "down"
  *  landing on a separator (a canvas-local cell inside no pane rect, flanked by
  *  two panes) starts a border drag; the router turns the drag delta into an
- *  ABSOLUTE new size and applies it via `resize-pane -t <a> -x|-y <cells>`
+ *  ABSOLUTE new size and applies it through the shared multiplexer authority
  *  (smoother than repeated -L/-R steps, and %layout-change resyncs the render).
  *  Keeping the hit-test + size math here (like spans/menu-model/diff-model) makes
- *  it unit-testable off the render loop. All coordinates are CANVAS-LOCAL: cx is
- *  `x - sidebarW`, cy is `y - TABBAR_H - HEADER_ROWS`. */
+ *  it unit-testable off the render loop. Pane coordinates are FRAMEBUFFER-LOCAL;
+ *  callers translate through the projected terminal canvas instead of repeating
+ *  shell/sidebar/chrome offsets. */
 
 /** The minimal pane rectangle the hit test needs (LivePane is assignable). */
 export interface PaneRect {
@@ -26,12 +27,30 @@ export interface PaneRect {
  *  to (a) and the far bound (b) the clamp protects. */
 export interface Separator {
   axis: "x" | "y";
+  /** Framebuffer-local separator column/row. */
+  position: number;
+  /** Covered interval on the perpendicular axis, end-exclusive. */
+  start: number;
+  end: number;
   aId: string;
   bId: string;
   aSize: number;
   bSize: number;
 }
 
+/** The framebuffer origin inside the app-owned terminal canvas. */
+export interface FramebufferOrigin {
+  x: number;
+  y: number;
+}
+
+export interface ResizeGuideRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
 /** Does pane `p` contain canvas cell (cx,cy)? */
 function inside(p: PaneRect, cx: number, cy: number): boolean {
   return cx >= p.left && cx < p.left + p.width && cy >= p.top && cy < p.top + p.height;
@@ -53,18 +72,53 @@ export function separatorAt(panes: readonly PaneRect[], cx: number, cy: number):
     if (a.left + a.width !== cx) continue;
     if (cy < a.top || cy >= a.top + a.height) continue;
     const b = panes.find((q) => q.left === cx + 1 && cy >= q.top && cy < q.top + q.height);
-    if (b) return { axis: "x", aId: a.id, bId: b.id, aSize: a.width, bSize: b.width };
+    if (b)
+      return {
+        axis: "x",
+        position: cx,
+        start: Math.max(a.top, b.top),
+        end: Math.min(a.top + a.height, b.top + b.height),
+        aId: a.id,
+        bId: b.id,
+        aSize: a.width,
+        bSize: b.width,
+      };
   }
   // Horizontal separator: `a` ends at row cy, `b` begins at cy+1, both cover cx.
   for (const a of panes) {
     if (a.top + a.height !== cy) continue;
     if (cx < a.left || cx >= a.left + a.width) continue;
     const b = panes.find((q) => q.top === cy + 1 && cx >= q.left && cx < q.left + q.width);
-    if (b) return { axis: "y", aId: a.id, bId: b.id, aSize: a.height, bSize: b.height };
+    if (b)
+      return {
+        axis: "y",
+        position: cy,
+        start: Math.max(a.left, b.left),
+        end: Math.min(a.left + a.width, b.left + b.width),
+        aId: a.id,
+        bId: b.id,
+        aSize: a.height,
+        bSize: b.height,
+      };
   }
   return null;
 }
 
+/**
+ * Resolve a divider from APP-CANVAS coordinates using the exact projected
+ * framebuffer origin. This is the seam between Workbench layout and tmux pane
+ * geometry: focus rails and native pane chrome remain app-owned and can never
+ * skew the gutter hit-test.
+ */
+export function separatorAtCanvas(
+  panes: readonly PaneRect[],
+  framebuffer: FramebufferOrigin,
+  canvasX: number,
+  canvasY: number,
+): Separator | null {
+  return separatorAt(panes, canvasX - framebuffer.x, canvasY - framebuffer.y);
+}
+
 /**
  * PURE — the absolute new extent for pane `a` given a drag `delta` (in cells)
  * along the separator's axis. Clamped so neither pane drops below `MIN_PANE`:
@@ -78,8 +132,19 @@ export function resizedSize(sep: Separator, delta: number): number {
   return Math.max(MIN_PANE, Math.min(total - MIN_PANE, sep.aSize + delta));
 }
 
-/** PURE — the `resize-pane` command applying an absolute `size` to pane `aId`
- *  along `axis` (x = width, y = height). */
-export function resizeCommand(sep: Separator, size: number): string {
-  return `resize-pane -t ${sep.aId} ${sep.axis === "x" ? "-x" : "-y"} ${size}`;
+/** Exact one-cell visual guide for hover/drag feedback. */
+export function resizeGuideRect(sep: Separator, delta = 0): ResizeGuideRect {
+  return sep.axis === "x"
+    ? {
+        x: sep.position + delta,
+        y: sep.start,
+        width: 1,
+        height: Math.max(1, sep.end - sep.start),
+      }
+    : {
+        x: sep.start,
+        y: sep.position + delta,
+        width: Math.max(1, sep.end - sep.start),
+        height: 1,
+      };
 }