tmux-ide 2.9.4 → 2.9.5

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

@@ -45,6 +45,7 @@ import { startOwnedEmbeddedDaemon } from "./embedded-daemon-lifecycle.ts";
 import { execFileSync } from "node:child_process";
 import { randomBytes, randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
+import { createRuntimeTraceWriter } from "./runtime-trace-writer.ts";
 import { createServer, type Server } from "node:http";
 import { createRequire } from "node:module";
 import type { Socket } from "node:net";
@@ -1404,14 +1405,11 @@ async function startEmbeddedDaemonGeneration(
         if (serverOwners?.defaultRetired) throw new Error("Default tmux owner is retired");
       },
     });
-    let runtimeTraceStream: ReturnType<typeof createWriteStream> | null = null;
-    const closeRuntimeTraceStream = async (): Promise<void> => {
+    let runtimeTraceWriter: ReturnType<typeof createRuntimeTraceWriter> | null = null;
+    const closeRuntimeTraceStream = async (incomplete = false): Promise<void> => {
       externalInteractionObserver.setDiagnostics(null);
       setFleetFactsObserverDiagnostics(null);
-      const stream = runtimeTraceStream;
-      runtimeTraceStream = null;
-      if (!stream || stream.closed || stream.destroyed) return;
-      await new Promise<void>((resolve) => stream.end(resolve));
+      await runtimeTraceWriter?.close(incomplete);
     };
     let startedServer: Awaited<ReturnType<typeof startHttpServer>>;
     try {
@@ -1455,16 +1453,12 @@ async function startEmbeddedDaemonGeneration(
         );
       };
       const runtimeTracePath = process.env.TMUX_IDE_SESSION_RUNTIME_TRACE_LOG;
-      runtimeTraceStream = runtimeTracePath
-        ? createWriteStream(runtimeTracePath, { flags: "a", highWaterMark: 64 * 1_024 })
+      runtimeTraceWriter = runtimeTracePath
+        ? createRuntimeTraceWriter(
+            createWriteStream(runtimeTracePath, { flags: "a", highWaterMark: 64 * 1024 }),
+            { processId: `daemon:${process.pid}`, daemonInstanceId: instanceId },
+          )
         : null;
-      let runtimeTraceSaturated = false;
-      runtimeTraceStream?.on("error", () => {
-        runtimeTraceSaturated = true;
-      });
-      runtimeTraceStream?.on("drain", () => {
-        runtimeTraceSaturated = false;
-      });
       const runtimeObservability = runtimeTracePath
         ? createSessionRuntimeObservability({
             // The JSONL stream is the qualifying record. Keep only a small
@@ -1473,28 +1467,22 @@ async function startEmbeddedDaemonGeneration(
             // pauses on the daemon's input/output event loop.
             capacity: 1_024,
             onSpan: (span) => {
-              if (!runtimeTraceStream || runtimeTraceSaturated) return;
-              runtimeTraceSaturated = !runtimeTraceStream.write(
-                `${JSON.stringify({ version: 1, type: "performance.stage", ...span })}\n`,
-              );
+              runtimeTraceWriter?.append(() => ({
+                version: 1,
+                type: "performance.stage",
+                ...span,
+              }));
             },
           })
         : undefined;
       if (runtimeTracePath) {
         const publishObserverDiagnostic = (event: object): void => {
-          try {
-            if (!runtimeTraceStream || runtimeTraceSaturated) return;
-            runtimeTraceSaturated = !runtimeTraceStream.write(
-              `${JSON.stringify({
-                version: 1,
-                type: "performance.daemon-observer",
-                ...event,
-                generation: instanceId,
-              })}\n`,
-            );
-          } catch {
-            // Qualification diagnostics never alter daemon observation.
-          }
+          runtimeTraceWriter?.append(() => ({
+            version: 1,
+            type: "performance.daemon-observer",
+            ...event,
+            generation: instanceId,
+          }));
         };
         const diagnostics = {
           nowMicros: () => Math.floor(performance.now() * 1_000),
@@ -1975,7 +1963,7 @@ async function startEmbeddedDaemonGeneration(
         appWindowMutation.dispose(),
         workspaceMultiplexer.dispose(),
         disposeInteractionObservation(),
-        closeRuntimeTraceStream(),
+        closeRuntimeTraceStream(true),
       ]);
       // The pane-stream coordinator may still hold runtime consumers while it
       // drains. Preserve the normal shutdown order on startup rollback too:
@@ -2044,7 +2032,7 @@ async function startEmbeddedDaemonGeneration(
         appWindowMutationDisposal,
         workspaceMultiplexerDisposal,
         externalInteractionDisposal,
-        closeRuntimeTraceStream(),
+        closeRuntimeTraceStream(true),
         Promise.resolve().then(() => closeClients()),
         ...[...sockets].map((socket) => Promise.resolve().then(() => socket.destroy())),
         Promise.race([closePromise, delay(100)]),

package/packages/daemon/src/lib/runtime-trace-writer.ts

@@ -0,0 +1,132 @@
+import type { Writable } from "node:stream";
+
+const MAX_RECORD_BYTES = 64 * 1024;
+
+/** Opt-in diagnostics: one stream buffer, no additional queue or producer backpressure. */
+export function createRuntimeTraceWriter(
+  stream: Writable,
+  identity: { processId: string; daemonInstanceId: string },
+  closeTimeoutMs = 1000,
+) {
+  const counts = {
+    offeredRecords: 0,
+    acceptedRecords: 0,
+    droppedRecords: 0,
+    saturatedDrops: 0,
+    failedDrops: 0,
+    oversizedRecords: 0,
+    constructionFailures: 0,
+    rejectedWrites: 0,
+    writeFailures: 0,
+  };
+  let saturated = false;
+  let failed = false;
+  let closed = false;
+  let closing: Promise<void> | undefined;
+  let closeFailure: ((error: Error) => void) | undefined;
+  const snapshot = () => ({ ...counts, failed, saturated, writableLength: stream.writableLength });
+  stream.on("drain", () => {
+    if (!failed) saturated = false;
+  });
+  // Retain the error listener through destroy: a late stream error must not escape cleanup.
+  stream.on("error", (error: Error) => {
+    counts.writeFailures++;
+    failed = true;
+    closeFailure?.(error);
+  });
+  return {
+    snapshot,
+    append(build: () => unknown): void {
+      if (closed) return;
+      counts.offeredRecords++;
+      if (failed || stream.destroyed) {
+        counts.failedDrops++;
+        counts.droppedRecords++;
+        return;
+      }
+      if (saturated) {
+        counts.saturatedDrops++;
+        counts.droppedRecords++;
+        return;
+      }
+      let line: string;
+      try {
+        const json = JSON.stringify(build());
+        if (json === undefined) throw new Error("Trace record is not JSON");
+        line = `${json}\n`;
+        if (Buffer.byteLength(line) > MAX_RECORD_BYTES) {
+          counts.oversizedRecords++;
+          counts.droppedRecords++;
+          return;
+        }
+      } catch {
+        counts.constructionFailures++;
+        counts.droppedRecords++;
+        failed = true;
+        return;
+      }
+      try {
+        saturated = !stream.write(line);
+        counts.acceptedRecords++;
+      } catch {
+        counts.rejectedWrites++;
+        counts.droppedRecords++;
+        failed = true;
+      }
+    },
+    close(incomplete = false): Promise<void> {
+      if (closing) return closing;
+      closed = true;
+      if (incomplete) failed = true;
+      closing = new Promise<void>((resolve, reject) => {
+        let settled = false;
+        const finish = (error?: Error) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          stream.off("drain", end);
+          stream.off("close", prematureClose);
+          closeFailure = undefined;
+          if (error) {
+            failed = true;
+            stream.destroy();
+            reject(error);
+          } else resolve();
+        };
+        const prematureClose = () =>
+          finish(new Error("Runtime trace closed before final summary completion"));
+        const end = () => {
+          try {
+            if (stream.destroyed || !stream.writable)
+              throw new Error("Runtime trace stream unavailable");
+            const summary = {
+              version: 1,
+              type: "performance.daemon-trace.summary",
+              ...identity,
+              ...snapshot(),
+              maxRecordBytes: MAX_RECORD_BYTES,
+              acceptedRecordsExcludeSummary: true,
+              shutdownKind: incomplete ? "startup-rollback" : "normal",
+              ringTailOverwrites: "not-file-loss",
+            };
+            stream.end(`${JSON.stringify(summary)}\n`, () =>
+              finish(failed ? new Error("Runtime trace recorded failures") : undefined),
+            );
+          } catch (error) {
+            finish(error instanceof Error ? error : new Error("Runtime trace end failed"));
+          }
+        };
+        const timer = setTimeout(
+          () => finish(new Error("Runtime trace close timed out")),
+          closeTimeoutMs,
+        );
+        closeFailure = finish;
+        stream.on("close", prematureClose);
+        if (stream.destroyed) finish(new Error("Runtime trace stream destroyed"));
+        else if (saturated && stream.writableNeedDrain) stream.once("drain", end);
+        else end();
+      });
+      return closing;
+    },
+  };
+}

package/packages/daemon/src/lib/tmux-client-execution.ts

@@ -1,7 +1,12 @@
+import { fileURLToPath } from "node:url";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
-import { delimiter, isAbsolute, join } from "node:path";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
 import { resolveRuntimeNamespace } from "./runtime-namespace.ts";
-import { resolveBundledTmux, bundledTmuxResourceEnvironment } from "./bundled-tmux.ts";
+import {
+  resolveBundledTmux,
+  bundledTmuxResourceEnvironment,
+  withBundledTmuxResources,
+} from "./bundled-tmux.ts";
 
 export function resolveTmuxExecutable(): string {
   if (resolveRuntimeNamespace().development) return resolveBundledTmux()!;
@@ -57,3 +62,43 @@ export function tmuxClientEnvironment(
   }
   return { ...environment, ...bundledTmuxResourceEnvironment(executable) };
 }
+
+/** Ordinary CLI commands retain PATH selection; bundled tmux fills a missing system client. */
+export function resolveOrdinaryTmuxClient(
+  environment: NodeJS.ProcessEnv,
+  cwd?: string | URL,
+): {
+  executable: string;
+  environment: NodeJS.ProcessEnv;
+} {
+  const configured = environment.TMUX_IDE_TMUX_BIN;
+  const candidates = configured
+    ? [configured]
+    : (environment.PATH ?? "/usr/bin:/bin")
+        .split(delimiter)
+        .map((entry) =>
+          resolve(cwd instanceof URL ? fileURLToPath(cwd) : (cwd ?? process.cwd()), entry, "tmux"),
+        );
+  let executable: string | undefined;
+  for (const candidate of candidates) {
+    try {
+      if (!isAbsolute(candidate)) continue;
+      accessSync(candidate, constants.X_OK);
+      const canonical = realpathSync(candidate);
+      if (statSync(canonical).isFile()) {
+        executable = canonical;
+        break;
+      }
+    } catch {
+      /* Try the next ordinary PATH candidate. */
+    }
+  }
+  if (!executable && !configured)
+    executable =
+      resolveBundledTmux([
+        ...(environment.TMUX_IDE_CLI ? [environment.TMUX_IDE_CLI] : []),
+        fileURLToPath(import.meta.url),
+      ]) ?? undefined;
+  if (!executable) throw new Error("tmux_executable_unavailable");
+  return { executable, environment: withBundledTmuxResources(executable, environment) };
+}

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

@@ -19,7 +19,8 @@ import { createNativeTmuxSessionCreator } from "./tmux-server-session-create.ts"
 import type { WorkspacePaneCreateMutationRequest } from "@tmux-ide/contracts";
 import { createTmuxSessionMutationFence } from "./tmux-session-mutation-fence.ts";
 import { createNativeTmuxSessionOpener } from "./tmux-server-session-open.ts";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { WorkspaceIdSchemaZ } from "@tmux-ide/contracts";
 import { mkdirSync } from "node:fs";
 import { z } from "zod";
 import type { WorkspaceMultiplexerBackend } from "../command-center/actions/handlers/workspace-multiplexer.ts";
@@ -61,6 +62,22 @@ export interface NativeTmuxServerOwnerOptions {
   readonly nativeServerIdentity?: NativeTmuxServerIdentity;
 }
 
+/** Native display names are not necessarily valid shared-contract record identities. */
+function discoveredWorkspaceName(registry: WorkspaceRegistry, sessionName: string): string {
+  if (WorkspaceIdSchemaZ.safeParse(sessionName).success && !registry.has(sessionName))
+    return sessionName;
+  // Existing intent wins even if it occupies a derived ID. Each candidate is
+  // deterministic; repeated refreshes retain the already-adopted session alias.
+  for (let suffix = 0; suffix <= registry.list().length; suffix += 1) {
+    const digest = createHash("sha256")
+      .update(`tmux-ide.discovered-workspace.v1\0${sessionName}\0${suffix}`)
+      .digest("hex");
+    const name = `session-${digest}`;
+    if (!registry.has(name)) return name;
+  }
+  throw new Error("Unable to allocate discovered workspace identity");
+}
+
 /** Refresh discovered live membership without changing durable workspace intent or aliases. */
 export function createNativeTmuxServerCatalog(
   workspaceRegistry: WorkspaceRegistry,
@@ -114,11 +131,10 @@ export function createNativeTmuxServerCatalog(
         workspaceRegistry.remove(workspace.name);
     for (const { summary, dir } of rows.values())
       if (
-        !workspaceRegistry.has(summary.sessionName) &&
         !workspaceRegistry.list().some((workspace) => workspace.sessionName === summary.sessionName)
       )
         workspaceRegistry.add({
-          name: summary.sessionName,
+          name: discoveredWorkspaceName(workspaceRegistry, summary.sessionName),
           sessionName: summary.sessionName,
           projectDir: dir,
           persistence: "volatile",

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

@@ -620,6 +620,7 @@ function analyzeInventoryPanes(panes: readonly NativeTerminalInventoryPaneSnapsh
         active: _active,
         role: _role,
         name: _name,
+        nameSource: _nameSource,
         type: _type,
         missionStamp: _missionStamp,
         dir: _dir,
@@ -989,6 +990,7 @@ export async function discoverWorkspaceRegistryTerminalInventory(
         active: _active,
         role: _role,
         name: _name,
+        nameSource: _nameSource,
         type: _type,
         missionStamp: _missionStamp,
         dir: _dir,
@@ -1018,6 +1020,7 @@ export async function discoverWorkspaceRegistrySemanticPanes(
       active: _active,
       role: _role,
       name: _name,
+      nameSource: _nameSource,
       type: _type,
       missionStamp: _missionStamp,
       dir: _dir,
@@ -1349,6 +1352,7 @@ export class WorkspaceTerminalInventoryRuntime {
               active: _active,
               role: _role,
               name: _name,
+              nameSource: _nameSource,
               type: _type,
               missionStamp: _missionStamp,
               dir: _dir,
@@ -2066,6 +2070,7 @@ export class NativeTerminalAttachmentRuntime {
               active: _active,
               role: _role,
               name: _name,
+              nameSource: _nameSource,
               type: _type,
               missionStamp: _missionStamp,
               dir: _dir,
@@ -2341,6 +2346,7 @@ export class NativeTerminalAttachmentRuntime {
           active: _active,
           role: _role,
           name: _name,
+          nameSource: _nameSource,
           type: _type,
           missionStamp: _missionStamp,
           dir: _dir,