tmux-ide 2.7.0 → 2.9.0-beta.11

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

@@ -0,0 +1,140 @@
+import { createSignal, onCleanup } from "solid-js";
+import { applicationMachineAuthorityManager as manager } from "./application-machine-authority.ts";
+import { createApplicationMachineCatalog } from "./application-machine-catalog.ts";
+import { ephemeralMachineProfile } from "./application-machine-startup.ts";
+import type { ApplicationMachineSidebarModel } from "./application-machine-sidebar.tsx";
+
+export function createApplicationMachineNavigation(options: {
+  resetWorkspace(): void;
+  cancelOpen(): void;
+  openSession(name: string, source: "keyboard" | "mouse"): Promise<unknown>;
+  sessionName(): string | null;
+  setSurface(value: "home" | "terminals"): void;
+  setNote(value: string | null): void;
+}) {
+  const catalog = createApplicationMachineCatalog();
+  const [snapshot, setSnapshot] = createSignal(catalog.getSnapshot());
+  const [focused, setFocused] = createSignal(false);
+  const [adding, setAdding] = createSignal(false);
+  const [alias, setAlias] = createSignal("");
+  const [error, setError] = createSignal<string | null>(null);
+  const stop = catalog.subscribe(setSnapshot);
+  let navigation = 0;
+  const select = (id: string) => {
+    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();
+      manager.select(id);
+    }
+    return true;
+  };
+  const open = async (id: string, name: string, source: "keyboard" | "mouse") => {
+    if (!select(id)) return;
+    const token = ++navigation;
+    setFocused(false);
+    options.setSurface("terminals");
+    if (manager.getMachine(id)?.endpoint().state !== "ready") {
+      options.setNote(
+        "This machine is disconnected. Its sessions will become available when it reconnects.",
+      );
+      return;
+    }
+    if (token !== navigation) return;
+    await options.openSession(name, source);
+  };
+  const sidebar: ApplicationMachineSidebarModel = {
+    groups: () => snapshot().groups,
+    activeMachineId: () => snapshot().selectedMachineId,
+    activeSessionName: options.sessionName,
+    focused,
+    onFocus: () => {
+      navigation++;
+      options.cancelOpen();
+      setFocused(true);
+    },
+    onBlur: () => setFocused(false),
+    onOpen: (id, name, source) => void open(id, name, source),
+    onSelectMachine: (id) => {
+      navigation++;
+      options.cancelOpen();
+      if (select(id)) {
+        options.setSurface("home");
+        options.setNote(null);
+      }
+    },
+    onAddMachine: () => {
+      navigation++;
+      options.cancelOpen();
+      setAlias("");
+      setError(null);
+      setAdding(true);
+    },
+  };
+  onCleanup(() => {
+    navigation++;
+    stop();
+    catalog.dispose();
+  });
+  return {
+    catalog,
+    automaticOpen: manager.snapshot().machines.length === 1,
+    automaticOpenAllowed: () =>
+      navigation === 0 && manager.snapshot().selectedMachineId === "local",
+    sidebar,
+    focused,
+    adding,
+    alias,
+    error,
+    setAlias,
+    label: () =>
+      snapshot().groups.find((g) => g.id === snapshot().selectedMachineId)?.label ?? "This machine",
+    isLocal: () => snapshot().selectedMachineId === "local",
+    focus: () => {
+      navigation++;
+      options.cancelOpen();
+      setFocused(true);
+    },
+    cancelAdd: () => {
+      setAdding(false);
+      setFocused(true);
+    },
+    add() {
+      try {
+        const target = alias().trim();
+        let existing = manager.snapshot().machines.find((m) => m.sshTarget === target);
+        if (!existing) {
+          const profiles = manager
+            .snapshot()
+            .machines.filter((m) => m.sshTarget)
+            .map((m) => ({
+              id: m.id,
+              label: m.label,
+              sshTarget: m.sshTarget!,
+              enabled: true,
+            }));
+          const profile = ephemeralMachineProfile(target, profiles);
+          manager.add(profile);
+          existing = manager.snapshot().machines.find((m) => m.id === profile.id);
+        }
+        setAdding(false);
+        if (existing) sidebar.onSelectMachine(existing.id, "keyboard");
+        setFocused(true);
+      } catch (cause) {
+        setError(cause instanceof Error ? cause.message : "Could not add this machine.");
+      }
+    },
+    start(target: string | null) {
+      catalog.start();
+      if (!target) return;
+      const id = manager.snapshot().selectedMachineId;
+      const token = navigation;
+      void manager.getMachine(id)?.ready.then((ready) => {
+        if (ready && token === navigation && manager.snapshot().selectedMachineId === id)
+          void open(id, target, "keyboard");
+      });
+    },
+  };
+}

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

