tmux-ide 2.9.4 → 2.9.6

package/packages/daemon/src/terminal/protocol/layout-parse.ts

@@ -20,6 +20,10 @@
  * tmux 3.7b server (splits, zoom, storms) — no tmux at test time.
  */
 
+// Internal parsing bound, matching fleet catalog capacity. This is NOT the
+// smaller pane-stream publication limit; future wire callers must enforce that.
+const MAX_TREE_LEAVES = 512;
+
 /** One visible pane rectangle, in window cells. `id` is `%`-prefixed. */
 export interface LayoutLeaf {
   id: string;
@@ -37,6 +41,39 @@ export interface ParsedLayout {
   leaves: LayoutLeaf[];
 }
 
+/** Opt-in validated ancestry. Runtime pane IDs are not semantic pane identities. */
+export type LayoutTreeNode =
+  | ({ kind: "leaf" } & LayoutLeaf)
+  | {
+      kind: "split";
+      axis: "cols" | "rows";
+      left: number;
+      top: number;
+      width: number;
+      height: number;
+      children: LayoutTreeNode[];
+    };
+
+interface TreeContext {
+  nodes: number;
+  ids: Set<string>;
+}
+
+/**
+ * Bounded ancestry parser, deliberately stricter than the legacy flat parser.
+ * Up to 512 leaves (fleet catalog bound), 1023 nodes, depth 64 and 64 KiB.
+ * Validates exact ordered tiling with one separator cell, including parent
+ * bounds. The checksum prefix is grammar only, not an authenticity proof.
+ */
+export function parseLayoutTree(layout: string): LayoutTreeNode | null {
+  if (layout.length > 64 * 1024 || !/^[0-9a-fA-F]{4},/.test(layout)) return null;
+  const s = layout.slice(5);
+  const root = parseCell(s, 0, [], { nodes: 0, ids: new Set() });
+  if (!root?.node || root.pos !== s.length || root.node.left !== 0 || root.node.top !== 0)
+    return null;
+  return root.node;
+}
+
 /** Parse a tmux layout string (`csum,WxH,X,Y…`). Null on any malformed input
  *  (the caller falls back to the slow list-panes path — never throw here). */
 export function parseLayout(layout: string): ParsedLayout | null {
@@ -53,31 +90,66 @@ function parseCell(
   s: string,
   pos: number,
   leaves: LayoutLeaf[],
-): { width: number; height: number; pos: number } | null {
+  tree?: TreeContext,
+  depth = 1,
+): { width: number; height: number; pos: number; node?: LayoutTreeNode } | null {
+  if (tree && (depth > 64 || ++tree.nodes > MAX_TREE_LEAVES * 2 - 1)) return null;
   const dims = readDims(s, pos);
   if (!dims) return null;
   const { width, height, left, top } = dims;
+  if (
+    tree &&
+    (![width, height, left, top, left + width, top + height].every(Number.isSafeInteger) ||
+      width <= 0 ||
+      height <= 0 ||
+      left < 0 ||
+      top < 0)
+  )
+    return null;
   pos = dims.pos;
   const ch = s[pos];
   if (ch === ",") {
     // Leaf: the numeric pane id.
     const id = readInt(s, pos + 1);
     if (!id) return null;
-    leaves.push({ id: `%${id.value}`, left, top, width, height });
-    return { width, height, pos: id.pos };
+    const leaf = { id: `%${id.value}`, left, top, width, height };
+    if (tree) {
+      if (
+        !Number.isSafeInteger(id.value) ||
+        tree.ids.has(leaf.id) ||
+        tree.ids.size >= MAX_TREE_LEAVES
+      )
+        return null;
+      tree.ids.add(leaf.id);
+    }
+    leaves.push(leaf);
+    return {
+      width,
+      height,
+      pos: id.pos,
+      ...(tree ? { node: { kind: "leaf" as const, ...leaf } } : {}),
+    };
   }
   if (ch === "{" || ch === "[") {
     const close = ch === "{" ? "}" : "]";
+    const children: LayoutTreeNode[] = [];
     pos++;
     for (;;) {
-      const child = parseCell(s, pos, leaves);
+      const child = parseCell(s, pos, leaves, tree, depth + 1);
       if (!child) return null;
+      if (tree && child.node) children.push(child.node);
       pos = child.pos;
       if (s[pos] === ",") {
         pos++;
         continue;
       }
-      if (s[pos] === close) return { width, height, pos: pos + 1 };
+      if (s[pos] === close) {
+        if (!tree) return { width, height, pos: pos + 1 };
+        const axis = ch === "{" ? "cols" : "rows";
+        const node: LayoutTreeNode = { kind: "split", axis, left, top, width, height, children };
+        if (!tilesParent(node)) return null;
+        return { width, height, pos: pos + 1, node };
+      }
       return null;
     }
   }
@@ -86,6 +158,24 @@ function parseCell(
   return null;
 }
 
+/** Child ordering and separator widths must describe precisely this parent. */
+function tilesParent(node: Extract<LayoutTreeNode, { kind: "split" }>): boolean {
+  if (node.children.length < 2) return false;
+  const cols = node.axis === "cols";
+  let next = cols ? node.left : node.top;
+  for (const child of node.children) {
+    if (
+      (cols ? child.left : child.top) !== next ||
+      (cols ? child.top : child.left) !== (cols ? node.top : node.left) ||
+      (cols ? child.height : child.width) !== (cols ? node.height : node.width)
+    )
+      return false;
+    next += (cols ? child.width : child.height) + 1;
+    if (!Number.isSafeInteger(next)) return false;
+  }
+  return next - 1 === (cols ? node.left + node.width : node.top + node.height);
+}
+
 /** Read `WxH,X,Y` at `pos`. */
 function readDims(
   s: string,

package/packages/daemon/src/terminal/protocol/native-split-resize.ts

@@ -0,0 +1,226 @@
+import { parseLayoutTree, type LayoutTreeNode } from "./layout-parse.ts";
+
+export interface NativeSplitResizeRequest {
+  readonly sessionId: string;
+  readonly windowId: string;
+  readonly expectedLayout: string;
+  readonly path: readonly number[];
+  readonly axis: "cols" | "rows";
+  readonly boundary: number;
+}
+
+/** Caller-owned runner must pin server/binary and bound execution/output. At
+ * mutation dispatch it must enforce generation/session/pane lifetime and
+ * authorizeBeforeEffect. Neither capability nor layout is an authority proof. */
+export type NativeSplitRunner = (args: readonly string[]) => string | Promise<string>;
+export type NativeSplitResizeResult =
+  | { status: "refused"; reason: "invalid-request" | "unsupported" }
+  | { status: "uncertain"; reason: "command-failed" | "invalid-receipt" }
+  | { status: "applied"; boundary: number; layout: string; tree: LayoutTreeNode; changed: boolean };
+
+function object(value: unknown, keys: readonly string[]): value is Record<string, unknown> {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === keys.length &&
+    keys.every((key) => Object.hasOwn(value, key))
+  );
+}
+function json(text: string, limit: number): unknown {
+  if (typeof text !== "string" || text.length > limit || Buffer.byteLength(text) > limit)
+    throw new Error("Bounded native response required");
+  return JSON.parse(text);
+}
+function capability(text: string): boolean {
+  const value = json(text, 1024);
+  return (
+    object(value, [
+      "schemaVersion",
+      "capability",
+      "sessionMembership",
+      "maxDepth",
+      "maxLeaves",
+      "maxGrid",
+    ]) &&
+    value.schemaVersion === 1 &&
+    value.capability === "split-resize-v1" &&
+    value.sessionMembership === "exact-session-link-v1" &&
+    value.maxDepth === 64 &&
+    value.maxLeaves === 512 &&
+    value.maxGrid === 4096
+  );
+}
+/** Read-only, uncached probe; the caller pins and bounds the selected server. */
+export async function supportsNativeSplitResize(runTmux: NativeSplitRunner): Promise<boolean> {
+  try {
+    return capability(await runTmux(["tmux-ide-resize-split", "-V"]));
+  } catch {
+    return false;
+  }
+}
+
+function validTree(tree: LayoutTreeNode): boolean {
+  let budget = 5;
+  const visit = (node: LayoutTreeNode): boolean => {
+    if (node.left + node.width > 4096 || node.top + node.height > 4096) return false;
+    budget += 21;
+    if (node.kind === "leaf") {
+      const id = node.id.slice(1);
+      if (!/^(0|[1-9][0-9]*)$/.test(id) || Number(id) > 0xffffffff) return false;
+      budget += id.length;
+    } else if (!node.children.every(visit)) return false;
+    return budget <= 8192;
+  };
+  return visit(tree);
+}
+function locate(tree: LayoutTreeNode, path: readonly number[]) {
+  let node = tree;
+  let parent: Extract<LayoutTreeNode, { kind: "split" }> | undefined;
+  for (const index of path) {
+    if (node.kind !== "split" || !node.children[index]) return null;
+    parent = node;
+    node = node.children[index]!;
+  }
+  return parent && path.at(-1)! < parent.children.length - 1 ? { parent, node } : null;
+}
+function edge(node: LayoutTreeNode, axis: "cols" | "rows") {
+  return axis === "cols" ? node.left + node.width : node.top + node.height;
+}
+function sameRect(a: LayoutTreeNode, b: LayoutTreeNode) {
+  return a.left === b.left && a.top === b.top && a.width === b.width && a.height === b.height;
+}
+/** Only geometry inside the exact parent may change, along the requested axis.
+ * Native redistribution can affect multiple siblings. This verifies convergence,
+ * not exclusive causation or authentication of the returned layout. */
+function preservesTree(
+  before: LayoutTreeNode,
+  after: LayoutTreeNode,
+  affected: LayoutTreeNode,
+  axis: "cols" | "rows",
+  inside = false,
+): boolean {
+  const begins = before === affected;
+  if (before.kind !== after.kind || ((!inside || begins) && !sameRect(before, after))) return false;
+  inside ||= begins;
+  if (
+    inside &&
+    (axis === "cols"
+      ? before.top !== after.top || before.height !== after.height
+      : before.left !== after.left || before.width !== after.width)
+  )
+    return false;
+  if (before.kind === "leaf") return after.kind === "leaf" && before.id === after.id;
+  return (
+    after.kind === "split" &&
+    before.axis === after.axis &&
+    before.children.length === after.children.length &&
+    before.children.every((child, index) =>
+      preservesTree(child, after.children[index]!, affected, axis, inside),
+    )
+  );
+}
+
+/** Internal foundation only; no route or native capability is enabled here.
+ * Capability is checked on every invocation, never cached across generations.
+ * A failed command or invalid post-dispatch receipt is uncertain: do not retry. */
+export async function resizeNativeSplit(
+  request: NativeSplitResizeRequest,
+  runTmux: NativeSplitRunner,
+): Promise<NativeSplitResizeResult> {
+  let captured: NativeSplitResizeRequest, before: LayoutTreeNode;
+  try {
+    if (
+      !object(request, ["sessionId", "windowId", "expectedLayout", "path", "axis", "boundary"]) ||
+      typeof request.sessionId !== "string" ||
+      !/^\$(0|[1-9][0-9]{0,9})$/.test(request.sessionId) ||
+      Number(request.sessionId.slice(1)) > 0xffffffff ||
+      typeof request.windowId !== "string" ||
+      !/^@(0|[1-9][0-9]{0,9})$/.test(request.windowId) ||
+      Number(request.windowId.slice(1)) > 0xffffffff ||
+      typeof request.expectedLayout !== "string" ||
+      !Array.isArray(request.path) ||
+      request.path.length < 1 ||
+      request.path.length >= 64 ||
+      request.path.some((index) => !Number.isInteger(index) || index < 0 || index > 511) ||
+      request.path.join(".").length > 256 ||
+      (request.axis !== "cols" && request.axis !== "rows") ||
+      !Number.isInteger(request.boundary) ||
+      request.boundary < 0 ||
+      request.boundary > 4096
+    )
+      return { status: "refused", reason: "invalid-request" };
+    const tree = parseLayoutTree(request.expectedLayout);
+    if (!tree || !validTree(tree)) return { status: "refused", reason: "invalid-request" };
+    const selected = locate(tree, request.path);
+    if (!selected || selected.parent.axis !== request.axis)
+      return { status: "refused", reason: "invalid-request" };
+    before = tree;
+    // Snapshot all command data before any await or externally supplied callback.
+    captured = { ...request, path: [...request.path] };
+  } catch {
+    return { status: "refused", reason: "invalid-request" };
+  }
+  try {
+    if (!capability(await runTmux(["tmux-ide-resize-split", "-V"])))
+      return { status: "refused", reason: "unsupported" };
+  } catch {
+    return { status: "refused", reason: "unsupported" };
+  }
+  let response: string;
+  try {
+    response = await runTmux([
+      "tmux-ide-resize-split",
+      "-t",
+      captured.windowId,
+      "-s",
+      captured.sessionId,
+      "-E",
+      captured.expectedLayout,
+      "-p",
+      captured.path.join("."),
+      "-a",
+      captured.axis,
+      "-c",
+      String(captured.boundary),
+    ]);
+  } catch {
+    return { status: "uncertain", reason: "command-failed" };
+  }
+  try {
+    const receipt = json(response, 16 * 1024);
+    if (
+      !object(receipt, ["schemaVersion", "boundary", "layout"]) ||
+      receipt.schemaVersion !== 1 ||
+      typeof receipt.layout !== "string" ||
+      typeof receipt.boundary !== "number" ||
+      !Number.isInteger(receipt.boundary) ||
+      receipt.boundary < 0 ||
+      receipt.boundary > 4096
+    )
+      return { status: "uncertain", reason: "invalid-receipt" };
+    const after = parseLayoutTree(receipt.layout);
+    const original = locate(before, captured.path)!;
+    const actual = after && locate(after, captured.path);
+    const previous = edge(original.node, captured.axis);
+    if (
+      !after ||
+      !validTree(after) ||
+      !actual ||
+      !preservesTree(before, after, original.parent, captured.axis) ||
+      receipt.boundary !== edge(actual.node, captured.axis) ||
+      receipt.boundary < Math.min(previous, captured.boundary) ||
+      receipt.boundary > Math.max(previous, captured.boundary)
+    )
+      return { status: "uncertain", reason: "invalid-receipt" };
+    return {
+      status: "applied",
+      boundary: receipt.boundary,
+      layout: receipt.layout,
+      tree: after,
+      changed: receipt.layout !== captured.expectedLayout,
+    };
+  } catch {
+    return { status: "uncertain", reason: "invalid-receipt" };
+  }
+}

package/packages/daemon/src/terminal/session-runtime/causal-cell-ledger.ts

@@ -63,7 +63,7 @@ function colorsEqual(
   );
 }
 
-function cellsEqual(
+export function cellsEqual(
   left: TerminalReplicaSnapshot["grid"][number]["cells"][number] | undefined,
   right: TerminalReplicaSnapshot["grid"][number]["cells"][number] | undefined,
 ): boolean {

package/packages/daemon/src/terminal/session-runtime/interaction-receipt-facts.ts

@@ -19,6 +19,16 @@ export function sessionRuntimeInteractionFacts(
   intent: SessionRuntimeSemanticIntent,
 ): SessionRuntimeInteractionFacts {
   switch (intent.verb) {
+    case "workspace.window.split.resize":
+      return {
+        target: { kind: "window-link", target: intent.target.window },
+        summary: {
+          operationKind: intent.verb,
+          layoutId: intent.target.layoutId,
+          splitId: intent.target.splitId,
+          boundary: intent.target.boundary,
+        },
+      };
     case "workspace.window.split":
       return {
         target: { kind: "pane", semanticPaneId: intent.semanticPaneId },
@@ -118,6 +128,20 @@ export function sessionRuntimeObservedProof(
   if (result.verb !== intent.verb)
     throw new TypeError("Mutation result verb does not match intent");
   switch (result.verb) {
+    case "workspace.window.split.resize":
+      if (
+        intent.verb !== result.verb ||
+        JSON.stringify(result.target) !== JSON.stringify(intent.target)
+      )
+        throw new TypeError("Split resize result does not match intent");
+      return {
+        operationKind: result.verb,
+        outcome: result.outcome,
+        target: result.target,
+        axis: result.axis,
+        boundary: result.boundary,
+        ...(result.successor === undefined ? {} : { successor: result.successor }),
+      };
     case "workspace.window.link.select":
     case "workspace.window.link.unlink":
       return { operationKind: result.verb, outcome: result.outcome, target: result.target };