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

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-home-experience.js

@@ -0,0 +1,40 @@
+import { createApplicationHomeFleetOwner } from "./application-home-fleet.js";
+import { createApplicationHomeNavigationOwner } from "./application-home-agents-owner.js";
+import { createApplicationGuidedTourIntegration } from "./application-guided-tour-integration.jsx";
+/** Compose Home's fleet, navigation and learning experience without additional transports. */
+export function createApplicationHomeExperience(options) {
+    const { machines, appearance } = options;
+    const paletteOpen = () => options.shell().semantic?.focus.palette.open ?? options.shell().localPaletteOpen;
+    const fleetHome = createApplicationHomeFleetOwner({
+        catalog: machines.catalog,
+        agents: machines.agents,
+        inputActive: () => options.activeSurface() === "home" &&
+            options.rendererFocused() &&
+            !options.paletteModalOpen() &&
+            !machines.switching() &&
+            !machines.adding() &&
+            !machines.focused() &&
+            !paletteOpen() &&
+            !appearance.pickerOpen(),
+        open: (_machineId, agent, source) => machines.openHomeAgent(agent, source),
+    });
+    const navigation = createApplicationHomeNavigationOwner({
+        ...options,
+        fleetHome: fleetHome.presentation,
+        fleetCommands: machines.paletteCommands,
+        openFleet: machines.openPalette,
+    });
+    const tour = createApplicationGuidedTourIntegration({
+        ...options,
+        sessionName: () => options.sessionOwner()?.sessionName() ?? null,
+        paletteOpen,
+        paletteCommands: navigation.paletteCommands,
+        blocked: () => options.paletteModalOpen() ||
+            !!navigation.paneRename.draft() ||
+            paletteOpen() ||
+            appearance.pickerOpen() ||
+            machines.switching() ||
+            machines.adding(),
+    });
+    return { ...navigation, tour };
+}

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