@@ -0,0 +1,248 @@
+/* @jsxImportSource @opentui/solid */
+import type { ScrollBoxRenderable } from "@opentui/core";
+import { For, createEffect, createMemo, createSignal, type Accessor, type JSX } from "solid-js";
+import { friendlySessionLabel } from "../terminal-text.ts";
+import type { SemanticThemeSnapshot } from "../theme.ts";
+import { NavigationRow } from "../ui/navigation-row.tsx";
+import { Surface } from "../ui/surface.tsx";
+import { useKeyboardRoute } from "../ui/keyboard-router.tsx";
+
+export interface ApplicationMachineGroup {
+  readonly id: string;
+  readonly label: string;
+  readonly state: "ready" | "connecting" | "disconnected";
+  readonly sessions: readonly {
+    readonly id: string;
+    readonly name: string;
+    readonly paneCount: number;
+    readonly disabled?: boolean;
+  }[];
+}
+export interface ApplicationMachineSidebarModel {
+  readonly groups: Accessor<readonly ApplicationMachineGroup[]>;
+  readonly activeMachineId: Accessor<string | null>;
+  readonly activeSessionName: Accessor<string | null>;
+  readonly onOpen: (machineId: string, sessionName: string, source: "keyboard" | "mouse") => void;
+  readonly onSelectMachine: (machineId: string, source: "keyboard" | "mouse") => void;
+  readonly onAddMachine?: () => void;
+  readonly focused?: Accessor<boolean>;
+  readonly onFocus?: () => void;
+  readonly onBlur?: () => void;
+}
+
+type Row = {
+  key: string;
+  group: ApplicationMachineGroup;
+  session?: ApplicationMachineGroup["sessions"][number];
+};
+/** Pure machine navigation. All connection and session authority stays with the caller. */
+export function ApplicationMachineSidebar(props: {
+  readonly model: ApplicationMachineSidebarModel;
+  readonly width: number;
+  readonly height: number;
+  readonly theme: SemanticThemeSnapshot;
+  readonly agents?: JSX.Element;
+  readonly agentRows?: number;
+}) {
+  const [localFocused, setLocalFocused] = createSignal(false);
+  const focused = () => props.model.focused?.() ?? localFocused();
+  const [collapsed, setCollapsed] = createSignal<ReadonlySet<string>>(new Set());
+  const [selectedKey, setSelectedKey] = createSignal<string | null>(null);
+  let scroll: ScrollBoxRenderable | undefined;
+  const agentHeight = () =>
+    (props.agentRows ?? 0) > 0
+      ? Math.min((props.agentRows ?? 0) + 2, Math.max(0, Math.floor(props.height / 2)))
+      : 0;
+  const machineHeight = () =>
+    Math.max(0, props.height - 1 - (props.model.onAddMachine ? 1 : 0) - agentHeight());
+  const active = (row: Row) =>
+    row.group.id === props.model.activeMachineId() &&
+    row.session?.name === props.model.activeSessionName();
+  const rows = createMemo<readonly Row[]>(() =>
+    props.model
+      .groups()
+      .flatMap((group) => [
+        { key: JSON.stringify([group.id]), group },
+        ...group.sessions
+          .filter(
+            (session) =>
+              !collapsed().has(group.id) ||
+              (group.id === props.model.activeMachineId() &&
+                session.name === props.model.activeSessionName()),
+          )
+          .map((session) => ({ key: JSON.stringify([group.id, session.id]), group, session })),
+      ]),
+  );
+  const index = () =>
+    Math.max(
+      0,
+      rows().findIndex((row) => row.key === selectedKey()),
+    );
+  const toggle = (group: ApplicationMachineGroup, value = !collapsed().has(group.id)) => {
+    const next = new Set(collapsed());
+    if (value) next.add(group.id);
+    else next.delete(group.id);
+    setCollapsed(next);
+  };
+  const activate = (row: Row, source: "keyboard" | "mouse") => {
+    setSelectedKey(row.key);
+    setLocalFocused(true);
+    props.model.onFocus?.();
+    if (row.session) {
+      if (row.group.state === "ready" && !row.session.disabled)
+        props.model.onOpen(row.group.id, row.session.name, source);
+    } else if (row.group.state !== "ready" || row.group.sessions.length === 0)
+      props.model.onSelectMachine(row.group.id, source);
+    else toggle(row.group);
+  };
+  const revealFocusedRow = () => {
+    if (!focused() || !scroll) return;
+    const y = index();
+    const height = Math.max(1, machineHeight());
+    if (y < scroll.scrollTop) scroll.scrollTo(y);
+    else if (y >= scroll.scrollTop + height) scroll.scrollTo(y - height + 1);
+  };
+  createEffect(() => {
+    const list = rows();
+    if (!list.some((row) => row.key === selectedKey()))
+      setSelectedKey((list.find(active) ?? list[0])?.key ?? null);
+    revealFocusedRow();
+  });
+  useKeyboardRoute((event) => {
+    if (!focused() || event.eventType !== "press") return false;
+    const key = event.name.toLowerCase();
+    if (
+      ![
+        "up",
+        "down",
+        "home",
+        "end",
+        "left",
+        "right",
+        "enter",
+        "return",
+        "space",
+        "escape",
+        "a",
+      ].includes(key)
+    )
+      return false;
+    event.preventDefault();
+    event.stopPropagation();
+    if (key === "escape") {
+      setLocalFocused(false);
+      props.model.onBlur?.();
+      return true;
+    }
+    if (key === "a") {
+      props.model.onAddMachine?.();
+      return true;
+    }
+    const list = rows();
+    const row = list[index()];
+    if (!row) return true;
+    if (key === "up" || key === "down" || key === "home" || key === "end") {
+      const next =
+        key === "home"
+          ? 0
+          : key === "end"
+            ? list.length - 1
+            : Math.min(list.length - 1, Math.max(0, index() + (key === "up" ? -1 : 1)));
+      setSelectedKey(list[next]!.key);
+    } else if (key === "left" || key === "right") {
+      setSelectedKey(JSON.stringify([row.group.id]));
+      toggle(row.group, key === "left");
+    } else activate(row, "keyboard");
+    return true;
+  });
+  return (
+    <Surface
+      id="application-machine-sidebar"
+      theme={props.theme}
+      variant="panel"
+      width={props.width}
+      height={props.height}
+      flexShrink={0}
+      flexDirection="column"
+      overflow="hidden"
+    >
+      <text height={1} fg={props.theme.roles.text.secondary}>
+        {" "}
+        Machines
+      </text>
+      <scrollbox
+        ref={(value) => {
+          scroll = value;
+          const resized = value.content.onSizeChange;
+          value.content.onSizeChange = () => {
+            resized?.call(value.content);
+            revealFocusedRow();
+          };
+        }}
+        height={machineHeight()}
+        width={props.width}
+        scrollX={false}
+        scrollY={true}
+      >
+        <For each={rows()}>
+          {(row) => (
+            <NavigationRow
+              theme={props.theme}
+              id={`machine:${row.key}`}
+              width={Math.max(1, props.width - 1)}
+              label={row.session ? friendlySessionLabel(row.session.name) : row.group.label}
+              marker={
+                row.session
+                  ? active(row)
+                    ? " ›"
+                    : "  "
+                  : collapsed().has(row.group.id)
+                    ? "▸"
+                    : "▾"
+              }
+              detail={
+                row.session
+                  ? row.group.state !== "ready" || row.session.disabled
+                    ? "unavailable"
+                    : `${row.session.paneCount}p`
+                  : row.group.state === "ready"
+                    ? "ready"
+                    : row.group.state === "connecting"
+                      ? "connecting"
+                      : "offline"
+              }
+              selected={Boolean(row.session && active(row))}
+              focused={Boolean(focused() && row.key === selectedKey())}
+              onActivate={(source) => activate(row, source)}
+            />
+          )}
+        </For>
+      </scrollbox>
+      <For each={agentHeight() > 0 ? [true] : []}>
+        {() => (
+          <scrollbox
+            width={props.width}
+            height={agentHeight()}
+            scrollX={false}
+            scrollY={true}
+            horizontalScrollbarOptions={{ visible: false }}
+          >
+            {props.agents}
+          </scrollbox>
+        )}
+      </For>
+      <For each={props.model.onAddMachine ? [props.model.onAddMachine] : []}>
+        {(add) => (
+          <NavigationRow
+            theme={props.theme}
+            id="machine:add"
+            label="Add machine (A)"
+            marker="+"
+            width={props.width}
+            onActivate={add}
+          />
+        )}
+      </For>
+    </Surface>
+  );
+}

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

