tmux-ide 2.9.6 → 2.9.8

package/packages/daemon/src/command-center/tmux-servers.ts

@@ -1,3 +1,5 @@
+import { mountTmuxServerHistoryAnchorRoute } from "./tmux-server-history-anchor.ts";
+import { mountTmuxServerDiagnosticsRoute } from "./tmux-server-diagnostics.ts";
 import { WindowSplitLayoutUnavailable } from "../terminal/mirror/window-split-authority.ts";
 import { streamTmuxInteractions } from "./tmux-server-interaction-events.ts";
 import { mountTmuxServerNativeBackingRoute } from "./tmux-server-native-backing.ts";
@@ -30,6 +32,7 @@ import {
 } from "../lib/tmux-server-owners.ts";
 import type { NativeTmuxServerOwner } from "../lib/tmux-server-owner.ts";
 import { WorkspaceMultiplexerError } from "../lib/workspace-multiplexer-verbs.ts";
+import { WorkspacePaneCreationError } from "../lib/workspace-pane-creation.ts";
 import { ownerBearerMatches } from "./owner-authority.ts";
 import { mountPaneStreamIssueRoute } from "./pane-stream-issue.ts";
 import { projectTerminalRuntimeInventory } from "./resources/terminal-runtime-inventory.ts";
@@ -79,6 +82,8 @@ function failure(c: Context, error: unknown): Response {
       { error: { code: error.code } },
       error.code === "not-found" ? 404 : error.code === "capacity" ? 429 : 409,
     );
+  if (error instanceof WorkspacePaneCreationError && error.code === "harness_unavailable")
+    return c.json({ error: { code: "harness_unavailable" } }, 409);
   if (error instanceof WorkspaceMultiplexerError)
     return c.json({ error: { code: error.code } }, 409);
   if (error instanceof z.ZodError || error instanceof SyntaxError || error instanceof TypeError)
@@ -133,6 +138,12 @@ export function mountTmuxServerRoutes(app: Hono, options: TmuxServerRoutesOption
     }),
   );
   const scoped = `${base}/:serverId/:generation`;
+  mountTmuxServerHistoryAnchorRoute(app, {
+    scopedPath: scoped,
+    owners: options.owners,
+    readBody: (request) => boundedJson(request, 4096),
+  });
+  mountTmuxServerDiagnosticsRoute(app, { scopedPath: scoped, owners: options.owners });
   mountTmuxServerEditorContextRoute(app, {
     scopedPath: scoped,
     owners: options.owners,

package/packages/daemon/src/lib/canonical-daemon-bootstrap.ts

@@ -100,6 +100,12 @@ function spawnOwner(entryPath: string, cwd: string): Promise<void> {
   });
 }
 
+class ShutdownTransportError extends Error {
+  constructor(readonly original: unknown) {
+    super("Canonical daemon shutdown transport failed.", { cause: original });
+  }
+}
+
 async function shutdownOlderOwner(info: CanonicalDaemonInfo): Promise<void> {
   const headers: Record<string, string> = { "content-type": "application/json" };
   if (info.authToken) headers.authorization = `Bearer ${info.authToken}`;
@@ -115,7 +121,9 @@ async function shutdownOlderOwner(info: CanonicalDaemonInfo): Promise<void> {
       }),
       signal: AbortSignal.timeout(2_000),
     },
-  );
+  ).catch((error: unknown) => {
+    throw new ShutdownTransportError(error);
+  });
   const envelope = (await response.json().catch(() => null)) as {
     ok?: unknown;
     result?: { stopping?: unknown };
@@ -248,7 +256,16 @@ async function replaceOlderCanonicalDaemon(
       { reason: "canonical-record-invalid" },
     );
   }
