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

package/packages/daemon/src/tui/mirror/runtime/application-machine-catalog.ts

@@ -1,3 +1,4 @@
+import type { TmuxServerDescriptor } from "@tmux-ide/contracts";
 import type { FleetCachedRoute } from "@tmux-ide/contracts/fleet-client-state";
 import { groupFleetEnvironments } from "@tmux-ide/daemon-client/fleet-environments";
 import {
@@ -27,6 +28,7 @@ export interface ApplicationMachineCatalogGroup {
   readonly label: string;
   readonly state: "ready" | "connecting" | "disconnected";
   readonly sessions: readonly ApplicationMachineCatalogSession[];
+  readonly servers?: readonly TmuxServerDescriptor[];
   readonly note: string | null;
   readonly diagnostic?: FleetConnectionStatus;
   readonly environmentId?: string | null;
@@ -114,6 +116,7 @@ export function createApplicationMachineCatalog(
             diagnostic && diagnostic.phase !== "ready"
               ? fleetConnectionMessage(diagnostic)
               : (entry?.snapshot.note ?? null),
+          servers: entry?.snapshot.servers,
           sessions: (entry?.lastSessions ?? []).map((session) => ({
             ...session,
             sourceId: session.id,
@@ -152,7 +155,13 @@ export function createApplicationMachineCatalog(
             ...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,
           })),
         };
@@ -214,12 +223,15 @@ export function createApplicationMachineCatalog(
             environmentId: entry.environmentId,
             generation: entry.generation,
             seenAt: entry.seenAt,
-            sessions: value.sessions.slice(0, 64).map(({ id, liveSessionId, name, paneCount }) => ({
-              id,
-              ...(liveSessionId ? { liveSessionId } : {}),
-              name,
-              paneCount,
-            })),
+            sessions: value.sessions
+              .slice(0, 64)
+              .map(({ id, liveSessionId, name, paneCount, server, serverLabel }) => ({
+                id,
+                ...(liveSessionId ? { liveSessionId } : {}),
+                name,
+                paneCount,
+                ...(server ? { server, serverLabel } : {}),
+              })),
           });
         } catch {
           /* Cache failure must never prevent live catalog publication. */

package/packages/daemon/src/tui/mirror/runtime/application-machine-navigation.ts

@@ -1,3 +1,5 @@
+import type { OpenTuiGenerationHostSnapshot } from "./open-tui-generation-host.ts";
+import type { TmuxServerScope } from "@tmux-ide/contracts";
 import { fleetHostColor } from "./fleet-presentation.ts";
 import type { ApplicationPaletteCommand } from "./application-palette-input.ts";
 import { createFleetTabs, type FleetTabTarget } from "./application-fleet-tabs.ts";
@@ -13,13 +15,30 @@ import { createApplicationMachineCatalog } from "./application-machine-catalog.t
 import { ephemeralMachineProfile } from "./application-machine-startup.ts";
 import type { ApplicationMachineSidebarModel } from "./application-machine-sidebar.tsx";
 
+/** Exact attached authority; an unscoped default connection still proves its incarnation. */
+function attachedMachineNavigationTarget(active: OpenTuiGenerationHostSnapshot | null) {
+  if (active?.status !== "live" || !active.connection?.liveSessionId || !active.daemonGeneration)
+    return null;
+  return {
+    liveSessionId: active.connection.liveSessionId,
+    daemonGeneration: active.daemonGeneration,
+    ...(active.connection.server ? { server: active.connection.server } : {}),
+  };
+}
+
 export function createApplicationMachineNavigation(options: {
-  resetWorkspace(machineId: string, expectedLiveSessionId?: string): void;
+  resetWorkspace(machineId: string, expectedLiveSessionId?: string, server?: TmuxServerScope): void;
   openAgent?(agent: ApplicationMachineAgent, source: "keyboard" | "mouse"): Promise<unknown> | void;
   cancelOpen(): void;
   openSession(name: string, source: "keyboard" | "mouse"): Promise<unknown>;
   sessionName(): string | null;
   activePaneId?(): string | null;
+  attachedGeneration?(): OpenTuiGenerationHostSnapshot | null;
+  attachedTarget?(): {
+    liveSessionId: string;
+    daemonGeneration: string;
+    server?: TmuxServerScope;
+  } | null;
   setSurface(value: "home" | "terminals"): void;
   setNote(value: string | null | ((current: string | null) => string | null)): void;
 }) {
@@ -45,10 +64,15 @@ export function createApplicationMachineNavigation(options: {
   const [snapshot, setSnapshot] = createSignal(catalog.getSnapshot());
   const [focused, setFocused] = createSignal(false);
   const [switching, setSwitching] = createSignal(false);
+  const [serverFocus, setServerFocus] = createSignal<{
+    machineId: string;
+    server: TmuxServerScope;
+  } | null>(null);
   const [attentionOnly, setAttentionOnly] = createSignal(false);
   const showSwitcher = (attention: boolean) => {
     navigation++;
     options.cancelOpen();
+    setServerFocus(null);
     setAttentionOnly(attention);
     setFocused(false);
     setSwitching(true);
@@ -56,21 +80,41 @@ export function createApplicationMachineNavigation(options: {
   const [adding, setAdding] = createSignal(false);
   const [alias, setAlias] = createSignal("");
   const [error, setError] = createSignal<string | null>(null);
-  const stop = catalog.subscribe(setSnapshot);
+  let attemptStartup: (() => void) | null = null;
+  const stop = catalog.subscribe((value) => {
+    setSnapshot(value);
+    attemptStartup?.();
+  });
   let navigation = 0;
+  const [activeSessionKey, setActiveSessionKey] = createSignal<string | null>(null);
   const [tabRevision, setTabRevision] = createSignal(0);
   const history: string[] = [...saved().recent].reverse();
   let historyIndex = history.length - 1;
-  const select = (id: string, expectedLiveSessionId?: string) => {
+  const select = (id: string, expectedLiveSessionId?: string, server?: TmuxServerScope) => {
     if (!manager.getMachine(id)) return false;
     if (manager.snapshot().selectedMachineId !== id) {
       navigation++;
       options.cancelOpen();
       // Synchronously remove the old input/shell owner before changing the route.
-      options.resetWorkspace(id, expectedLiveSessionId);
+      if (server) options.resetWorkspace(id, expectedLiveSessionId, server);
+      else options.resetWorkspace(id, expectedLiveSessionId);
       manager.select(id);
     } else if (expectedLiveSessionId) {
-      options.resetWorkspace(id, expectedLiveSessionId);
+      const attached =
+        options.attachedTarget?.() ??
+        attachedMachineNavigationTarget(options.attachedGeneration?.() ?? null);
+      const sameAuthority =
+        attached?.liveSessionId === expectedLiveSessionId &&
+        (server
+          ? attached.server
+            ? attached.server.serverId === server.serverId &&
+              attached.server.generation === server.generation
+            : attached.daemonGeneration === server.generation &&
+              manager.getMachine(id)?.read()?.instanceId === server.generation
+          : !attached.server);
+      if (sameAuthority) return true;
+      if (server) options.resetWorkspace(id, expectedLiveSessionId, server);
+      else options.resetWorkspace(id, expectedLiveSessionId);
     }
     return true;
   };
@@ -80,18 +124,44 @@ export function createApplicationMachineNavigation(options: {
     source: "keyboard" | "mouse",
     remember = true,
     expectedLiveSessionId?: string,
+    server?: TmuxServerScope,
+    sessionKey?: string,
   ) => {
     // A same-machine session click supersedes any pending exact-agent focus too.
     if (manager.snapshot().selectedMachineId === id) options.cancelOpen();
     // A sidebar selection can leave a tab whose route is pinned to a different
     // live incarnation on this same machine. Select a new exact owner before
     // preparation; never apply that old tab's identity fence to the new name.
-    if (!expectedLiveSessionId && options.sessionName() !== name) {
-      expectedLiveSessionId = snapshot()
+    if (manager.getMachine(id)?.endpoint().state !== "ready") {
+      select(id);
+      options.setNote("This machine is disconnected. Select the session after reconnecting.");
+      return false;
+    }
+    const candidates =
+      snapshot()
         .groups.find((group) => group.id === id || group.routeIds?.includes(id))
-        ?.sessions.find((row) => row.name === name && !row.disabled)?.liveSessionId;
+        ?.sessions.filter(
+          (row) =>
+            row.name === name &&
+            !row.disabled &&
+            (!sessionKey || row.id === sessionKey) &&
+            (!expectedLiveSessionId || row.liveSessionId === expectedLiveSessionId) &&
+            (!server ||
+              (row.server?.serverId === server.serverId &&
+                row.server.generation === server.generation)),
+        ) ?? [];
+    if (candidates.length !== 1) {
+      options.setNote(
+        "Select the session under its tmux server; this target is ambiguous or has changed.",
+      );
+      return false;
     }
-    if (!select(id, expectedLiveSessionId)) return;
+    const selected = candidates[0]!;
+    const sameSelection = activeSessionKey() === selected.id && options.sessionName() === name;
+    setActiveSessionKey(selected.id);
+    expectedLiveSessionId = selected.liveSessionId;
+    server = selected.server;
+    if (!select(id, sameSelection ? undefined : expectedLiveSessionId, server)) return;
     const token = ++navigation;
     setFocused(false);
     options.setSurface("terminals");
@@ -111,15 +181,21 @@ export function createApplicationMachineNavigation(options: {
     if (token === navigation) {
       const session = snapshot()
         .groups.find((group) => group.id === id || group.routeIds?.includes(id))
-        ?.sessions.find((row) => row.name === name && !row.disabled);
+        ?.sessions.find((row) => row.id === selected.id && !row.disabled);
       if (session) {
         if (session.liveSessionId)
           tabs.remember({
-            key: JSON.stringify([id, session.liveSessionId]),
+            key: JSON.stringify([
+              id,
+              session.server?.serverId,
+              session.server?.generation,
+              session.liveSessionId,
+            ]),
+            server: session.server,
             machineId: id,
             liveSessionId: session.liveSessionId,
             label: session.name,
-            hostLabel: manager.getMachine(id)?.label ?? id,
+            hostLabel: `${manager.getMachine(id)?.label ?? id}${session.serverLabel ? ` / ${session.serverLabel}` : ""}`,
           });
         preferences.change({ type: "visit", key: session.id });
         if (remember && history[historyIndex] !== session.id) {
@@ -138,30 +214,57 @@ export function createApplicationMachineNavigation(options: {
       (g) => g.id === target.machineId || g.routeIds?.includes(target.machineId),
     );
     const row = group?.sessions.find(
-      (s) => s.liveSessionId === target.liveSessionId && !s.disabled,
+      (s) =>
+        s.liveSessionId === target.liveSessionId &&
+        !s.disabled &&
+        s.server?.serverId === target.server?.serverId &&
+        s.server?.generation === target.server?.generation,
     );
     return row ? { ...target, label: row.name } : null;
   };
   const tabs = createFleetTabs({
     resolve: resolveTab,
     retireActive: () => {
+      setActiveSessionKey(null);
       navigation++;
       options.cancelOpen();
       options.resetWorkspace(manager.snapshot().selectedMachineId);
       options.setSurface("home");
     },
     open: async (target) =>
-      !!(await open(target.machineId, target.label, "keyboard", true, target.liveSessionId)),
+      !!(await open(
+        target.machineId,
+        target.label,
+        "keyboard",
+        true,
+        target.liveSessionId,
+        target.server,
+      )),
     publish: () => setTabRevision((value) => value + 1),
     unavailable: () => options.setNote("That tab's session is unavailable or has been replaced."),
   });
+  const isDefaultSession = (machineId: string, session: { server?: TmuxServerScope }) =>
+    !session.server ||
+    session.server.generation === manager.getMachine(machineId)?.read()?.instanceId;
   const sidebar: ApplicationMachineSidebarModel = {
     groups: () =>
       snapshot().groups.map((group) => ({
         ...group,
         agentsAvailable:
-          agentGroups().find((value) => value.machineId === group.id)?.available ?? false,
-        agents: agentGroups().find((value) => value.machineId === group.id)?.agents ?? [],
+          group.sessions.some((session) => isDefaultSession(group.id, session)) &&
+          (agentGroups().find((value) => value.machineId === group.id)?.available ?? false),
+        agents: !group.sessions.some((session) => isDefaultSession(group.id, session))
+          ? []
+          : (agentGroups().find((value) => value.machineId === group.id)?.agents ?? []).map(
+              (agent) => ({
+                ...agent,
+                server: group.sessions.find(
+                  (session) =>
+                    session.liveSessionId === agent.liveSessionId &&
+                    isDefaultSession(group.id, session),
+                )?.server,
+              }),
+            ),
       })),
     tabs: () => {
       tabRevision();
@@ -182,6 +285,7 @@ export function createApplicationMachineNavigation(options: {
     onCollapse: (key, enabled) => preferences.change({ type: "collapse", key, enabled }),
     activeMachineId: () => snapshot().selectedMachineId,
     activeSessionName: options.sessionName,
+    activeSessionKey,
     activePaneId: options.activePaneId,
     focused,
     onFocus: () => {
@@ -190,8 +294,17 @@ export function createApplicationMachineNavigation(options: {
       setFocused(true);
     },
     onBlur: () => setFocused(false),
-    onOpen: (id, name, source) => void open(id, name, source),
+    onOpen: (id, name, source, sessionKey) =>
+      void open(id, name, source, true, undefined, undefined, sessionKey),
     onOpenAgent: (id, sessionName, paneId, source) => {
+      const sessions = snapshot().groups.find((group) => group.id === id)?.sessions ?? [];
+      const selectedSession = sessions.find(
+        (session) => session.name === sessionName && isDefaultSession(id, session),
+      );
+      if (sessions.length && !selectedSession) {
+        options.setNote("Open this agent through its server session first.");
+        return;
+      }
       const row = agentGroups()
         .find((group) => group.machineId === id)
         ?.agents.find((agent) => agent.sessionName === sessionName && agent.paneId === paneId);
@@ -202,11 +315,16 @@ export function createApplicationMachineNavigation(options: {
         return;
       }
       options.cancelOpen();
-      if (!select(id)) return;
+      if (!select(id, selectedSession?.liveSessionId, selectedSession?.server)) return;
+      if (selectedSession) setActiveSessionKey(selectedSession.id);
       navigation++;
       setFocused(false);
       void options.openAgent?.(row, source);
     },
+    onSelectServer: (machineId, server) => {
+      showSwitcher(false);
+      setServerFocus({ machineId, server });
+    },
     onSelectMachine: (id) => {
       tabs.suspend();
       navigation++;
@@ -242,6 +360,30 @@ export function createApplicationMachineNavigation(options: {
     catalog,
     agents,
     selectedMachineId: () => manager.snapshot().selectedMachineId,
+    openHomeAgent: (row: ApplicationMachineAgent, source: "keyboard" | "mouse") => {
+      if (!agents.isCurrentTarget(row.machineId, row) || row.disabled) return;
+      const session = snapshot()
+        .groups.find((group) => group.id === row.machineId)
+        ?.sessions.find(
+          (session) =>
+            session.liveSessionId === row.liveSessionId &&
+            !session.disabled &&
+            session.server?.serverId === row.server?.serverId &&
+            session.server?.generation === row.server?.generation,
+        );
+      if (!session) {
+        options.setNote("That agent session has changed. Select it again.");
+        return;
+      }
+      options.cancelOpen();
+      if (!select(row.machineId, row.liveSessionId, row.server)) return;
+      setActiveSessionKey(session.id);
+      navigation++;
+      setFocused(false);
+      return options.openAgent?.(row, source);
+    },
+    openSelectedSession: (name: string, source: "keyboard" | "mouse", key?: string) =>
+      open(manager.snapshot().selectedMachineId, name, source, true, undefined, undefined, key),
     automaticOpen: manager.snapshot().machines.length === 1,
     automaticOpenAllowed: () =>
       navigation === 0 && manager.snapshot().selectedMachineId === "local",
@@ -262,7 +404,18 @@ export function createApplicationMachineNavigation(options: {
         options.setNote("That session is unavailable or has been replaced.");
         return;
       }
-      if (await open(group.id, session.name, "keyboard", false)) historyIndex = next;
+      if (
+        await open(
+          group.id,
+          session.name,
+          "keyboard",
+          false,
+          session.liveSessionId,
+          session.server,
+          session.id,
+        )
+      )
+        historyIndex = next;
     },
     cycleTab(direction: -1 | 1, close = false) {
       const value = tabs.snapshot();
@@ -276,10 +429,22 @@ export function createApplicationMachineNavigation(options: {
       if (target) void tabs.activate(target.key);
     },
     closeSwitcher: () => setSwitching(false),
+    switcherFilter: (command: ApplicationPaletteCommand) => {
+      const focus = serverFocus();
+      return (
+        !focus ||
+        (typeof command === "object" &&
+          command.fleet?.machineId === focus.machineId &&
+          command.fleet?.server?.serverId === focus.server.serverId &&
+          command.fleet?.server?.generation === focus.server.generation)
+      );
+    },
     paletteCommands(): readonly ApplicationPaletteCommand[] {
       const groupsById = new Map(agentGroups().map((group) => [group.machineId, group]));
       return snapshot().groups.flatMap((group) => {
-        const agentGroup = groupsById.get(group.id);
+        const agentGroup = !group.sessions.some((session) => isDefaultSession(group.id, session))
+          ? undefined
+          : groupsById.get(group.id);
         const agentsBySession = new Map<string, ApplicationMachineAgent[]>();
         for (const agent of agentGroup?.agents ?? []) {
           if (!agent.liveSessionId || !agent.paneId) continue;
@@ -297,20 +462,25 @@ export function createApplicationMachineNavigation(options: {
               ? saved().recent.indexOf(session.id)
               : 1000,
             liveSessionId: session.liveSessionId,
-            hostLabel: group.label,
-            agentActivities: agentGroup?.available
-              ? (agentsBySession.get(session.liveSessionId) ?? []).map((a) => ({
-                  paneId: a.paneId!,
-                  attention: a.attention,
-                  activity: a.activity,
-                }))
-              : undefined,
+            server: session.server,
+            hostLabel: `${group.label}${session.serverLabel ? ` / ${session.serverLabel}` : ""}`,
+            agentActivities:
+              isDefaultSession(group.id, session) && agentGroup?.available
+                ? (agentsBySession.get(session.liveSessionId) ?? []).map((a) => ({
+                    paneId: a.paneId!,
+                    attention: a.attention,
+                    activity: a.activity,
+                  }))
+                : undefined,
             daemonInstanceId: daemon?.instanceId ?? "",
             disabled: session.disabled || group.state !== "ready",
           };
           return [
             { kind: "open-session", sessionName: session.name, label: session.name, fleet },
-            ...(agentsBySession.get(session.liveSessionId) ?? []).map((a) => ({
+            ...(isDefaultSession(group.id, session)
+              ? (agentsBySession.get(session.liveSessionId) ?? [])
+              : []
+            ).map((a) => ({
               kind: "jump-agent" as const,
               sessionName: session.name,
               paneId: a.paneId!,
@@ -332,6 +502,21 @@ export function createApplicationMachineNavigation(options: {
               disabled: group.state !== "ready",
             },
           },
+          ...(group.servers ?? []).map((server) => ({
+            kind: "open-machine" as const,
+            sessionName: "" as const,
+            label: `${server.label} · ${server.serverId.slice(-6)} · New session ^N`,
+            fleet: {
+              machineId: group.id,
+              hostLabel: `${group.label} / ${server.label}`,
+              liveSessionId: "",
+              daemonInstanceId: daemon?.instanceId ?? "",
+              disabled: group.state !== "ready" || server.state !== "online",
+              ...(server.state === "online"
+                ? { server: { serverId: server.serverId, generation: server.generation } }
+                : {}),
+            },
+          })),
           ...sessions,
         ];
       });
@@ -341,7 +526,12 @@ export function createApplicationMachineNavigation(options: {
       const target = command.fleet;
       const session = snapshot()
         .groups.find((g) => g.id === target.machineId)
-        ?.sessions.find((s) => s.liveSessionId === target.liveSessionId);
+        ?.sessions.find(
+          (s) =>
+            s.liveSessionId === target.liveSessionId &&
+            s.server?.serverId === target.server?.serverId &&
+            s.server?.generation === target.server?.generation,
+        );
       if (session)
         preferences.change({
           type: "favorite",
@@ -357,6 +547,22 @@ export function createApplicationMachineNavigation(options: {
       if (!target) return;
       const handle = manager.getMachine(target.machineId);
       if (command.kind === "open-machine") {
+        if (target.server) {
+          const descriptor = snapshot()
+            .groups.find((group) => group.id === target.machineId)
+            ?.servers?.find(
+              (server) =>
+                server.serverId === target.server?.serverId &&
+                server.generation === target.server.generation &&
+                server.state === "online",
+            );
+          if (!descriptor || handle?.read()?.instanceId !== target.daemonInstanceId) {
+            options.setNote("That server has changed. Select it again.");
+            return;
+          }
+          sidebar.onSelectServer?.(target.machineId, target.server);
+          return;
+        }
         if (
           handle?.endpoint().state === "ready" &&
           handle.read()?.instanceId === target.daemonInstanceId
@@ -369,7 +575,11 @@ export function createApplicationMachineNavigation(options: {
         (g) => g.id === target.machineId || g.routeIds?.includes(target.machineId),
       );
       const session = group?.sessions.find(
-        (s) => s.liveSessionId === target.liveSessionId && !s.disabled,
+        (s) =>
+          s.liveSessionId === target.liveSessionId &&
+          !s.disabled &&
+          s.server?.serverId === target.server?.serverId &&
+          s.server?.generation === target.server?.generation,
       );
       if (
         !session ||
@@ -381,7 +591,15 @@ export function createApplicationMachineNavigation(options: {
       }
       if (command.kind === "jump-agent")
         sidebar.onOpenAgent?.(target.machineId, session.name, command.paneId, source);
-      else await open(target.machineId, session.name, source, true, target.liveSessionId);
+      else
+        await open(
+          target.machineId,
+          session.name,
+          source,
+          true,
+          target.liveSessionId,
+          target.server,
+        );
     },
     adding,
     alias,
@@ -433,16 +651,47 @@ export function createApplicationMachineNavigation(options: {
         setError(cause instanceof Error ? cause.message : "Could not add this machine.");
       }
     },
-    start(target: string | null) {
+    start(target: string | null, serverId?: string | null) {
       agents.start();
       catalog.start();
-      if (!target) return;
+      if (!target && !serverId) return;
       const id = manager.snapshot().selectedMachineId;
       const token = navigation;
+
+      let machineReady = false;
+      const attempt = () => {
+        if (!machineReady) return;
+        if (token !== navigation) {
+          attemptStartup = null;
+          return;
+        }
+        const group = snapshot().groups.find((group) => group.id === id);
+        if (group?.state !== "ready") return;
+        const matches = group.sessions.filter(
+          (row) =>
+            !row.disabled &&
+            (!serverId || row.server?.serverId === serverId) &&
+            (!target || row.name === target),
+        );
+        if (matches.length !== 1) {
+          options.setNote(
+            matches.length
+              ? "Select a session under the requested tmux server."
+              : "Requested server or session is unavailable. Select it again.",
+          );
+          attemptStartup = null;
+          return;
+        }
+        const row = matches[0]!;
+        attemptStartup = null;
+        void open(id, row.name, "keyboard", true, row.liveSessionId, row.server, row.id);
+      };
+      attemptStartup = attempt;
       void manager.getMachine(id)?.ready.then((ready) => {
-        if (ready && token === navigation && manager.snapshot().selectedMachineId === id)
-          void open(id, target, "keyboard");
+        machineReady = ready;
+        attemptStartup?.();
       });
+      attempt();
     },
   };
 }

package/packages/daemon/src/tui/mirror/runtime/application-machine-overlays.tsx

@@ -17,7 +17,7 @@ export function ApplicationMachineOverlays(props: {
           open={true}
           attentionOnly={props.machines.attentionOnly()}
           rows={[]}
-          commands={props.machines.paletteCommands()}
+          commands={props.machines.paletteCommands().filter(props.machines.switcherFilter)}
           onActivate={(c) => {
             if (typeof c === "object") void props.machines.openPalette(c, "keyboard");
           }}