@@ -0,0 +1,39 @@
+import { randomUUID } from "node:crypto";
+import { SavedMachineSchema, type SavedMachine } from "@tmux-ide/contracts";
+import { loadSavedMachines } from "../../../lib/saved-machines.ts";
+import { applicationMachineAuthorityManager } from "./application-machine-authority.ts";
+
+/** Labels describe access routes; they never become routing identities. */
+export function ephemeralMachineProfile(
+  alias: string,
+  existing: readonly SavedMachine[],
+): SavedMachine {
+  const target = SavedMachineSchema.shape.sshTarget.parse(alias);
+  const base = target.slice(0, 70);
+  const labels = new Set([
+    "local",
+    "this mac",
+    "this machine",
+    ...existing.map((p) => p.label.normalize("NFKC").toLowerCase()),
+  ]);
+  let label = base;
+  for (let suffix = 2; labels.has(label.normalize("NFKC").toLowerCase()); suffix++)
+    label = `${base} (${suffix})`;
+  return SavedMachineSchema.parse({ id: randomUUID(), label, sshTarget: target, enabled: true });
+}
+
+/** Local discovery and rendering never wait for any remote handshake. */
+export function initializeApplicationMachines(aliases: readonly string[]): void {
+  const profiles = [...loadSavedMachines().machines];
+  let preferred: string | null = null;
+  for (const alias of aliases) {
+    let profile = profiles.find((p) => p.sshTarget === alias && p.enabled);
+    if (!profile) {
+      profile = ephemeralMachineProfile(alias, profiles);
+      profiles.push(profile);
+    }
+    preferred ??= profile.id;
+  }
+  applicationMachineAuthorityManager.initialize(profiles);
+  if (preferred) applicationMachineAuthorityManager.select(preferred);
+}