@@ -0,0 +1,132 @@
+import { createEffect, createMemo, createSignal, onCleanup } from "solid-js";
+import { createHomeAgentSelectionOwner } from "./application-home-agent-selection.js";
+export function projectHomeFleet(catalog, groups, filter) {
+    const machines = catalog.groups.filter((group) => filter.machineId === null || group.id === filter.machineId);
+    const rows = [];
+    const unavailable = new Set();
+    let observedSessions = 0, totalSessions = 0, loadingSessions = 0, unavailableSessions = 0, truncatedSessions = 0;
+    const panes = new Set();
+    for (const machine of machines) {
+        const group = groups.find((group) => group.machineId === machine.id);
+        totalSessions += machine.sessions.length;
+        const observation = machine.state === "ready" ? group?.observation : undefined;
+        observedSessions +=
+            observation?.observedSessions ?? (group?.available ? machine.sessions.length : 0);
+        loadingSessions +=
+            observation?.loadingSessions ??
+                (machine.state === "connecting" ? machine.sessions.length : 0);
+        unavailableSessions +=
+            observation?.unavailableSessions ??
+                (machine.state === "disconnected" ? machine.sessions.length : 0);
+        truncatedSessions += observation?.truncatedSessions ?? 0;
+        for (const key of observation?.unavailableSessionKeys ?? [])
+            unavailable.add(JSON.stringify([machine.id, key]));
+        for (const agent of [...(group?.agents ?? [])].sort((a, b) => Number(a.disabled) - Number(b.disabled) || a.id.localeCompare(b.id))) {
+            const sessionKey = JSON.stringify([machine.id, agent.sessionKey]);
+            if (agent.disabled)
+                unavailable.add(sessionKey);
+            if (filter.attentionOnly &&
+                !(agent.attention || agent.activity === "waiting" || agent.activity === "failed"))
+                continue;
+            const paneKey = agent.paneId
+                ? JSON.stringify([machine.id, agent.server?.serverId, agent.daemonInstanceId, agent.paneId])
+                : agent.id;
+            if (panes.has(paneKey))
+                continue;
+            panes.add(paneKey);
+            rows.push({ ...agent, key: agent.id, sessionKey, machineLabel: machine.label });
+        }
+    }
+    // Identity order never jumps when an activity signal changes.
+    rows.sort((a, b) => a.key.localeCompare(b.key));
+    const missing = machines.filter((machine) => machine.state !== "ready" ||
+        !groups.find((group) => group.machineId === machine.id)?.available);
+    return {
+        phase: missing.length
+            ? rows.length || observedSessions
+                ? "partial"
+                : machines.some((machine) => machine.state === "connecting")
+                    ? "loading"
+                    : "unavailable"
+            : "live",
+        rows,
+        observedSessions,
+        totalSessions,
+        loadingSessions,
+        unavailableSessions,
+        truncatedSessions,
+        refreshingSessionKeys: [],
+        unavailableSessionKeys: [...unavailable],
+        note: missing.length
+            ? `${missing.map((machine) => `${machine.label}: ${machine.state === "ready" ? "partial observations" : machine.state}`).join(" · ")} · unavailable rows show last observed activity`
+            : rows.length === 0 && filter.attentionOnly
+                ? "No agents need attention in this view."
+                : null,
+    };
+}
+/** Reuses resident fleet observations, adding no daemon connections or pane streams. */
+export function createApplicationHomeFleetOwner(options) {
+    const [catalog, setCatalog] = createSignal(options.catalog.getSnapshot());
+    const [groups, setGroups] = createSignal(options.agents.getSnapshot());
+    const [filter, setFilter] = createSignal({
+        machineId: null,
+        attentionOnly: false,
+    });
+    const selection = createHomeAgentSelectionOwner();
+    const [selected, setSelected] = createSignal(selection.snapshot());
+    const snapshot = createMemo(() => projectHomeFleet(catalog(), groups(), filter()));
+    const stops = [
+        options.catalog.subscribe(setCatalog),
+        options.agents.subscribe(setGroups),
+        selection.subscribe(setSelected),
+    ];
+    createEffect(() => selection.setRows(snapshot().rows));
+    createEffect(() => {
+        const id = filter().machineId;
+        if (id && !catalog().groups.some((group) => group.id === id))
+            setFilter((value) => ({ ...value, machineId: null }));
+    });
+    onCleanup(() => {
+        for (const stop of stops)
+            stop();
+        selection.dispose();
+    });
+    const presentation = {
+        get agentRoster() {
+            return snapshot();
+        },
+        get agentSelection() {
+            return selected();
+        },
+        get agentInputActive() {
+            return options.inputActive();
+        },
+        get agentFilterLabel() {
+            return `${catalog().groups.find((group) => group.id === filter().machineId)?.label ?? "All machines"} · ${filter().attentionOnly ? "Needs attention" : "All agents"}`;
+        },
+        onCycleAgentMachine() {
+            const ids = [null, ...catalog().groups.map((group) => group.id)];
+            setFilter((value) => ({
+                ...value,
+                machineId: ids[(ids.indexOf(value.machineId) + 1) % ids.length],
+            }));
+        },
+        onToggleAgentAttention() {
+            setFilter((value) => ({ ...value, attentionOnly: !value.attentionOnly }));
+        },
+        onRetryAgents: () => options.agents.retry?.(),
+        onLoadMoreAgents: () => options.agents.loadMore?.(),
+        onSelectAgent: selection.select,
+        onMoveAgent: selection.move,
+        onAgentViewport: selection.setViewport,
+        onOpenAgent(row, source) {
+            if (!options.inputActive())
+                return;
+            const group = groups().find((group) => group.machineId === row.machineId);
+            const agent = group?.agents.find((agent) => agent.id === row.key);
+            if (agent && !agent.disabled && agent.paneId)
+                void options.open(agent.machineId, agent, source);
+        },
+    };
+    return { presentation };
+}

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

@@ -34,6 +34,7 @@ export function createApplicationMachineAgents(options) {
             const current = !!entry && entry.binding === bindingFor(entry.handle);
             return Object.freeze({
                 machineId: group.id,
+                observation: entry?.observer?.getSnapshot(),
                 available: group.state === "ready" && current && entry?.observer?.getSnapshot().phase === "live",
                 agents: Object.freeze((entry?.rows ?? []).map((row) => Object.freeze({
                     ...row,
@@ -139,6 +140,14 @@ export function createApplicationMachineAgents(options) {
                 entry.binding === bindingFor(entry.handle) &&
                 !!entry.observer?.isCurrentTarget(row));
         },
+        retry() {
+            for (const entry of entries.values())
+                entry.observer?.retry();
+        },
+        loadMore() {
+            for (const entry of entries.values())
+                entry.observer?.loadMore();
+        },
         start() {
             if (started || disposed)
                 return;

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 } : {}),
                         })),
                     });
                 }