tmux-ide 2.9.0-beta.21 → 2.9.0-beta.22

package/packages/daemon/dist/tui/mirror/open-tui-workspace-runtime-port.js

@@ -109,14 +109,18 @@ function layoutKey(frame) {
         return null;
     return `panes:${panes.join("\u0000")}`;
 }
-function layoutSnapshot(windows, currentWindowKey = null) {
+function layoutSnapshot(windows, currentWindowKey = null, windowLinks = null) {
     const selectedKey = currentWindowKey ??
         [...windows.entries()].find(([, frame]) => frame.currentWindow)?.[0] ??
         null;
     const frames = Object.freeze([...windows.entries()].map(([key, frame]) => frame.currentWindow === (key === selectedKey)
         ? frame
         : freezeLayout({ ...frame, currentWindow: key === selectedKey })));
+    const links = windowLinks?.links.map((link) => Object.freeze({ ...link }));
+    if (links)
+        Object.freeze(links);
     return Object.freeze({
+        windowLinks: windowLinks && links ? Object.freeze({ ...windowLinks, links }) : null,
         current: frames.find((frame) => frame.currentWindow) ?? null,
         windows: frames,
     });
@@ -144,7 +148,8 @@ function layoutFrameSemanticallyEqual(left, right) {
         }));
 }
 function layoutSnapshotsSemanticallyEqual(left, right) {
-    return (left.windows.length === right.windows.length &&
+    return (JSON.stringify(left.windowLinks ?? null) === JSON.stringify(right.windowLinks ?? null) &&
+        left.windows.length === right.windows.length &&
         left.windows.every((window, index) => {
             const candidate = right.windows[index];
             return candidate !== undefined && layoutFrameSemanticallyEqual(window, candidate);
@@ -702,6 +707,8 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
         if (coherentSettled ||
             closed ||
             !physicalReady ||
+            (routing.liveSessionId !== undefined &&
+                latestLayoutSnapshot.windowLinks?.liveSessionId !== routing.liveSessionId) ||
             !layoutExactlyCoversPanes(latestLayoutSnapshot, panes) ||
             !latestLayoutSnapshot.current?.panes.every(({ pane }) => typeof pane === "string" && canonicalSeedPanes.has(pane))) {
             return;
@@ -866,7 +873,7 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
                 : {}),
             signal: options.signal,
             stream: {
-                protocolVersion: 1,
+                protocolVersion: 2,
                 workspaceName: inventory.workspaceName,
                 panes: [...panes],
                 viewerMode: "interactive",
@@ -981,13 +988,16 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
                     });
                     return;
                 }
+                if (latestLayoutSnapshot.windowLinks &&
+                    !latestLayoutSnapshot.windowLinks.links.some((link) => link.semanticWindowId === retained.semanticWindowId))
+                    return;
                 layoutsByWindow.set(key, retained);
                 // tmux reports a switch as incumbent=false followed by target=true.
                 // Retain the incumbent through that pair and publish one unique current
                 // window only when the positive target frame arrives.
-                if (retained.currentWindow)
+                if (!latestLayoutSnapshot.windowLinks && retained.currentWindow)
                     currentWindowKey = key;
-                const candidate = layoutSnapshot(layoutsByWindow, currentWindowKey);
+                const candidate = layoutSnapshot(layoutsByWindow, currentWindowKey, latestLayoutSnapshot.windowLinks ?? null);
                 if (!layoutExactlyCoversPanes(candidate, panes)) {
                     if (lastRejectedLayoutSnapshot &&
                         layoutSnapshotsSemanticallyEqual(candidate, lastRejectedLayoutSnapshot))
@@ -1023,6 +1033,9 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
             onLayoutSnapshot: (snapshot) => {
                 if (closed)
                     return;
+                if (routing.liveSessionId !== undefined &&
+                    snapshot.windowLinks.liveSessionId !== routing.liveSessionId)
+                    return failConnection(new Error("Selected live session was replaced before terminal activation"));
                 const replacement = new Map();
                 let replacementCurrent = null;
                 for (const frame of snapshot.layouts) {
@@ -1030,14 +1043,15 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
                     const key = layoutKey(retained);
                     if (key === null || replacement.has(key))
                         return failConnection(new Error("invalid layout snapshot"));
-                    replacement.set(key, retained);
+                    const previous = layoutsByWindow.get(key);
+                    replacement.set(key, previous && layoutFrameSemanticallyEqual(previous, retained) ? previous : retained);
                     if (retained.currentWindow) {
                         if (replacementCurrent !== null)
                             return failConnection(new Error("invalid layout snapshot current window"));
                         replacementCurrent = key;
                     }
                 }
-                const candidate = layoutSnapshot(replacement, replacementCurrent);
+                const candidate = layoutSnapshot(replacement, replacementCurrent, snapshot.windowLinks);
                 if (!layoutExactlyCoversPanes(candidate, panes))
                     return failConnection(new Error("layout snapshot does not cover terminal inventory"));
                 layoutsByWindow.clear();
@@ -1048,6 +1062,11 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
                 if (layoutSnapshotsSemanticallyEqual(candidate, latestLayoutSnapshot))
                     return;
                 latestLayoutSnapshot = candidate;
+                options.onDiagnostic?.("layout", {
+                    windows: candidate.windows.length,
+                    current: candidate.current !== null,
+                    links: candidate.windowLinks?.links.length ?? 0,
+                });
                 settleCoherent();
                 for (const listener of [...layoutListeners]) {
                     try {
@@ -1198,7 +1217,9 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
         submitIntent: async (operationId, intent) => {
             // Structural commands can affect hidden panes. Do not defer user intent
             // until a different topology may be current; fail closed during seeding.
-            if (closed || [...endpoints.values()].some((endpoint) => !endpoint.inputReady))
+            if (closed ||
+                !latestLayoutSnapshot.windowLinks ||
+                [...endpoints.values()].some((endpoint) => !endpoint.inputReady))
                 throw new Error("Terminal inventory is still receiving canonical state");
             return (await opened.submitIntent(operationId, intent)) ?? undefined;
         },

package/packages/daemon/dist/tui/mirror/runtime/application-home-catalog-owner.js

@@ -56,8 +56,12 @@ export function createApplicationHomeCatalogOwner(options) {
         const currentSessions = next.sessions;
         if (automaticOpen && next.phase === "live") {
             automaticOpen = false;
-            if (currentSessions.length === 1)
-                void options.startGeneration(currentSessions[0].name);
+            if (currentSessions.length === 1) {
+                const session = currentSessions[0];
+                void (options.openCatalogSession
+                    ? options.openCatalogSession(session)
+                    : options.startGeneration(session.name));
+            }
         }
         if (currentSessions.length === 0) {
             if (current !== null)
@@ -93,9 +97,11 @@ export function createApplicationHomeCatalogOwner(options) {
                 return true;
             }
             if (name === "return" || name === "enter") {
-                const sessionName = sessions()[selectedSessionIndex()]?.name;
-                if (sessionName)
-                    void options.startGeneration(sessionName);
+                const session = sessions()[selectedSessionIndex()];
+                if (session)
+                    void (options.openCatalogSession
+                        ? options.openCatalogSession(session)
+                        : options.startGeneration(session.name));
                 return true;
             }
             return false;

package/packages/daemon/dist/tui/mirror/runtime/application-home-catalog.js

@@ -1,8 +1,8 @@
+import WebSocket from "ws";
+import { createWorkspaceEventSupervisor, } from "@tmux-ide/daemon-client/workspace-event-supervisor";
 import { readApplicationDaemonInfo as readCanonicalDaemonInfo } from "./application-daemon-authority.js";
-import { WorkspaceCatalogResourceV3SchemaZ, } from "@tmux-ide/contracts";
+import { TmuxServersResourceSchemaZ, TmuxServerSessionsResourceSchemaZ, } from "@tmux-ide/contracts";
 import { createPushResourceSession, } from "@tmux-ide/daemon-client/push-resource-session";
-import { createWorkspaceEventSupervisor, } from "@tmux-ide/daemon-client/workspace-event-supervisor";
-import WebSocket from "ws";
 import { canonicalDaemonUrl } from "../../../lib/canonical-daemon.js";
 function sameDaemon(left, right) {
     return (left?.protocolVersion === right.protocolVersion &&
@@ -22,7 +22,7 @@ export function closeApplicationHomeCatalogTransport(subscription, supervisor) {
     subscription.close();
     supervisor.dispose();
 }
-function createApplicationHomeCatalogAdapter(onTransportRetired) {
+function createApplicationHomeCatalogAdapter(_onTransportRetired) {
     return {
         validateTarget(value) {
             if (!value ||
@@ -42,10 +42,9 @@ function createApplicationHomeCatalogAdapter(onTransportRetired) {
             };
         },
         async fetch(target, _key, signal) {
-            const url = canonicalDaemonUrl("http", target.daemon.bindHostname, target.daemon.port, "/api/resources/workspace-catalog?version=3");
-            let response;
-            try {
-                response = await fetch(url, {
+            const base = canonicalDaemonUrl("http", target.daemon.bindHostname, target.daemon.port);
+            const read = async (path) => {
+                const response = await fetch(base + path, {
                     headers: {
                         accept: "application/json",
                         ...(target.daemon.authToken
@@ -55,75 +54,129 @@ function createApplicationHomeCatalogAdapter(onTransportRetired) {
                     credentials: "omit",
                     cache: "no-store",
                     redirect: "error",
-                    signal,
+                    signal: AbortSignal.any([signal, AbortSignal.timeout(3_000)]),
                 });
-            }
-            catch {
-                return {
-                    status: "failed",
-                    failure: catalogFailure("network", "Live session discovery failed.", true),
-                };
-            }
-            if (!response.ok)
+                if (!response.ok)
+                    throw new Error(`Discovery returned HTTP ${response.status}`);
+                return response.json();
+            };
+            try {
+                const inventory = TmuxServersResourceSchemaZ.parse(await read("/api/v1/tmux-servers"));
+                const sessions = await Promise.allSettled(inventory.servers.map(async (descriptor) => {
+                    if (descriptor.state !== "online")
+                        return [];
+                    const server = { serverId: descriptor.serverId, generation: descriptor.generation };
+                    const result = TmuxServerSessionsResourceSchemaZ.parse(await read(`/api/v1/tmux-servers/${server.serverId}/${server.generation}/sessions`));
+                    if (result.server.serverId !== server.serverId ||
+                        result.server.generation !== server.generation)
+                        throw new Error("Server discovery identity changed");
+                    return result.sessions.map((session) => ({
+                        id: JSON.stringify([server.serverId, server.generation, session.liveSessionId]),
+                        server,
+                        serverLabel: descriptor.label,
+                        liveSessionId: session.liveSessionId,
+                        name: session.sessionName,
+                        ...(session.workspaceName ? { workspaceName: session.workspaceName } : {}),
+                        paneCount: session.paneCount,
+                    }));
+                }));
                 return {
-                    status: "failed",
-                    failure: catalogFailure("http", `Live session discovery returned HTTP ${response.status}.`, response.status >= 500),
+                    status: "ok",
+                    resource: {
+                        kind: "live-catalog",
+                        daemonInstanceId: target.daemon.instanceId,
+                        servers: inventory.servers.map((server, index) => sessions[index]?.status === "rejected"
+                            ? {
+                                serverId: server.serverId,
+                                label: server.label,
+                                state: "offline",
+                                generation: null,
+                            }
+                            : server),
+                        scopedSessions: sessions.flatMap((result) => result.status === "fulfilled" ? result.value : []),
+                    },
                 };
-            let body;
-            try {
-                body = await response.json();
             }
             catch {
                 return {
                     status: "failed",
-                    failure: catalogFailure("schema", "Live session discovery returned invalid JSON.", false),
+                    failure: catalogFailure("network", "Server session discovery failed.", true),
                 };
             }
-            const parsed = WorkspaceCatalogResourceV3SchemaZ.safeParse(body);
-            if (!parsed.success || !sameDaemon(target.daemon, parsed.data.daemon))
-                return {
-                    status: "failed",
-                    failure: catalogFailure("schema", "Live session discovery failed daemon identity validation.", false),
-                };
-            return { status: "ok", resource: { kind: "live-catalog", value: parsed.data } };
         },
         async connect(target, _interests, handlers, signal) {
-            const socketUrl = canonicalDaemonUrl("ws", target.daemon.bindHostname, target.daemon.port, "/ws/events?mode=semantic");
-            const socket = new WebSocket(socketUrl, {
-                headers: target.daemon.authToken
-                    ? { Authorization: `Bearer ${target.daemon.authToken}` }
-                    : undefined,
-            });
-            const supervisor = createWorkspaceEventSupervisor({
-                socket,
-                daemon: target.daemon,
-                workspaceName: target.workspaceName,
-                sessionName: target.workspaceName,
-                fetchTerminalRuntimeInventory: () => Promise.reject(new Error("Home catalog owns no terminal inventory.")),
-                onRetired: onTransportRetired,
-            });
-            const subscription = supervisor.connectWorkspaceCatalog(() => handlers.invalidate(["live-catalog"]), { terminalFirst: false });
+            // Root push is an advisory invalidation only: every refresh still resolves
+            // the full scoped inventory. The timer discovers changes on other owners.
             let closed = false;
-            const close = () => {
-                if (closed)
+            let pending = false;
+            let closePush = null;
+            const invalidate = () => {
+                if (!closed)
+                    handlers.invalidate(["live-catalog"]);
+            };
+            const startPush = async () => {
+                if (closed || pending || closePush)
                     return;
+                pending = true;
+                const socket = new WebSocket(canonicalDaemonUrl("ws", target.daemon.bindHostname, target.daemon.port, "/ws/events?mode=semantic"), {
+                    headers: target.daemon.authToken
+                        ? { Authorization: `Bearer ${target.daemon.authToken}` }
+                        : undefined,
+                });
+                const supervisor = createWorkspaceEventSupervisor({
+                    socket,
+                    daemon: target.daemon,
+                    workspaceName: target.workspaceName,
+                    sessionName: target.workspaceName,
+                    fetchTerminalRuntimeInventory: () => Promise.reject(new Error("Home catalog owns no terminal inventory.")),
+                    onRetired: () => {
+                        const cleanup = closePush;
+                        closePush = null;
+                        cleanup?.();
+                    },
+                });
+                const subscription = supervisor.connectWorkspaceCatalog(invalidate, {
+                    terminalFirst: false,
+                });
+                const cleanup = () => closeApplicationHomeCatalogTransport(subscription, supervisor);
+                closePush = cleanup;
+                try {
+                    await subscription.ready;
+                }
+                catch {
+                    if (closePush === cleanup)
+                        closePush = null;
+                    cleanup();
+                }
+                finally {
+                    pending = false;
+                    if (closed) {
+                        cleanup();
+                        closePush = null;
+                    }
+                }
+            };
+            const timer = setInterval(() => {
+                invalidate();
+                void startPush().catch(() => {
+                    pending = false;
+                });
+            }, 5_000);
+            const close = () => {
                 closed = true;
+                clearInterval(timer);
                 signal.removeEventListener("abort", close);
-                // Release the logical observer before retiring its physical transport.
-                closeApplicationHomeCatalogTransport(subscription, supervisor);
+                const cleanup = closePush;
+                closePush = null;
+                cleanup?.();
             };
             signal.addEventListener("abort", close, { once: true });
-            try {
-                await subscription.ready;
-            }
-            catch (error) {
+            if (signal.aborted)
                 close();
-                throw error;
-            }
-            if (signal.aborted) {
-                close();
-                throw signal.reason;
-            }
+            else
+                void startPush().catch(() => {
+                    pending = false;
+                });
             return { status: "connected", close };
         },
         rejectionFailure: () => catalogFailure("unavailable", "Live session discovery was rejected.", true),
@@ -145,29 +198,31 @@ const initialSnapshot = () => ({
     sessions: [],
     note: "Discovering live tmux sessions…",
 });
-function projectCatalog(resource) {
+function projectCatalog(resource, scopedSessions) {
     return {
         phase: "live",
         daemonInstanceId: resource.daemon.instanceId,
-        sessions: resource.liveSessions
-            .map(({ liveSessionId, sessionName, paneCount }) => ({
-            id: `${resource.daemon.instanceId}:${liveSessionId}`,
-            liveSessionId,
-            workspaceName: resource.intents.find((intent) => intent.sessionName === sessionName)
-                ?.workspaceName,
-            name: sessionName,
-            paneCount,
-        }))
-            .sort((left, right) => left.name.localeCompare(right.name)),
-        note: resource.liveSessions.length === 0
+        sessions: scopedSessions ??
+            resource.liveSessions
+                .map(({ liveSessionId, sessionName, paneCount }) => ({
+                id: `${resource.daemon.instanceId}:${liveSessionId}`,
+                liveSessionId,
+                workspaceName: resource.intents.find((intent) => intent.sessionName === sessionName)
+                    ?.workspaceName,
+                name: sessionName,
+                paneCount,
+            }))
+                .sort((left, right) => left.name.localeCompare(right.name)),
+        note: (scopedSessions?.length ?? resource.liveSessions.length) === 0
             ? "No live tmux sessions yet. This list updates automatically."
             : null,
     };
 }
 /**
- * Daemon-authoritative Home catalog. Reads are push-invalidated while the
- * daemon generation is healthy; the only timer is a bounded failure-recovery
- * probe used when no canonical daemon or event transport is available.
+ * Daemon-authoritative fleet metadata. Root push preserves immediate updates,
+ * while a five-second refresh discovers independent
+ * server owners without opening pane streams. Failed reads use bounded backoff;
+ * each failed server is excluded without suppressing healthy siblings.
  */
 export function createApplicationHomeCatalog(overrides = {}) {
     const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
@@ -253,7 +308,17 @@ export function createApplicationHomeCatalog(overrides = {}) {
         if (slot?.status === "loaded" && !slot.refreshing && slot.resource.kind === "live-catalog") {
             clearRetry();
             retryAttempt = 0;
-            publish(projectCatalog(slot.resource.value));
+            publish(slot.resource.value
+                ? projectCatalog(slot.resource.value)
+                : {
+                    phase: "live",
+                    daemonInstanceId: slot.resource.daemonInstanceId ?? null,
+                    sessions: slot.resource.scopedSessions ?? [],
+                    servers: slot.resource.servers,
+                    note: slot.resource.scopedSessions?.length
+                        ? null
+                        : "No live tmux sessions yet. This list updates automatically.",
+                });
             return;
         }
         if (slot?.status === "error") {

package/packages/daemon/dist/tui/mirror/runtime/application-machine-catalog.js

@@ -53,6 +53,7 @@ export function createApplicationMachineCatalog(options = {}) {
                     note: diagnostic && diagnostic.phase !== "ready"
                         ? fleetConnectionMessage(diagnostic)
                         : (entry?.snapshot.note ?? null),
+                    servers: entry?.snapshot.servers,
                     sessions: (entry?.lastSessions ?? []).map((session) => ({
                         ...session,
                         sourceId: session.id,
@@ -86,7 +87,13 @@ export function createApplicationMachineCatalog(options = {}) {
                     sessions: group.sessions.map((session) => ({
                         ...session,
                         id: session.liveSessionId && joined.environmentId && !joined.conflict
-                            ? JSON.stringify([joined.environmentId, "session", session.liveSessionId])
+                            ? JSON.stringify([
+                                joined.environmentId,
+                                "session",
+                                session.server?.serverId,
+                                session.server?.generation,
+                                session.liveSessionId,
+                            ])
                             : session.id,
                     })),
                 };
@@ -152,11 +159,14 @@ export function createApplicationMachineCatalog(options = {}) {
                         environmentId: entry.environmentId,
                         generation: entry.generation,
                         seenAt: entry.seenAt,
-                        sessions: value.sessions.slice(0, 64).map(({ id, liveSessionId, name, paneCount }) => ({
+                        sessions: value.sessions
+                            .slice(0, 64)
+                            .map(({ id, liveSessionId, name, paneCount, server, serverLabel }) => ({
                             id,
                             ...(liveSessionId ? { liveSessionId } : {}),
                             name,
                             paneCount,
+                            ...(server ? { server, serverLabel } : {}),
                         })),
                     });
                 }