tmux-ide 2.9.6 → 2.9.8

package/packages/daemon/src/terminal/session-runtime/transport-binding.ts

@@ -104,6 +104,13 @@ function assertLiveControllerPrincipal(
   }
 }
 
+function holdsCurrentLease(shared: SharedClient): boolean {
+  const lease = shared.lease;
+  if (!lease) return false;
+  const snapshot = shared.consumer.controllerSnapshot();
+  return snapshot.controllerClientId === lease.clientId && snapshot.revision === lease.revision;
+}
+
 const clientsByRegistry = new WeakMap<object, Map<string, SharedClient>>();
 
 function authenticatedSurface(transport: SessionRuntimeTransport, hostClientId: string): string {
@@ -451,6 +458,11 @@ export class SessionRuntimeTransportBinding {
     }
   }
 
+  setCellPixels(width: number, height: number, precise?: { width: number; height: number }): void {
+    this.#assertOpen();
+    this.#shared.consumer.setCellPixels?.(width, height, precise);
+  }
+
   fitViewport(
     expectedLease: SessionRuntimeAuthorityLease,
     cols: number,
@@ -695,20 +707,37 @@ export class SessionRuntimeTransportBinder {
   }
 
   activateController(target: SharedClient): void {
-    if (target.lease) return;
-    const current = [...this.#clients.values()].find(
-      (candidate) =>
-        candidate !== target &&
-        candidate.consumer.session === target.consumer.session &&
-        candidate.lease,
-    );
-    if (current?.lease) {
-      const previous = current.lease;
-      current.lease = null;
-      target.lease = current.consumer.handoffController(previous, target.consumer.clientId);
+    if (target.lease && holdsCurrentLease(target)) return;
+    target.lease = null;
+    const controllerClientId = target.consumer.controllerSnapshot().controllerClientId;
+    const current =
+      controllerClientId === null || controllerClientId === target.consumer.clientId
+        ? undefined
+        : [...this.#clients.values()].find(
+            (candidate) =>
+              candidate !== target &&
+              candidate.consumer.session === target.consumer.session &&
+              candidate.consumer.clientId === controllerClientId,
+          );
+    if (!current) {
+      // Free, already ours, or held by a principal outside this binder (for
+      // example the command-center owner route): plain acquisition decides.
+      target.lease = target.consumer.acquireController();
       return;
     }
-    target.lease = target.consumer.acquireController();
+    // A transport-bound holder whose binding lost its executable lease can
+    // never type again, yet it would keep every other viewer locked out. Re-
+    // derive its exact current lease so the handoff below reclaims it; a live
+    // holder simply hands off as before. Either way only one client can type.
+    const previous =
+      current.lease && holdsCurrentLease(current)
+        ? current.lease
+        : current.consumer.acquireController();
+    const handedOff = current.consumer.handoffController(previous, target.consumer.clientId);
+    // Drop the holder's lease only after the runtime accepted the handoff; a
+    // refusal (e.g. during topology verification) must leave it executable.
+    current.lease = null;
+    target.lease = handedOff;
   }
 
   async release(
@@ -727,18 +756,23 @@ export class SessionRuntimeTransportBinder {
     }
     shared.refs -= 1;
     if (shared.refs > 0) return;
-    if (shared.lease) {
-      // A same-host passive session channel keeps the controller PRINCIPAL
-      // continuous across interactive pane retargeting. It contributes no
-      // source-pane grant and cannot type; the lease retires with the last
-      // host/session ref, while a passive-only host never acquires one.
-      const retired = shared.lease;
-      shared.lease = null;
-      shared.consumer.releaseController(retired);
-    }
-    for (const [key, candidate] of this.#clients) {
-      if (candidate === shared) this.#clients.delete(key);
+    try {
+      if (shared.lease) {
+        // A same-host passive session channel keeps the controller PRINCIPAL
+        // continuous across interactive pane retargeting. It contributes no
+        // source-pane grant and cannot type; the lease retires with the last
+        // host/session ref, while a passive-only host never acquires one.
+        const retired = shared.lease;
+        shared.lease = null;
+        shared.consumer.releaseController(retired);
+      }
+    } finally {
+      // A refused surrender must never strand the controller on a client with
+      // no transport: closing the consumer retires whatever it still owns.
+      for (const [key, candidate] of this.#clients) {
+        if (candidate === shared) this.#clients.delete(key);
+      }
+      await shared.consumer.close();
     }
-    await shared.consumer.close();
   }
 }

package/packages/daemon/src/terminal/session-runtime/xterm-terminal-interpreter-backend.ts

@@ -102,6 +102,19 @@ export class XtermTerminalInterpreterBackend implements TerminalInterpreterBacke
     return this.#terminal.rows;
   }
 
+  graphicsCursor(): { x: number; line: number; alternate: boolean } {
+    const buffer = this.#terminal.buffer.active;
+    return {
+      x: Math.min(buffer.cursorX, this.#terminal.cols - 1),
+      line: buffer.baseY + buffer.cursorY,
+      alternate: buffer.type === "alternate",
+    };
+  }
+
+  graphicsViewportTop(): number {
+    return this.#terminal.buffer.active.baseY;
+  }
+
   write(data: Uint8Array | string): Promise<void> {
     return new Promise((resolve) => this.#terminal.write(data, resolve));
   }

package/packages/daemon/src/tui/mirror/runtime/application-home-agents-owner.ts

@@ -326,7 +326,12 @@ export function createApplicationHomeNavigationOwner(options: {
         command === "switch-session"
       )
         return null;
-      if (options.sessionOwner()?.snapshot()?.status !== "live") return "Open a live session first";
+      const status = options.sessionOwner()?.snapshot()?.status;
+      if (status !== "live") {
+        if (status === "rebinding") return "Terminal is updating. Try again shortly.";
+        if (status === "connecting") return "Opening terminal…";
+        return "Open a live session first";
+      }
       return command !== "new-window" && command !== "new-agent" && !options.focusedPane()
         ? "Select a live pane first"
         : null;

package/packages/daemon/src/tui/mirror/runtime/application-terminal-input-ingress.ts

@@ -108,7 +108,9 @@ export function createApplicationTerminalInputIngress(
     recovery = null;
   };
   const recover = (
-    inputs: ReturnType<typeof terminalInputsForPaste>,
+    inputs:
+      | ReturnType<typeof terminalInputsForPaste>
+      | (() => ReturnType<typeof terminalInputsForPaste> | null),
     bytes: Uint8Array,
     kind: "input" | "paste",
   ): boolean => {
@@ -145,7 +147,15 @@ export function createApplicationTerminalInputIngress(
         }
       : undefined;
     recovery.inputs.push(async () => {
-      for (const [index, input] of inputs.entries()) {
+      if (
+        version !== recoveryVersion ||
+        !sameScope(target, scope()) ||
+        generation()?.status !== "live"
+      )
+        return false;
+      const framed = typeof inputs === "function" ? inputs() : inputs;
+      if (framed === null) return false;
+      for (const [index, input] of framed.entries()) {
         if (
           version !== recoveryVersion ||
           !sameScope(target, scope()) ||
@@ -197,6 +207,23 @@ export function createApplicationTerminalInputIngress(
       }
     })();
   };
+  const pasteMode = (): boolean | null => {
+    const active = generation();
+    const pane = focusedPane();
+    if (active?.status !== "live" || !active.fastLane || !pane) return null;
+    const mode = active.fastLane.lane.paneState(pane)?.snapshot?.modes.bracketedPaste;
+    return typeof mode === "boolean" ? mode : null;
+  };
+  const deliverPaste = (bytes: Uint8Array): void => {
+    const mode = pasteMode();
+    if (mode === null) {
+      // Do not let the successful drain of the surrounding FIFO hide refusal.
+      ownsNote = false;
+      setNote("terminal unavailable · paste was not sent");
+      return;
+    }
+    sendApplicationTerminalPaste(interaction, bytes, captureOrigin(), mode);
+  };
   const captureOrigin = (): boolean =>
     Boolean(currentTuiPerformanceEventSink()?.terminalInputOrigin);
   const flush = (): void => {
@@ -291,7 +318,7 @@ export function createApplicationTerminalInputIngress(
       if (bytes.length === 0) return;
       const copy = Uint8Array.from(bytes);
       try {
-        terminalInputsForPaste(Buffer.from(copy).toString("utf8"));
+        terminalInputsForPaste(Buffer.from(copy).toString("utf8"), false);
       } catch {
         setNote("terminal unavailable · paste was rejected");
         return;
@@ -304,16 +331,24 @@ export function createApplicationTerminalInputIngress(
         active.fastLane &&
         focusedPane()
       ) {
-        sendApplicationTerminalPaste(interaction, copy, captureOrigin());
+        deliverPaste(copy);
         return;
       }
-      if (recover(terminalInputsForPaste(Buffer.from(copy).toString("utf8")), copy, "paste"))
+      if (
+        recover(
+          () => {
+            const mode = pasteMode();
+            return mode === null
+              ? null
+              : terminalInputsForPaste(Buffer.from(copy).toString("utf8"), mode);
+          },
+          copy,
+          "paste",
+        )
+      )
         return;
       noteAdmission(
-        pending.enqueue(
-          () => sendApplicationTerminalPaste(interaction, copy, captureOrigin()),
-          copy.byteLength,
-        ),
+        pending.enqueue(() => deliverPaste(copy), copy.byteLength),
         "paste",
       );
     },

package/packages/daemon/src/tui/mirror/runtime/application-terminal-paste.ts

@@ -20,9 +20,10 @@ export function sendApplicationTerminalPaste(
   interaction: ApplicationTerminalInteractionController,
   bytes: Uint8Array,
   captureOrigin: boolean,
+  bracketedPaste: boolean,
 ): void {
   const text = Buffer.from(bytes).toString("utf8");
-  const inputs = terminalInputsForPaste(text);
+  const inputs = terminalInputsForPaste(text, bracketedPaste);
   for (let index = 0; index < inputs.length; index += 1) {
     const parserOrigin =
       index === 0 && captureOrigin

package/packages/daemon/src/tui/mirror/runtime/terminal-input-adapter.ts

@@ -48,10 +48,13 @@ export function terminalInputForOpenTuiKey(
 }
 
 /** Preserve paste ordering and bracketed-paste semantics without an unbounded frame. */
-export function terminalInputsForPaste(text: string): readonly SessionRuntimeTerminalInput[] {
+export function terminalInputsForPaste(
+  text: string,
+  bracketedPaste: boolean,
+): readonly SessionRuntimeTerminalInput[] {
   if (text.length === 0) return [];
   if (text.includes("\0")) throw new TypeError("terminal paste must not contain NUL");
-  const framed = `\u001b[200~${text}\u001b[201~`;
+  const framed = bracketedPaste ? `\u001b[200~${text}\u001b[201~` : text;
   const inputs: SessionRuntimeTerminalInput[] = [];
   for (let offset = 0; offset < framed.length; ) {
     let end = Math.min(offset + SESSION_RUNTIME_MAX_TERMINAL_INPUT_TEXT_CHARS, framed.length);

package/packages/daemon-client/src/fleet-connection-status.ts

@@ -25,7 +25,7 @@ export function fleetConnectionMessage(status: FleetConnectionStatus): string {
     case "invalid-target":
       return "Check the SSH alias in this machine's settings.";
     case "incompatible":
-      return "Incompatible daemon protocol. Update the remote daemon, then retry.";
+      return "App and remote daemon protocols are incompatible. Check that this app and tmux-ide on the remote machine are up to date, then retry.";
     case "invalid-descriptor":
       return "Remote daemon discovery returned an invalid response. Check the installation.";
     case "daemon-missing":

package/packages/daemon-client/src/pane-creation-refusal.ts

@@ -0,0 +1,48 @@
+/** Read only a fixed refusal code; never retain server messages or private context. */
+export async function readPaneCreationRefusal(
+  response: Response,
+  signal: AbortSignal,
+): Promise<"harness_unavailable" | undefined> {
+  if (response.status !== 409 || !response.body) return undefined;
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let length = 0;
+  try {
+    for (;;) {
+      signal.throwIfAborted();
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.byteLength;
+      if (length > 1024) return undefined;
+      chunks.push(value);
+    }
+    signal.throwIfAborted();
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const value: unknown = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    if (
+      !value ||
+      typeof value !== "object" ||
+      Object.keys(value).length !== 1 ||
+      !("error" in value)
+    )
+      return undefined;
+    const error = value.error;
+    return error &&
+      typeof error === "object" &&
+      Object.keys(error).length === 1 &&
+      "code" in error &&
+      error.code === "harness_unavailable"
+      ? "harness_unavailable"
+      : undefined;
+  } catch {
+    return undefined;
+  } finally {
+    await reader.cancel().catch(() => undefined);
+    reader.releaseLock();
+  }
+}

package/packages/daemon-client/src/pane-stream-client.ts

@@ -33,6 +33,9 @@ import {
   type TerminalDeliveryVisibility,
   type WorkspaceMultiplexerMutationResult,
   type WindowLinkTopology,
+  TERMINAL_GRAPHICS_MAX_REQUEST_DIGESTS,
+  type TerminalGraphicsBlob,
+  type TerminalGraphicsState,
 } from "@tmux-ide/contracts";
 import {
   calibratePaneStreamClocks,
@@ -270,6 +273,14 @@ export interface OpenPaneStreamClientOptions {
   readonly onClockCalibrationOutcome?: (outcome: PaneStreamClockCalibrationOutcome) => void;
   readonly diagnosticNextTurn?: (callback: () => void) => () => void;
   readonly onLayout?: (frame: Extract<PaneStreamServerFrame, { type: "layout" }>) => void;
+  /** Kitty graphics state; only sent when the offer carried the graphics capability. */
+  readonly onTerminalGraphics?: (pane: string, state: TerminalGraphicsState) => void;
+  /** One chunk of requested image bytes (`blob.offset` into `blob.total`). */
+  readonly onTerminalGraphicsBlob?: (
+    pane: string,
+    blob: TerminalGraphicsBlob,
+    bytes: Uint8Array,
+  ) => void;
   readonly onLayoutSnapshot?: (
     frame: Extract<PaneStreamServerFrame, { type: "layout-snapshot" }>,
   ) => void;
@@ -313,6 +324,8 @@ export type ConnectIssuedPaneStreamRuntimeClientOptions = Pick<
   | "onClockCalibrationOutcome"
   | "diagnosticNextTurn"
   | "onLayout"
+  | "onTerminalGraphics"
+  | "onTerminalGraphicsBlob"
   | "onLayoutSnapshot"
   | "onInputAck"
   | "onCausalCellProof"
@@ -369,6 +382,14 @@ export interface PaneStreamRuntimeClient {
     operationId: string,
     intent: SessionRuntimeSemanticIntent,
   ): Promise<WorkspaceMultiplexerMutationResult | null>;
+  /** Pull image bytes announced in graphics state; the daemon sends each once per request. */
+  requestTerminalGraphics(pane: string, digests: readonly string[]): void;
+  /** Renderer cell size in device pixels; only after state carried `cellPixels`. */
+  setTerminalCellPixels(
+    width: number,
+    height: number,
+    precise?: { width: number; height: number },
+  ): void;
   close(): void;
 }
 
@@ -1590,6 +1611,16 @@ export async function connectIssuedPaneStreamRuntimeClient(
     nack: (nack) => send({ type: "terminal-delivery-nack", nack }),
     setVisibility: (address, visibility) =>
       send({ type: "terminal-delivery-visibility", ...address, visibility }),
+    setTerminalCellPixels: (width, height, precise) =>
+      send({ type: "terminal-cell-pixels", width, height, ...(precise ? { precise } : {}) }),
+    requestTerminalGraphics: (pane, digests) => {
+      for (let start = 0; start < digests.length; start += TERMINAL_GRAPHICS_MAX_REQUEST_DIGESTS)
+        send({
+          type: "terminal-graphics-request",
+          pane,
+          digests: digests.slice(start, start + TERMINAL_GRAPHICS_MAX_REQUEST_DIGESTS),
+        });
+    },
     submitIntent: (operationId, intent) =>
       new Promise<WorkspaceMultiplexerMutationResult | null>((resolve, reject) => {
         const timer = createRuntimeTimer(() => {
@@ -1651,6 +1682,12 @@ function routeFrame(
     case "layout":
       options.onLayout?.(frame);
       return;
+    case "terminal-graphics":
+      options.onTerminalGraphics?.(frame.pane, frame.state);
+      return;
+    case "terminal-graphics-blob":
+      options.onTerminalGraphicsBlob?.(frame.pane, frame.blob, decodeBase64(frame.data));
+      return;
     case "layout-snapshot":
       options.onLayoutSnapshot?.(frame);
       return;

package/packages/daemon-client/src/tmux-server-client.ts

@@ -1,4 +1,9 @@
+import { readPaneCreationRefusal } from "./pane-creation-refusal.ts";
 import {
+  HistoryAnchorRequestSchemaZ,
+  HistoryAnchorResponseSchemaZ,
+  type HistoryAnchorRequest,
+  TmuxServerDiagnosticsSchemaZ,
   TmuxAgentOpenRequestSchemaZ,
   TmuxAgentOpenResponseSchemaZ,
   type TmuxAgentOpenRequest,
@@ -49,6 +54,7 @@ export class TmuxServerClientError extends Error {
   constructor(
     readonly code: "disposed" | "scope-mismatch" | "request-failed",
     readonly status?: number,
+    readonly refusalCode?: "harness_unavailable",
   ) {
     super(`tmux server client ${code}`);
     this.name = "TmuxServerClientError";
@@ -61,7 +67,12 @@ async function request(
   headers?: Record<string, string>,
   method?: "DELETE",
   signal?: AbortSignal,
+  responseLimit?: number,
+  paneCreationRefusal = false,
 ) {
+  const requestSignal = signal
+    ? AbortSignal.any([signal, AbortSignal.timeout(options.timeoutMs ?? 5_000)])
+    : AbortSignal.timeout(options.timeoutMs ?? 5_000);
   const response = await (options.fetch ?? fetch)(new URL(path, options.baseUrl), {
     method: method ?? (body === undefined ? "GET" : "POST"),
     headers: {
@@ -72,13 +83,45 @@ async function request(
     ...(body === undefined ? {} : { body: JSON.stringify(body) }),
     redirect: "error",
     cache: "no-store",
-    signal: signal
-      ? AbortSignal.any([signal, AbortSignal.timeout(options.timeoutMs ?? 5_000)])
-      : AbortSignal.timeout(options.timeoutMs ?? 5_000),
+    signal: requestSignal,
   });
-  if (!response.ok) throw new TmuxServerClientError("request-failed", response.status);
-  const result: unknown = await response.json();
-  signal?.throwIfAborted();
+  if (!response.ok)
+    throw new TmuxServerClientError(
+      "request-failed",
+      response.status,
+      paneCreationRefusal ? await readPaneCreationRefusal(response, requestSignal) : undefined,
+    );
+  let result: unknown;
+  if (responseLimit === undefined) result = await response.json();
+  else {
+    const reader = response.body?.getReader();
+    if (!reader) throw new TmuxServerClientError("request-failed");
+    const chunks: Uint8Array[] = [];
+    let length = 0;
+    try {
+      for (;;) {
+        requestSignal.throwIfAborted();
+        const item = await reader.read();
+        if (item.done) break;
+        length += item.value.byteLength;
+        if (length > responseLimit) {
+          void reader.cancel().catch(() => undefined);
+          throw new TmuxServerClientError("request-failed");
+        }
+        chunks.push(item.value);
+      }
+      const bytes = new Uint8Array(length);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      result = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  requestSignal.throwIfAborted();
   return result;
 }
 export async function listTmuxServers(options: TmuxServerClientOptions) {
@@ -140,6 +183,7 @@ export function createTmuxServerClient(
     headers?: Record<string, string>,
     signal?: AbortSignal,
     defaultTimeoutMs?: number,
+    paneCreationRefusal = false,
   ) {
     assertCurrent();
     const result = await request(
@@ -151,6 +195,8 @@ export function createTmuxServerClient(
       headers,
       undefined,
       signal,
+      undefined,
+      paneCreationRefusal,
     );
     assertCurrent();
     return result;
@@ -352,6 +398,10 @@ export function createTmuxServerClient(
         await scopedRequest(
           `panes/create?liveSessionId=${encodeURIComponent(liveSessionId)}`,
           body,
+          undefined,
+          undefined,
+          undefined,
+          true,
         ),
       );
       if (
@@ -426,3 +476,80 @@ export function createTmuxServerClient(
   };
 }
 export type TmuxServerClient = ReturnType<typeof createTmuxServerClient>;
+
+/** Optional metadata; old servers have no route. Callers own selected-scope currentness. */
+export async function readTmuxServerDiagnostics(
+  options: TmuxServerClientOptions,
+  scopeInput: TmuxServerScope,
+  signal?: AbortSignal,
+) {
+  const scope = TmuxServerScopeSchemaZ.parse(scopeInput);
+  signal?.throwIfAborted();
+  try {
+    const result = TmuxServerDiagnosticsSchemaZ.parse(
+      await request(
+        options,
+        `${TMUX_SERVERS_API_PATH}/${scope.serverId}/${scope.generation}/diagnostics`,
+        undefined,
+        undefined,
+        undefined,
+        signal,
+        4096,
+      ),
+    );
+    if (result.server.serverId !== scope.serverId || result.server.generation !== scope.generation)
+      throw new TmuxServerClientError("scope-mismatch");
+    return result;
+  } catch (error) {
+    signal?.throwIfAborted();
+    if (error instanceof TmuxServerClientError && error.status === 404) return null;
+    throw error;
+  }
+}
+
+/** Optional old-daemon endpoint. Never retries, creates sessions, or admits input. */
+export async function requestHistoryAnchor(
+  options: TmuxServerClientOptions,
+  scopeInput: TmuxServerScope,
+  input: HistoryAnchorRequest,
+  signal?: AbortSignal,
+) {
+  const scope = TmuxServerScopeSchemaZ.parse(scopeInput),
+    body = HistoryAnchorRequestSchemaZ.parse(input);
+  if (body.proof.generation !== scope.generation) throw new TmuxServerClientError("scope-mismatch");
+  signal?.throwIfAborted();
+  try {
+    const value = HistoryAnchorResponseSchemaZ.parse(
+      await request(
+        options,
+        `${TMUX_SERVERS_API_PATH}/${scope.serverId}/${scope.generation}/history-anchor`,
+        body,
+        undefined,
+        undefined,
+        signal,
+        4096,
+      ),
+    );
+    if (value.server.serverId !== scope.serverId || value.server.generation !== scope.generation)
+      throw new TmuxServerClientError("scope-mismatch");
+    if (
+      value.result.status === "resolved" &&
+      Object.entries(body.proof).some(
+        ([key, v]) =>
+          value.result.status === "resolved" &&
+          value.result.proof[key as keyof typeof body.proof] !== v,
+      )
+    )
+      throw new TmuxServerClientError("scope-mismatch");
+    if (
+      (body.operation.kind === "capture" && value.result.status === "resolved") ||
+      (body.operation.kind === "resolve" && value.result.status === "captured")
+    )
+      throw new TmuxServerClientError("scope-mismatch");
+    return value;
+  } catch (error) {
+    signal?.throwIfAborted();
+    if (error instanceof TmuxServerClientError && error.status === 404) return null;
+    throw error;
+  }
+}