package/packages/daemon/src/tui/mirror/runtime/application-optional-features.ts

@@ -0,0 +1,25 @@
+import { OptionalFeatureRegistry } from "./optional-feature-registry.ts";
+
+export interface ApplicationOptionalFeatures {
+  readonly home: typeof import("../features/home/feature.tsx");
+  readonly files: typeof import("../features/files/feature.tsx");
+  readonly changes: typeof import("../features/changes/feature.tsx");
+  readonly missionsActivity: typeof import("../features/missions-activity/feature.tsx");
+  readonly dialogs: typeof import("../features/dialogs/feature.tsx");
+  readonly settings: typeof import("../features/settings/feature.ts");
+  readonly palette: typeof import("../features/palette/feature.ts");
+  readonly richPreview: typeof import("../features/rich-preview/feature.tsx");
+  readonly performanceHud: typeof import("../features/performance-hud/feature.tsx");
+}
+
+/** Literal imports keep each admitted module discoverable by Bun's compiler. */
+export function createApplicationOptionalFeatureRegistry(): OptionalFeatureRegistry<ApplicationOptionalFeatures> {
+  return new OptionalFeatureRegistry<ApplicationOptionalFeatures>({
+    home: () => import("../features/home/feature.tsx"),
+    dialogs: () => import("../features/dialogs/feature.tsx"),
+    settings: () => import("../features/settings/feature.ts"),
+    palette: () => import("../features/palette/feature.ts"),
+    richPreview: () => import("../features/rich-preview/feature.tsx"),
+    performanceHud: () => import("../features/performance-hud/feature.tsx"),
+  });
+}

package/packages/daemon/src/tui/mirror/runtime/application-palette-command-owner.ts

