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

package/packages/daemon/src/tui/mirror/runtime/application-route-connection.ts

@@ -1,3 +1,9 @@
+import {
+  listTmuxServers,
+  createTmuxServerClient,
+} from "@tmux-ide/daemon-client/tmux-server-client";
+import { canonicalDaemonUrl } from "../../../lib/canonical-daemon.ts";
+import type { TmuxServerScope } from "@tmux-ide/contracts";
 import { fetchCanonicalLiveWorkspaceRouting } from "../canonical-workspace-routing.ts";
 import type { ApplicationMachineAuthorityHandle } from "./application-machine-authority.ts";
 import { prepareOpenTuiApplicationShellConnection } from "../application-shell-daemon-connection.ts";
@@ -8,14 +14,100 @@ export function applicationRouteConnection(
   handle: ApplicationMachineAuthorityHandle,
   expectedLiveSessionId?: string,
   onDiagnostic?: (phase: string, details: Readonly<Record<string, unknown>>) => void,
+  server?: TmuxServerScope,
 ) {
+  let rootInstanceId = handle.read()?.instanceId;
+  let selectedServer = server;
+  let refresh: { root: string; promise: Promise<TmuxServerScope> } | null = null;
+  const refreshAfterDaemonReplacement = async (nextRoot: string): Promise<TmuxServerScope> => {
+    if (!selectedServer) throw new Error("Select the server session again");
+    if (rootInstanceId === nextRoot) return selectedServer;
+    if (!expectedLiveSessionId) throw new Error("Select the server session again");
+    if (refresh?.root === nextRoot) return refresh.promise;
+    const stableServerId = selectedServer.serverId;
+    const promise = (async () => {
+      const daemon = handle.read();
+      const epoch = handle.endpoint()?.epoch;
+      if (!daemon?.authToken || daemon.instanceId !== nextRoot)
+        throw new Error("Daemon changed during reconnect");
+      const options = {
+        baseUrl: canonicalDaemonUrl("http", daemon.bindHostname, daemon.port),
+        ownerToken: daemon.authToken,
+        hostClientId: `opentui-reconnect:${process.pid}`,
+        origin: "tmux-ide://opentui",
+      };
+      const catalog = await listTmuxServers(options);
+      const descriptor = catalog.servers.find((candidate) => candidate.serverId === stableServerId);
+      if (!descriptor || descriptor.state !== "online")
+        throw new Error("Selected tmux server is unavailable");
+      const scope = { serverId: descriptor.serverId, generation: descriptor.generation };
+      const client = createTmuxServerClient(options, scope);
+      try {
+        const sessions = await client.sessions();
+        if (!sessions.sessions.some((session) => session.liveSessionId === expectedLiveSessionId))
+          throw new Error("Selected tmux session was replaced");
+      } finally {
+        client.dispose();
+      }
+      if (handle.read()?.instanceId !== nextRoot || handle.endpoint()?.epoch !== epoch)
+        throw new Error("Daemon changed during reconnect");
+      rootInstanceId = nextRoot;
+      selectedServer = scope;
+      return scope;
+    })();
+    refresh = { root: nextRoot, promise };
+    try {
+      return await promise;
+    } finally {
+      if (refresh?.promise === promise) refresh = null;
+    }
+  };
   return {
     readDaemon: handle.read,
-    observeCanonicalGeneration: handle.observe,
+    observeCanonicalGeneration: server
+      ? async (listener: (generation: string | null) => void) => {
+          let stopped = false;
+          let revision = 0;
+          const stop = await handle.observe((generation) => {
+            const token = ++revision;
+            if (!generation) {
+              listener(null);
+              return;
+            }
+            if (generation === rootInstanceId) {
+              listener(selectedServer!.generation);
+              return;
+            }
+            // Retire old input before reading the replacement daemon's registration.
+            listener(null);
+            void refreshAfterDaemonReplacement(generation).then(
+              (scope) => {
+                if (!stopped && token === revision && handle.read()?.instanceId === generation)
+                  listener(scope.generation);
+              },
+              () => {
+                if (!stopped && token === revision) listener(null);
+              },
+            );
+          });
+          return () => {
+            stopped = true;
+            revision++;
+            stop();
+          };
+        }
+      : handle.observe,
     resolveConnection: async (sessionName: string) => {
+      if (selectedServer) {
+        const currentRoot = handle.read()?.instanceId;
+        if (!currentRoot) return null;
+        await refreshAfterDaemonReplacement(currentRoot);
+      }
       const connection = await prepareOpenTuiApplicationShellConnection(sessionName, {
         ...(onDiagnostic ? { onDiagnostic } : {}),
+        ...(selectedServer ? { server: selectedServer, expectedLiveSessionId } : {}),
         readCanonicalDaemonInfo: handle.read,
+        readDaemonEndpoint: handle.endpoint,
         isCanonicalDaemonAlive: handle.isAlive,
         ensureSessionWorkspace: (name) =>
           ensureOpenTuiSessionWorkspaceResult(name, {

package/packages/daemon/src/tui/mirror/runtime/application-shell-catalog.tsx

@@ -71,6 +71,8 @@ export interface ApplicationCatalogShellProps {
   ) => void;
   readonly onCreateSession?: () => void;
   readonly onCycleTheme?: () => void;
+  readonly onOpenTutorial?: () => void;
+  readonly tutorialLabel?: string;
 }
 
 const CATALOG_VIEWS: readonly ShellChromeView[] = [
@@ -462,6 +464,8 @@ export function ApplicationCatalogShell(props: ApplicationCatalogShellProps): JS
                 onOpenTerminals={() => props.onOpenSurface("terminals", "mouse")}
                 onOpenCommands={() => props.onSetPaletteOpen(true, "mouse")}
                 onCycleTheme={props.onCycleTheme}
+                onOpenTutorial={props.onOpenTutorial}
+                tutorialLabel={props.tutorialLabel}
               />
             </Show>
           </box>

package/packages/daemon/src/tui/mirror/runtime/application-shell-home.tsx

@@ -35,7 +35,12 @@ export interface ApplicationHomeSurfaceProps {
   readonly theme: SemanticThemeSnapshot;
   readonly onOpenTerminals: () => void;
   readonly onOpenCommands: () => void;
+  readonly onOpenTutorial?: () => void;
+  readonly tutorialLabel?: string;
   readonly onCycleTheme?: () => void;
+  readonly agentFilterLabel?: string;
+  readonly onCycleAgentMachine?: () => void;
+  readonly onToggleAgentAttention?: () => void;
   readonly agentRoster?: HomeAgentSnapshot;
   readonly recentPaneActivity?: readonly InteractionReceipt[];
   readonly agentSelection?: HomeAgentSelectionSnapshot;
@@ -74,10 +79,11 @@ export function ApplicationHomeSurface(props: ApplicationHomeSurfaceProps): JSX.
     naturalButtonWidth("Open terminals", "F2") +
       naturalButtonWidth("Commands", "F5") +
       (props.onCycleTheme ? naturalButtonWidth(themeLabel()) + 2 : 0) +
+      (props.onOpenTutorial ? naturalButtonWidth(props.tutorialLabel ?? "Learn tmux-ide") + 2 : 0) +
       2;
   const reservedRows = () =>
     (spacious() ? 4 : 2) +
-    (actionsInRow() ? 1 : props.onCycleTheme ? 3 : 2) +
+    (actionsInRow() ? 1 : 2 + (props.onCycleTheme ? 1 : 0) + (props.onOpenTutorial ? 1 : 0)) +
     (spacious() ? 1 : 0) +
     (props.note ? (spacious() ? 2 : 1) : 0);
   const recentActivity = () =>
@@ -156,6 +162,9 @@ export function ApplicationHomeSurface(props: ApplicationHomeSurfaceProps): JSX.
         >
           {(snapshot) => (
             <HomeAgentRoster
+              filterLabel={props.agentFilterLabel}
+              onCycleMachine={props.onCycleAgentMachine}
+              onToggleAttention={props.onToggleAgentAttention}
               theme={props.theme}
               width={bodyWidth()}
               height={rosterHeight()}
@@ -220,6 +229,16 @@ export function ApplicationHomeSurface(props: ApplicationHomeSurfaceProps): JSX.
             width={buttonWidth("Commands", "F5")}
             onPress={props.onOpenCommands}
           />
+          <Show when={props.onOpenTutorial}>
+            {(open) => (
+              <TuiButton
+                theme={props.theme}
+                label={props.tutorialLabel ?? "Learn tmux-ide"}
+                width={buttonWidth(props.tutorialLabel ?? "Learn tmux-ide")}
+                onPress={open()}
+              />
+            )}
+          </Show>
           <Show when={props.onCycleTheme}>
             {(onCycleTheme) => (
               <TuiButton

package/packages/daemon/src/tui/mirror/runtime/application-shell-view.tsx

@@ -117,12 +117,16 @@ export interface ApplicationShellViewProps {
   readonly onCreateWindow?: () => void;
   readonly onCreateSession?: () => void;
   readonly onCycleTheme?: () => void;
+  readonly onOpenTutorial?: () => void;
+  readonly tutorialLabel?: string;
   readonly onBeginPaneRename?: (paneId: string, currentName: string) => void;
   readonly onCancelPaneRename?: () => void;
   readonly onSubmitPaneRename?: () => void;
   readonly onDismissNotification?: () => void;
   readonly paletteCloseArmed?: Accessor<boolean>;
   readonly onSelectPane: TerminalWorkspaceProps["onSelectPane"];
+  readonly onSelectWindowLink?: TerminalWorkspaceProps["onSelectWindowLink"];
+  readonly onUnlinkWindowLink?: TerminalWorkspaceProps["onUnlinkWindowLink"];
   readonly onResizePreview: TerminalWorkspaceProps["onResizePreview"];
   readonly onResizePane: TerminalWorkspaceProps["onResizePane"];
   readonly onCancelResize?: TerminalWorkspaceProps["onCancelResize"];
@@ -268,6 +272,8 @@ export function ApplicationShellView(props: ApplicationShellViewProps): JSX.Elem
           onPaletteActivate={props.onPaletteActivate}
           onCreateSession={props.onCreateSession}
           onCycleTheme={props.onCycleTheme}
+          onOpenTutorial={props.onOpenTutorial}
+          tutorialLabel={props.tutorialLabel}
         />
       }
     >
@@ -454,6 +460,8 @@ export function ApplicationShellView(props: ApplicationShellViewProps): JSX.Elem
                   onOpenTerminals={() => props.onOpenSurface("terminals", "mouse")}
                   onOpenCommands={() => props.onSetPaletteOpen(true, "mouse")}
                   onCycleTheme={props.onCycleTheme}
+                  onOpenTutorial={props.onOpenTutorial}
+                  tutorialLabel={props.tutorialLabel}
                 />
               </Show>
               <box
@@ -509,6 +517,8 @@ export function ApplicationShellView(props: ApplicationShellViewProps): JSX.Elem
                       agentIndicators={agentIndicators}
                       paneInteractions={props.paneInteractions}
                       onSelectPane={props.onSelectPane}
+                      onSelectWindowLink={props.onSelectWindowLink}
+                      onUnlinkWindowLink={props.onUnlinkWindowLink}
                       onCreateWindow={props.onCreateWindow}
                       onPaneContextAction={(paneId, action, currentName) => {
                         if (action === "rename-pane")

package/packages/daemon/src/tui/mirror/runtime/application-terminal-interaction-controller.ts

@@ -1,6 +1,8 @@
+import { WorkspaceWindowLinkSelectResultSchemaZ } from "@tmux-ide/contracts";
+import { windowLinkForPane, windowLinkTarget } from "./application-terminal-workspace-policy.ts";
 import { createHash, randomUUID } from "node:crypto";
 import type { Accessor, Setter } from "solid-js";
-import type { SessionRuntimeTerminalInput } from "@tmux-ide/contracts";
+import type { WindowLinkTarget, SessionRuntimeTerminalInput } from "@tmux-ide/contracts";
 import {
   currentTuiPerformanceEventSink,
   type TuiTerminalInputOrigin,
@@ -79,6 +81,8 @@ export interface ApplicationTerminalInteractionController {
   adoptGeneration(snapshot: OpenTuiGenerationHostSnapshot | null): void;
   adoptLayout(snapshot: OpenTuiWorkspaceLayoutSnapshot): void;
   selectPane(paneId: string): void;
+  selectWindowLink(target: WindowLinkTarget): Promise<void>;
+  unlinkWindowLink(target: WindowLinkTarget): Promise<string>;
   sendInput(
     input: SessionRuntimeTerminalInput,
     parserOrigin?: Omit<
@@ -628,6 +632,41 @@ export function createApplicationTerminalInteractionController(
     }
   };
 
+  let linkSelection: {
+    target: WindowLinkTarget;
+    paneId: string;
+    layout: OpenTuiWorkspaceLayoutSnapshot;
+    received: boolean;
+    resolve: (selected: boolean) => void;
+    timer: ReturnType<typeof setTimeout>;
+  } | null = null;
+  const finishLinkSelection = (selected: boolean) => {
+    const pending = linkSelection;
+    if (!pending) return;
+    linkSelection = null;
+    clearTimeout(pending.timer);
+    pending.resolve(selected);
+  };
+  const reconcileLinkSelection = (snapshot: OpenTuiWorkspaceLayoutSnapshot) => {
+    const pending = linkSelection;
+    if (!pending) return;
+    pending.layout = snapshot;
+    const observed = windowLinkTarget(snapshot, pending.target.linkId);
+    if (
+      !observed ||
+      observed.linkRevision !== pending.target.linkRevision ||
+      observed.liveSessionId !== pending.target.liveSessionId ||
+      observed.expectedSemanticWindowId !== pending.target.expectedSemanticWindowId
+    ) {
+      finishLinkSelection(false);
+      return;
+    }
+    if (!pending.received || snapshot.windowLinks?.activeLinkId !== pending.target.linkId) return;
+    finishLinkSelection(
+      snapshot.current !== null && paneForWindow(snapshot.current) === pending.paneId,
+    );
+  };
+
   const paneInput = new TerminalPaneInputRouter<{
     readonly input: SessionRuntimeTerminalInput;
     readonly parserOrigin?: Omit<
@@ -636,6 +675,7 @@ export function createApplicationTerminalInteractionController(
     >;
   }>({
     select: async (paneId) => {
+      finishLinkSelection(false);
       const expected = liveSelectionTarget();
       const selecting = pendingWindowSwitch;
       const operationId = selecting?.traceId;
@@ -649,6 +689,7 @@ export function createApplicationTerminalInteractionController(
             (failure) => {
               selectionFailure.current = failure;
             },
+            windowLinkForPane(options.layout(), paneId) ?? undefined,
           )
         : null;
       if (selecting && pendingWindowSwitch === selecting) {
@@ -833,6 +874,7 @@ export function createApplicationTerminalInteractionController(
           next.fastLane !== inputAuthorityIdentity.fastLane ||
           next.adapter !== inputAuthorityIdentity.adapter);
       if (next === null || replaced) {
+        finishLinkSelection(false);
         paneInput.invalidateSelection();
         pendingWindowSwitch = null;
         pendingWindowRename = null;
@@ -846,6 +888,7 @@ export function createApplicationTerminalInteractionController(
       inputAuthorityIdentity = next;
     },
     adoptLayout(snapshot) {
+      reconcileLinkSelection(snapshot);
       paneInput.adoptCanonicalPane(snapshot.current ? paneForWindow(snapshot.current) : null);
       const currentWindow = snapshot.current?.semanticWindowId ?? snapshot.current?.windowName;
       const currentPane = snapshot.current ? paneForWindow(snapshot.current) : null;
@@ -933,7 +976,130 @@ export function createApplicationTerminalInteractionController(
       maybeRequestWindowSwitchFrame();
       maybeRequestPaneResizeFrame();
     },
-    selectPane: (paneId) => paneInput.selectPane(paneId),
+    selectPane: (paneId) => {
+      finishLinkSelection(false);
+      paneInput.selectPane(paneId);
+    },
+    async unlinkWindowLink(target) {
+      const expected = liveSelectionTarget();
+      const observed = windowLinkTarget(options.layout(), target.linkId);
+      if (
+        !expected ||
+        !observed ||
+        observed.liveSessionId !== target.liveSessionId ||
+        observed.linkRevision !== target.linkRevision ||
+        observed.expectedSemanticWindowId !== target.expectedSemanticWindowId
+      )
+        return "Window link changed; reopen its menu";
+      try {
+        if (
+          !expected.client.ownsRuntimeAuthority?.("input") &&
+          !(await expected.client.requestAuthority("input"))
+        )
+          return "Window unlink requires input control";
+        const current = liveSelectionTarget();
+        if (
+          current?.client !== expected.client ||
+          current.daemonGeneration !== expected.daemonGeneration
+        )
+          return "Session changed; reopen the window menu";
+        await expected.client.dispatch({
+          kind: "semantic-intent",
+          intent: {
+            verb: "workspace.window.link.unlink",
+            workspaceName: expected.workspaceName,
+            target,
+          },
+        });
+        return "Window link removed";
+      } catch {
+        return "Window link could not be removed; it may be the last link or have changed";
+      }
+    },
+    async selectWindowLink(target) {
+      const expected = liveSelectionTarget();
+      const snapshot = options.layout();
+      const observed = windowLinkTarget(snapshot, target.linkId);
+      const backing = snapshot.windows.find(
+        (window) => window.semanticWindowId === target.expectedSemanticWindowId,
+      );
+      const paneId = backing && paneForWindow(backing);
+      if (
+        !expected ||
+        !paneId ||
+        !observed ||
+        observed.liveSessionId !== target.liveSessionId ||
+        observed.linkRevision !== target.linkRevision ||
+        observed.expectedSemanticWindowId !== target.expectedSemanticWindowId
+      )
+        return;
+      finishLinkSelection(false);
+      let resolve!: (selected: boolean) => void;
+      const settled = new Promise<boolean>((done) => {
+        resolve = done;
+      });
+      const pending = {
+        target,
+        paneId,
+        layout: snapshot,
+        received: false,
+        resolve,
+        timer: setTimeout(() => {
+          if (linkSelection === pending) finishLinkSelection(false);
+        }, 5_000),
+      };
+      pending.timer.unref?.();
+      linkSelection = pending;
+      // Register input ordering synchronously, before authority or command awaits.
+      paneInput.selectPane(paneId, { presentOptimistically: false, selection: () => settled });
+      try {
+        if (
+          !expected.client.ownsRuntimeAuthority?.("input") &&
+          !(await expected.client.requestAuthority("input"))
+        ) {
+          if (linkSelection === pending) finishLinkSelection(false);
+          return;
+        }
+        const current = liveSelectionTarget();
+        if (
+          linkSelection !== pending ||
+          current?.client !== expected.client ||
+          current.daemonGeneration !== expected.daemonGeneration
+        ) {
+          if (linkSelection === pending) finishLinkSelection(false);
+          return;
+        }
+        const wrapper = (await expected.client.dispatch({
+          kind: "semantic-intent",
+          intent: {
+            verb: "workspace.window.link.select",
+            workspaceName: expected.workspaceName,
+            target,
+          },
+        })) as { kind?: string; operationId?: string; result?: unknown };
+        const result = WorkspaceWindowLinkSelectResultSchemaZ.safeParse(wrapper.result);
+        if (linkSelection !== pending) return;
+        if (
+          wrapper.kind !== "semantic-intent" ||
+          !result.success ||
+          result.data.operationId !== wrapper.operationId ||
+          result.data.daemonInstanceId !== expected.daemonGeneration ||
+          result.data.workspaceName !== expected.workspaceName ||
+          result.data.target.linkId !== target.linkId ||
+          result.data.target.liveSessionId !== target.liveSessionId ||
+          result.data.target.linkRevision !== target.linkRevision ||
+          result.data.target.expectedSemanticWindowId !== target.expectedSemanticWindowId
+        ) {
+          finishLinkSelection(false);
+          return;
+        }
+        pending.received = true;
+        reconcileLinkSelection(pending.layout);
+        await settled;
+      } catch {
+        if (linkSelection === pending) finishLinkSelection(false);
+      }
+    },
     sendInput: async (input, parserOrigin) => {
       await paneInput.sendInput({ input, parserOrigin });
     },
@@ -1152,6 +1318,15 @@ export function createApplicationTerminalInteractionController(
       if (next) paneInput.selectPane(next);
     },
     cycleWindow() {
+      const topology = options.layout().windowLinks;
+      if (topology) {
+        if (topology.links.length < 2) return;
+        const current = topology.links.findIndex((link) => link.linkId === topology.activeLinkId);
+        const next = topology.links[(current + 1) % topology.links.length]!;
+        const target = windowLinkTarget(options.layout(), next.linkId);
+        if (target) void this.selectWindowLink(target);
+        return;
+      }
       const windows = options.layout().windows;
       if (windows.length < 2) return;
       const current = windows.findIndex((window) => window.currentWindow);

package/packages/daemon/src/tui/mirror/runtime/application-terminal-workspace-policy.ts

@@ -1,3 +1,4 @@
+import type { WindowLinkTarget } from "@tmux-ide/contracts";
 import type { AgentActivity } from "@tmux-ide/contracts";
 
 import type { OpenTuiWorkspaceLayoutSnapshot } from "../open-tui-workspace-runtime-port.ts";
@@ -309,3 +310,64 @@ export function terminalPaneResizePreview(
           }),
   });
 }
+
+/** Resolve only live opaque observations; native indexes are display metadata. */
+export function windowLinkTarget(
+  snapshot: OpenTuiWorkspaceLayoutSnapshot,
+  linkId: string,
+): WindowLinkTarget | null {
+  const topology = snapshot.windowLinks;
+  const link = topology?.links.find((candidate) => candidate.linkId === linkId);
+  if (!topology || !link) return null;
+  return {
+    liveSessionId: topology.liveSessionId,
+    linkRevision: topology.linkRevision,
+    linkId: link.linkId,
+    expectedSemanticWindowId: link.semanticWindowId,
+  };
+}
+
+/** Pane navigation within the active link must not silently choose a sibling link. */
+export function windowLinkForPane(
+  snapshot: OpenTuiWorkspaceLayoutSnapshot,
+  paneId: string,
+): WindowLinkTarget | null {
+  const backing = snapshot.windows.find((window) =>
+    window.panes.some((pane) => pane.pane === paneId),
+  );
+  const topology = snapshot.windowLinks;
+  if (!backing || !topology) return null;
+  const links = topology.links.filter((link) => link.semanticWindowId === backing.semanticWindowId);
+  const link =
+    links.find((candidate) => candidate.linkId === topology.activeLinkId) ??
+    (links.length === 1 ? links[0] : undefined);
+  return link ? windowLinkTarget(snapshot, link.linkId) : null;
+}
+
+/** Root composition for backing zoom and link actions, all restoring host focus. */
+export function terminalWindowActionCallbacks(
+  controller: Pick<
+    import("./application-terminal-interaction-controller.ts").ApplicationTerminalInteractionController,
+    "selectWindowLink" | "unlinkWindowLink" | "zoomPane" | "selectPane"
+  >,
+  notify: (message: string) => void,
+  recover: import("./application-host-focus-presentation.ts").ApplicationHostFocusRecovery,
+  cancelNavigation: () => void,
+) {
+  return {
+    onSelectPane: recover((paneId: string) => {
+      cancelNavigation();
+      controller.selectPane(paneId);
+    }),
+    onZoomPane: recover((paneId?: string) => {
+      void controller.zoomPane(paneId).then(notify);
+    }),
+    onSelectWindowLink: recover((target: WindowLinkTarget) => {
+      cancelNavigation();
+      void controller.selectWindowLink(target);
+    }),
+    onUnlinkWindowLink: recover((target: WindowLinkTarget) => {
+      void controller.unlinkWindowLink(target).then(notify);
+    }),
+  };
+}