tmux-ide 2.9.2 → 2.9.3

package/packages/daemon/src/tui/mirror/runtime/bounded-performance-record-writer.ts

@@ -6,21 +6,26 @@ export interface PerformanceRecordSink {
 export class BoundedPerformanceRecordWriter {
   readonly #sink: PerformanceRecordSink;
   readonly #criticalLimit: number;
-  readonly #pendingCritical = new Map<string, string>();
+  readonly #pendingCritical = new Set<string>();
+  readonly #pending: { record: string; bytes: number; key?: string }[] = [];
+  readonly #pendingByteLimit: number;
+  #pendingBytes = 0;
+  #flushPromise: Promise<void> | null = null;
+  #resolveFlush: (() => void) | null = null;
   #saturated = false;
   #failed = false;
   #droppedRecords = 0;
 
-  constructor(sink: PerformanceRecordSink, criticalLimit = 16) {
+  constructor(sink: PerformanceRecordSink, criticalLimit = 16, pendingByteLimit = 64 * 1024) {
     this.#sink = sink;
     this.#criticalLimit = criticalLimit;
+    this.#pendingByteLimit = pendingByteLimit;
   }
 
   write(record: string): boolean {
     if (this.#failed) return false;
     if (this.#saturated) {
-      this.#droppedRecords += 1;
-      return false;
+      return this.#enqueue(record);
     }
     return this.#writeAccepted(record);
   }
@@ -33,22 +38,57 @@ export class BoundedPerformanceRecordWriter {
       this.#droppedRecords += 1;
       return false;
     }
-    this.#pendingCritical.set(key, record);
-    return true;
+    return this.#enqueue(record, key);
   }
 
   drain(): void {
     if (this.#failed) return;
     this.#saturated = false;
-    for (const [key, record] of this.#pendingCritical) {
-      this.#pendingCritical.delete(key);
-      if (!this.#writeAccepted(record)) break;
+    while (this.#pending.length > 0 && !this.#saturated && !this.#failed) {
+      const next = this.#pending.shift()!;
+      this.#pendingBytes -= next.bytes;
+      if (next.key !== undefined) this.#pendingCritical.delete(next.key);
+      this.#writeAccepted(next.record);
     }
+    if (this.#pending.length === 0) this.#finishFlush();
+  }
+
+  /** Wait until retained records reach the stream; its owner then flushes/end()s it. */
+  flush(): Promise<void> {
+    if (this.#failed || this.#pending.length === 0) return Promise.resolve();
+    this.#flushPromise ??= new Promise((resolve) => {
+      this.#resolveFlush = resolve;
+    });
+    return this.#flushPromise;
   }
 
   fail(): void {
     this.#failed = true;
     this.#pendingCritical.clear();
+    this.#pending.length = 0;
+    this.#pendingBytes = 0;
+    this.#finishFlush();
+  }
+
+  #enqueue(record: string, key?: string): boolean {
+    const bytes = Buffer.byteLength(record);
+    // Ordinary bursts get one extra stream-sized buffer. Critical records have
+    // a separate byte reserve as well as their existing key-count limit.
+    const limit = this.#pendingByteLimit + (key === undefined ? 0 : 64 * 1024);
+    if (this.#pending.length >= 1024 || this.#pendingBytes + bytes > limit) {
+      this.#droppedRecords += 1;
+      return false;
+    }
+    if (key !== undefined) this.#pendingCritical.add(key);
+    this.#pending.push({ record, bytes, ...(key === undefined ? {} : { key }) });
+    this.#pendingBytes += bytes;
+    return true;
+  }
+
+  #finishFlush(): void {
+    this.#resolveFlush?.();
+    this.#resolveFlush = null;
+    this.#flushPromise = null;
   }
 
   diagnostics(): Readonly<{

package/packages/daemon/src/tui/mirror/runtime/terminal-fast-lane-renderer-adapter.ts

@@ -400,11 +400,12 @@ export class TerminalFastLaneRendererAdapter implements PaneScopedTerminalAdapte
         identity.acceptedRevision,
       ]);
       if (seen.has(key)) continue;
-      if (seen.size >= 256) this.#droppedCanonicalHostFrames += 1;
-      else {
-        seen.add(key);
-        identities.push(identity);
-      }
+      // Bound retained de-duplication history, not the renderer's lifetime.
+      // An evicted identity may be reported again only after another real paint.
+      // Pending identities still have their separate per-frame admission limit.
+      if (seen.size >= 256) seen.delete(seen.values().next().value!);
+      seen.add(key);
+      identities.push(identity);
     }
     const dropped = this.#droppedCanonicalHostFrames;
     this.#droppedCanonicalHostFrames = 0;

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

@@ -27,6 +27,10 @@ export class TerminalPaneInputRouter<Input> {
     this.#options = options;
   }
 
+  get selectionVersion(): number {
+    return this.#selectionToken;
+  }
+
   get focusedPane(): string | null {
     return this.#focusedPane;
   }

package/packages/daemon/src/tui/mirror/runtime/workspace-terminal-fast-lane.ts

@@ -28,6 +28,8 @@ export interface OpenTuiTerminalResourceSampler {
   dispose(): void;
 }
 
+// Limit outstanding low-water sampling chains, not completed observations over
+// the lifetime of a renderer. Each chain owns at most one pending timeout.
 const TERMINAL_RESOURCE_SAMPLE_LIMIT = 512;
 // The ProductRig idle proof reads after 10.1s. Emit just before that boundary
 // so the operation-scoped sample cannot race the proof read.
@@ -315,8 +317,7 @@ function createOpenTuiTerminalResourceSampler(
       }[];
     }>,
   ) => {
-    if (disposed || resourceEpochIdentity === null || ordinal >= TERMINAL_RESOURCE_SAMPLE_LIMIT)
-      return;
+    if (disposed || resourceEpochIdentity === null) return;
     ordinal += 1;
     const now = readDiagnosticNow();
     if (now === null) return;
@@ -474,7 +475,11 @@ function createOpenTuiTerminalResourceSampler(
   };
   return {
     afterFence(identity) {
-      if (disposed || ordinal >= TERMINAL_RESOURCE_SAMPLE_LIMIT) return;
+      if (disposed) return;
+      if (pending.size >= TERMINAL_RESOURCE_SAMPLE_LIMIT) {
+        recordSamplingFailure();
+        return;
+      }
       latestIdentity = identity;
       let now: number | null;
       if (resourceEpochIdentity === null) {

package/packages/daemon/src/tui/mirror/terminal-text.ts

@@ -52,3 +52,35 @@ function graphemes(text: string): string[] {
     );
   return [...text];
 }
+
+/** PURE — greedy word-wrap for terminal prose (never returns empty for
+ *  non-empty text; words longer than the width hard-break). */
+export function wrapText(text: string, width: number): string[] {
+  if (width <= 0) return [text];
+  const out: string[] = [];
+  for (const para of text.split("\n")) {
+    let line = "";
+    for (const word of para.split(/\s+/).filter(Boolean)) {
+      if (line.length === 0) {
+        let w = word;
+        while (w.length > width) {
+          out.push(w.slice(0, width));
+          w = w.slice(width);
+        }
+        line = w;
+      } else if (line.length + 1 + word.length <= width) {
+        line += ` ${word}`;
+      } else {
+        out.push(line);
+        let w = word;
+        while (w.length > width) {
+          out.push(w.slice(0, width));
+          w = w.slice(width);
+        }
+        line = w;
+      }
+    }
+    if (line.length > 0 || para.length === 0) out.push(line);
+  }
+  return out.length > 0 ? out : [""];
+}

package/packages/daemon/src/tui/mirror/workspace/connection-feedback.ts

@@ -167,9 +167,12 @@ export function createApplicationConnectionFeedback(
           failure,
           ...(inventory
             ? {
-                recovery: missing
-                  ? "A registered session may have been recreated. Choose that session to restore its identity, then retry here. It may be a different session."
-                  : "Terminal identities conflict or cannot be verified. Copy connection details for diagnosis; Retry does not repair identity conflicts.",
+                recovery:
+                  failure.reason === "duplicate-runtime-pane-binding"
+                    ? "A terminal is shared by multiple workspace entries. Unlink shared tmux windows so each belongs to one session, then select Retry."
+                    : missing
+                      ? "A registered session may have been recreated. Choose that session to restore its identity, then retry here. It may be a different session."
+                      : "Terminal identities conflict or cannot be verified. Copy connection details for diagnosis; Retry does not repair identity conflicts.",
               }
             : {}),
         };

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

@@ -5,6 +5,9 @@ export type FleetConnectionFailureCode =
   | "invalid-target"
   | "invalid-descriptor"
   | "incompatible"
+  | "ssh-authentication"
+  | "ssh-host-key"
+  | "remote-cli-missing"
   | "daemon-missing";
 
 export interface FleetConnectionStatus {
@@ -26,7 +29,13 @@ export function fleetConnectionMessage(status: FleetConnectionStatus): string {
     case "invalid-descriptor":
       return "Remote daemon discovery returned an invalid response. Check the installation.";
     case "daemon-missing":
-      return "No running daemon. Start tmux-ide on this machine, then retry.";
+      return "No running daemon. Retrying automatically; start tmux-ide on this machine if needed.";
+    case "ssh-authentication":
+      return "SSH authentication failed. Check the machine's SSH credentials, then retry.";
+    case "ssh-host-key":
+      return "SSH host key verification failed. Verify the host in your terminal, then retry.";
+    case "remote-cli-missing":
+      return "Remote tmux-ide command not found. Check its installation and non-interactive SSH PATH.";
     case "unavailable":
       return "Connection failed. Check reachability, SSH authentication and host trust.";
     default:

package/packages/daemon-client/src/workspace-client.ts

@@ -1257,7 +1257,10 @@ export function createWorkspaceClient<
       startApplicationShell();
       if (authorityShell !== null) {
         if (!shellMatchesTerminalAuthority(authorityShell, resource))
-          requestTerminalMismatchRefresh(authorityShell, resource);
+          // A newer terminal revision has already established topology. Read
+          // its presentation/refusal details instead of refreshing that same
+          // terminal revision again while leaving the shell stale.
+          shellSession?.refresh();
       }
       return true;
     },

package/packages/contracts/src/__tests__/actions-contract.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ActionContractsZ } from "../actions-contract.ts";
-
-describe("daemon action contract", () => {
-  it("supports generation-pinned cooperative shutdown", () => {
-    const instanceId = "9bcf33b0-c837-4a94-b5e8-c0977f54464f";
-
-    expect(
-      ActionContractsZ["daemon.shutdown"].input.parse({
-        reason: "takeover",
-        expectedInstanceId: instanceId,
-      }),
-    ).toEqual({ reason: "takeover", expectedInstanceId: instanceId });
-    expect(
-      ActionContractsZ["daemon.shutdown"].input.safeParse({
-        expectedInstanceId: "not-a-uuid",
-      }).success,
-    ).toBe(false);
-  });
-
-  it("accepts only renderer-safe semantic workspace pane creation", () => {
-    const input = { kind: "terminal", workspaceName: "workspace.alpha" } as const;
-    expect(ActionContractsZ["workspace.pane.create"].input.parse(input)).toEqual(input);
-    for (const [field, value] of [
-      ["cwd", "/tmp/project"],
-      ["argv", ["sh", "-c", "owned"]],
-      ["env", { SECRET: "renderer" }],
-      ["paneId", "%42"],
-      ["sessionName", "runtime-session"],
-    ] as const) {
-      expect(
-        ActionContractsZ["workspace.pane.create"].input.safeParse({
-          ...input,
-          [field]: value,
-        }).success,
-      ).toBe(false);
-    }
-  });
-
-  it("renames panes through semantic identity only", () => {
-    const input = {
-      workspaceName: "workspace.alpha",
-      scope: "pane",
-      semanticPaneId: "pane.main",
-      name: "Build monitor",
-    } as const;
-    expect(ActionContractsZ["workspace.rename"].input.parse(input)).toEqual(input);
-    expect(
-      ActionContractsZ["workspace.rename"].input.safeParse({
-        ...input,
-        semanticPaneId: "%42",
-      }).success,
-    ).toBe(false);
-  });
-
-  it("keeps config-free workspace admission semantic and its result browser-safe", () => {
-    expect(ActionContractsZ["workspace.open"].input.parse({ projectDir: "/tmp/project" })).toEqual({
-      projectDir: "/tmp/project",
-    });
-    for (const [field, value] of [
-      ["sessionName", "renderer-session"],
-      ["paneId", "%42"],
-      ["command", ["sh", "-c", "owned"]],
-      ["env", { SECRET: "renderer" }],
-    ] as const) {
-      expect(
-        ActionContractsZ["workspace.open"].input.safeParse({
-          projectDir: "/tmp/project",
-          [field]: value,
-        }).success,
-      ).toBe(false);
-    }
-
-    const result = ActionContractsZ["workspace.open"].result.parse({
-      operationId: "10000000-0000-4000-8000-000000000001",
-      daemonInstanceId: "20000000-0000-4000-8000-000000000002",
-      outcome: "created",
-      resource: {
-        resourceVersion: 1,
-        workspaceName: "project-00112233445566778899aabbccddeeff",
-        initialPaneId: "pane.workspace.00112233445566778899aabbccddeeff",
-      },
-    });
-    expect(JSON.stringify(result)).not.toMatch(/projectDir|sessionName|runtime|tmux|path/u);
-  });
-
-  it("lets the trusted desktop host select a folder without exposing its path", () => {
-    const input = {
-      source: { kind: "host-selection" },
-      previousWorkspaceName: "workspace.alpha",
-    } as const;
-    expect(ActionContractsZ["workspace.open.prepare"].input.parse(input)).toEqual(input);
-    expect(
-      ActionContractsZ["workspace.open.prepare"].input.safeParse({
-        ...input,
-        source: { kind: "host-selection", projectDir: "/private/project" },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("accepts only semantic pane identities for a swap", () => {
-    const input = {
-      workspaceName: "workspace.alpha",
-      sourceSemanticPaneId: "pane.source",
-      targetSemanticPaneId: "pane.target",
-    } as const;
-    expect(ActionContractsZ["workspace.pane.swap"].input.parse(input)).toEqual(input);
-    for (const unsafe of [
-      { sourcePaneId: "%1" },
-      { targetPaneId: "%2" },
-      { tmuxCommand: "swap-pane -D" },
-      { sessionName: "runtime-session" },
-    ]) {
-      expect(
-        ActionContractsZ["workspace.pane.swap"].input.safeParse({ ...input, ...unsafe }).success,
-      ).toBe(false);
-    }
-  });
-});