@@ -0,0 +1,162 @@
+import type { CommandSource } from "@tmux-ide/contracts";
+import { createSignal } from "solid-js";
+
+import type { ApplicationPaletteCommand } from "./application-palette-input.ts";
+import type { ApplicationShellBinding } from "./application-shell-binding.ts";
+import { applicationPaletteCommands } from "./application-palette-input.ts";
+import { createApplicationPaletteSearchOwner } from "./application-palette-search-owner.ts";
+
+type Source = "keyboard" | "mouse";
+
+export function createApplicationPaletteCommandOwner(options: {
+  readonly activeSurface: () => "home" | "terminals";
+  readonly binding: Pick<
+    ApplicationShellBinding,
+    "openSurface" | "setPaletteOpen" | "activatePaletteSurface"
+  >;
+  readonly commandSource: (
+    source: Source,
+    surface: "application-bar" | "command-palette",
+  ) => CommandSource;
+  readonly setSurface: (surface: "home" | "terminals") => void;
+  readonly setNote: (note: string | null) => void;
+  readonly openAppearance?: () => void;
+  readonly zoomPane?: () => Promise<string>;
+  readonly newWindow: () => Promise<string>;
+  readonly splitPane: (direction: "right" | "down") => Promise<string>;
+  readonly closePane: () => Promise<string>;
+  readonly openAgent: (sessionName: string, paneId: string, source: Source) => Promise<boolean>;
+  readonly openSession?: (sessionName: string, source: Source) => Promise<unknown> | void;
+  readonly onNavigationIntent?: () => void;
+  readonly commands?: () => readonly ApplicationPaletteCommand[];
+  readonly isOpen?: () => boolean;
+  readonly disabledReason?: (command: ApplicationPaletteCommand) => string | null;
+  readonly targetKey?: () => string;
+}) {
+  const [closeArmed, setCloseArmed] = createSignal(false);
+  const [busy, setBusy] = createSignal(false);
+  let armedTarget: string | undefined;
+  let openRevision = 0;
+  const search = createApplicationPaletteSearchOwner({
+    commands: options.commands ?? (() => applicationPaletteCommands(null)),
+    open: options.isOpen ?? (() => false),
+    activate: (command, source) => activate(command, source),
+    close: () => setOpen(false, "keyboard"),
+    onChange: () => setCloseArmed(false),
+  });
+  const setOpen = (open: boolean, source: Source): void => {
+    openRevision += 1;
+    setCloseArmed(false);
+    if (open) search.reset(options.activeSurface() === "home" ? 0 : 1);
+    void options.binding
+      .setPaletteOpen(open, options.commandSource(source, "command-palette"))
+      .catch(() => options.setNote("Commands could not be updated. Try again."));
+  };
+  const activate = (
+    command: ApplicationPaletteCommand,
+    source: Source,
+    confirmed = false,
+  ): void => {
+    if (busy()) return;
+    if (command === "appearance") {
+      setOpen(false, source);
+      options.openAppearance?.();
+      return;
+    }
+    const unavailable = options.disabledReason?.(command);
+    if (unavailable) {
+      setCloseArmed(false);
+      options.setNote(unavailable);
+      return;
+    }
+    if (typeof command === "object" && command.kind === "open-session") {
+      options.onNavigationIntent?.();
+      setCloseArmed(false);
+      setOpen(false, source);
+      if (!options.openSession) {
+        options.setNote("Session switching is unavailable.");
+        return;
+      }
+      try {
+        // Begin ingress ownership synchronously, before the next terminal key.
+        void Promise.resolve(options.openSession(command.sessionName, source)).catch(() => {
+          options.setNote("The selected session could not be opened.");
+        });
+      } catch {
+        options.setNote("The selected session could not be opened.");
+      }
+      return;
+    }
+    if (typeof command === "object" && command.kind === "jump-agent") {
+      options.onNavigationIntent?.();
+      setCloseArmed(false);
+      setOpen(false, source);
+      void options
+        .openAgent(command.sessionName, command.paneId, source)
+        .catch(() => options.setNote("The selected agent could not be opened."));
+      return;
+    }
+    if (command === "home" || command === "terminals") {
+      options.onNavigationIntent?.();
+      setCloseArmed(false);
+      void options.binding
+        .activatePaletteSurface(command, options.commandSource(source, "command-palette"))
+        .then((dispatched) => {
+          if (!dispatched) options.setSurface(command);
+        })
+        .catch(() => options.setNote("The selected surface could not be opened."));
+      return;
+    }
+    if (
+      command === "close-pane" &&
+      !confirmed &&
+      (!closeArmed() || armedTarget !== options.targetKey?.())
+    ) {
+      armedTarget = options.targetKey?.();
+      setCloseArmed(true);
+      options.setNote("Close pane is destructive · activate again to confirm");
+      return;
+    }
+    setCloseArmed(false);
+    setBusy(true);
+    const revision = openRevision;
+    let operation: Promise<string>;
+    try {
+      operation =
+        command === "zoom-pane"
+          ? (options.zoomPane?.() ?? Promise.resolve("Zoom unavailable"))
+          : command === "close-pane"
+            ? options.closePane()
+            : command === "new-window"
+              ? options.newWindow()
+              : options.splitPane(command === "split-right" ? "right" : "down");
+    } catch {
+      setBusy(false);
+      options.setNote("Command failed. Check the live session and try again.");
+      return;
+    }
+    void operation
+      .then((message) => {
+        options.setNote(message);
+        if (revision === openRevision) setOpen(false, source);
+      })
+      .catch(() => options.setNote("Command failed. Check the live session and try again."))
+      .finally(() => setBusy(false));
+  };
+  return {
+    ...search,
+    busy,
+    disabledReason: options.disabledReason ?? (() => null),
+    closeArmed: () => closeArmed() && armedTarget === options.targetKey?.(),
+    setOpen,
+    activate,
+    openSurface(surface: "home" | "terminals", source: Source) {
+      options.onNavigationIntent?.();
+      void options.binding
+        .openSurface(surface, options.commandSource(source, "application-bar"))
+        .then((dispatched) => {
+          if (!dispatched) options.setSurface(surface);
+        });
+    },
+  };
+}