-  await deps.shutdownOlderOwner(info);
+  let transportFailure: ShutdownTransportError | undefined;
+  try {
+    await deps.shutdownOlderOwner(info);
+  } catch (error) {
+    if (!(error instanceof ShutdownTransportError)) throw error;
+    transportFailure = error;
+  }
+  // A competing upgrader may close the authenticated owner's listener before
+  // removing its record. Observe retirement, without repeating the mutation.
+  // A transport failure alone never authorizes starting a replacement.
   const deadline = deps.now() + timeoutMs;
   while (deps.now() < deadline) {
     const state = deps.inspect();
@@ -257,6 +274,7 @@ async function replaceOlderCanonicalDaemon(
     if (!(await deps.alive(info))) return;
     await deps.sleep(25);
   }
+  if (transportFailure) throw transportFailure.original;
   throw new DaemonBootstrapError(
     "control-timeout",
     "The older canonical daemon did not retire after accepting the version upgrade.",

package/packages/daemon/src/lib/daemon-embed.ts

@@ -1,3 +1,4 @@
+import { TmuxServerVersionSchemaZ } from "@tmux-ide/contracts";
 import {
   createNativeSplitCapabilityProbe,
   createNativeSplitReadiness,
@@ -1400,6 +1401,7 @@ async function startEmbeddedDaemonGeneration(
     let paneStreamRuntime: PaneStreamRuntime | null = null;
     let serverOwners: Awaited<ReturnType<typeof createEmbeddedTmuxServerOwners>> | null = null;
     let defaultEditorContextRetired = false;
+    const defaultDiagnosticsLifetime = new AbortController();
     const defaultSessionCreator = createNativeTmuxSessionCreator({
       generation: instanceId,
       registry: workspaceRegistry,
@@ -1805,6 +1807,29 @@ async function startEmbeddedDaemonGeneration(
         stateDirectory: resolveRuntimeNamespace().runtimeDir,
         webSocketBaseUrl: canonicalDaemonUrl("ws", bindHostname, port),
         defaultOwner: {
+          readServerVersion: async (signal?: AbortSignal) => {
+            const assertCurrent = () => {
+              if (
+                defaultEditorContextRetired ||
+                serverOwners?.defaultRetired ||
+                !initialNativeServerIdentity
+              )
+                throw new Error("Default tmux diagnostics owner is unavailable");
+            };
+            assertCurrent();
+            const combined = AbortSignal.any([
+              defaultDiagnosticsLifetime.signal,
+              ...(signal ? [signal] : []),
+            ]);
+            combined.throwIfAborted();
+            const output = await fleetFactsTmuxRunner(
+              ["display-message", "-p", "#{version}"],
+              combined,
+            );
+            combined.throwIfAborted();
+            assertCurrent();
+            return TmuxServerVersionSchemaZ.parse(output.trim());
+          },
           get interactionObservation() {
             return interactionObservation;
           },
@@ -1913,6 +1938,7 @@ async function startEmbeddedDaemonGeneration(
           paneStreamRuntime,
           dispose: async () => {
             defaultEditorContextRetired = true;
+            defaultDiagnosticsLifetime.abort();
             sessionMonitor?.stop();
             paneSourceCredentials.dispose();
             const transportResults = await Promise.allSettled([

package/packages/daemon/src/lib/tmux-server-owner.ts

@@ -30,6 +30,7 @@ import { observedAgentSchema } from "./tmux-server-agent-admission.ts";
 import { createPaneEditorContextResolver } from "./tmux-pane-editor-context.ts";
 import { createHash, randomUUID } from "node:crypto";
 import {
+  TmuxServerVersionSchemaZ,
   WorkspaceIdSchemaZ,
   WindowLinkTargetSchemaZ,
   type WindowLinkTarget,
@@ -594,6 +595,15 @@ export async function createNativeTmuxServerOwner(options: NativeTmuxServerOwner
     throw error;
   }
   return {
+    readServerVersion: async (signal?: AbortSignal) => {
+      assertOpen();
+      const combined = AbortSignal.any([credentialLifetime.signal, ...(signal ? [signal] : [])]);
+      combined.throwIfAborted();
+      const output = await generationRunAsync(["display-message", "-p", "#{version}"], combined);
+      combined.throwIfAborted();
+      assertOpen();
+      return TmuxServerVersionSchemaZ.parse(output.trim());
+    },
     serverId: options.serverId,
     generation,
     resolvePaneEditorContext,

package/packages/daemon/src/lib/tmux-session-mutation-fence.ts

@@ -23,7 +23,8 @@ export function createTmuxSessionMutationFence() {
         const output = run([
           "if-shell",
           "-t",
-          `=${selected.name}`,
+          // if-shell resolves a pane target: the colon selects this exact session.
+          `=${selected.name}:`,
           "-F",
           `#{&&:#{==:#{session_id},${selected.id}},#{==:#{session_created},${selected.created}}}`,
           args.map((arg) => (arg === ";" ? ";" : shellEscape(arg))).join(" "),

package/packages/daemon/src/terminal/attachments/native-runtime.ts

@@ -918,6 +918,11 @@ function parsePaneSnapshot(
  * application-shell inventory. Names are resolved exactly to `$session_id`
  * before any pane query, and a second identity/topology snapshot closes races.
  */
+const INVENTORY_FENCE_ATTEMPTS = 4;
+/** 25, 50, 100 ms: enough for a mutation's identity stamps, bounded for every reader. */
+const settleDelay = (attempt: number) =>
+  new Promise<void>((resolve) => setTimeout(resolve, 25 * 2 ** (attempt - 1)));
+
 export async function discoverWorkspaceRegistryTerminalInventory(
   registry: WorkspaceRegistry,
   runner: NativeTerminalInventoryReadRunner,
@@ -941,12 +946,6 @@ export async function discoverWorkspaceRegistryTerminalInventory(
     const argv = ["list-panes", "-s", "-t", identity.id, "-F", PANE_FORMAT] as const;
     const before = await requiredTmuxResult(runner, argv, signal);
     if (before === null) continue;
-    const first = parsePaneSnapshot(before, identity);
-    const panes = first.panes;
-    const after = await requiredTmuxResult(runner, argv, signal);
-    if (after === null) throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
-    const second = parsePaneSnapshot(after, identity);
-    const latest = second.panes;
     // Foreground commands, titles, focus and paths can change while the same
     // pane remains valid. Fence binding/topology only, then publish one complete
     // latest snapshot rather than mixing presentation values across reads.
@@ -961,14 +960,30 @@ export async function discoverWorkspaceRegistryTerminalInventory(
       "windowStamp",
       "index",
     ] as const;
-    if (
-      first.linksProof !== second.linksProof ||
-      panes.length !== latest.length ||
-      panes.some((pane, index) => proofKeys.some((key) => pane[key] !== latest[index]![key]))
-    ) {
-      throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+    const matches = (
+      first: ReturnType<typeof parsePaneSnapshot>,
+      second: ReturnType<typeof parsePaneSnapshot>,
+    ) =>
+      first.linksProof === second.linksProof &&
+      first.panes.length === second.panes.length &&
+      first.panes.every((pane, index) =>
+        proofKeys.every((key) => pane[key] === second.panes[index]![key]),
+      );
+    // A just-created window or split is still being stamped, so topology can
+    // move between two reads. Let it settle for a bounded number of re-reads;
+    // only two consecutive matching reads are ever published.
+    let previous = parsePaneSnapshot(before, identity);
+    let stable: ReturnType<typeof parsePaneSnapshot> | null = null;
+    for (let attempt = 0; attempt < INVENTORY_FENCE_ATTEMPTS && !stable; attempt += 1) {
+      if (attempt > 0) await settleDelay(attempt);
+      const after = await requiredTmuxResult(runner, argv, signal);
+      if (after === null) throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+      const next = parsePaneSnapshot(after, identity);
+      if (matches(previous, next)) stable = next;
+      else previous = next;
     }
-    bySessionName.set(sessionName, latest);
+    if (!stable) throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+    bySessionName.set(sessionName, stable.panes);
   }
 
   const panes: NativeTerminalInventoryPaneSnapshot[] = [];