[Init] Initial commit - NetMesh terminal manager

components/terminalHelpers.test.ts

@@ -0,0 +1,657 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { Host } from "../domain/models";
+import {
+  AUTO_RUN_SNIPPET_LINE_DELAY_MS,
+  resolveDisconnectedDialogTerminalRoot,
+  restoreTerminalFocusFromDisconnectedDialog,
+  shouldClaimDisconnectedDialogFocus,
+  shouldHideConnectingDialogForConnectionReuse,
+  shouldDelayAutoRunSnippetInput,
+  shouldReconnectDisconnectedDialogOnEnterKey,
+  shouldRestoreDisconnectedDialogTerminalFocus,
+  shouldShowTerminalDisconnectedNotice,
+  shouldShowTerminalConnectionDialog,
+} from "./terminal/terminalHelpers";
+
+const host = (overrides: Partial<Host> = {}): Host => ({
+  id: "host-1",
+  label: "Host",
+  hostname: "example.com",
+  username: "alice",
+  authMethod: "password",
+  ...overrides,
+});
+
+test("disconnected dialog reconnects on plain Enter when no control owns focus", () => {
+  assert.equal(
+    shouldReconnectDisconnectedDialogOnEnterKey({
+      key: "Enter",
+      enabled: true,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldReconnectDisconnectedDialogOnEnterKey({
+      key: "Enter",
+      enabled: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldReconnectDisconnectedDialogOnEnterKey({
+      key: "a",
+      enabled: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldReconnectDisconnectedDialogOnEnterKey({
+      key: "Enter",
+      enabled: true,
+      shiftKey: true,
+    }),
+    false,
+  );
+});
+
+test("disconnected dialog leaves Enter to focused buttons and inputs", () => {
+  class FakeElement {
+    constructor(private readonly selectorMatch: boolean) {}
+    closest(selector: string) {
+      void selector;
+      return this.selectorMatch ? this : null;
+    }
+  }
+  const previousHTMLElement = globalThis.HTMLElement;
+  // @ts-expect-error test double for DOM instanceof checks
+  globalThis.HTMLElement = FakeElement;
+  try {
+    const buttonLike = new FakeElement(true);
+    const plain = new FakeElement(false);
+    assert.equal(
+      shouldReconnectDisconnectedDialogOnEnterKey({
+        key: "Enter",
+        enabled: true,
+        target: buttonLike as unknown as EventTarget,
+      }),
+      false,
+    );
+    assert.equal(
+      shouldReconnectDisconnectedDialogOnEnterKey({
+        key: "Enter",
+        enabled: true,
+        target: plain as unknown as EventTarget,
+      }),
+      true,
+    );
+  } finally {
+    globalThis.HTMLElement = previousHTMLElement;
+  }
+});
+
+test("disconnected dialog focus claim never steals from other panes", () => {
+  class FakeNode {
+    constructor(
+      private readonly opts: {
+        id: string;
+        parent?: FakeNode | null;
+        interactive?: boolean;
+        children?: FakeNode[];
+      },
+    ) {
+      for (const child of opts.children ?? []) {
+        child.opts.parent = this;
+      }
+    }
+    get parentElement() {
+      return this.opts.parent ?? null;
+    }
+    contains(other: FakeNode | null) {
+      if (!other) return false;
+      let cur: FakeNode | null | undefined = other;
+      while (cur) {
+        if (cur === this) return true;
+        cur = cur.opts.parent;
+      }
+      return false;
+    }
+    closest(selector: string) {
+      if (selector.includes("button") && this.opts.interactive) return this;
+      return null;
+    }
+    querySelector(selector: string) {
+      if (!selector.includes("xterm-helper-textarea")) return null;
+      return (this.opts.children ?? []).find((c) => c.opts.id === "textarea") ?? null;
+    }
+    focusCalls = 0;
+    focus() {
+      this.focusCalls += 1;
+    }
+  }
+
+  const previousHTMLElement = globalThis.HTMLElement;
+  // @ts-expect-error test double for DOM instanceof checks
+  globalThis.HTMLElement = FakeNode;
+  try {
+    const body = new FakeNode({ id: "body" });
+    const otherPane = new FakeNode({ id: "other" });
+    const textarea = new FakeNode({ id: "textarea" });
+    const dialogButton = new FakeNode({ id: "btn", interactive: true });
+    const dialog = new FakeNode({ id: "dialog", children: [dialogButton] });
+    const session = new FakeNode({ id: "session", children: [textarea, dialog] });
+
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: null,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      true,
+    );
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: body as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      true,
+    );
+    // Unfocused split sibling must not claim when focus is on body/null.
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: null,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+        isFocusedPane: false,
+      }),
+      false,
+    );
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: body as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+        isFocusedPane: false,
+      }),
+      false,
+    );
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: body as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+        isFocusedPane: true,
+      }),
+      true,
+    );
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: textarea as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      true,
+    );
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: otherPane as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      false,
+    );
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: dialogButton as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      false,
+    );
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: dialog as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      false,
+    );
+
+    assert.equal(
+      restoreTerminalFocusFromDisconnectedDialog({
+        activeElement: dialog as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      true,
+    );
+    assert.equal(textarea.focusCalls, 1);
+    // After React removes the focused dialog, the browser parks focus on body
+    // before passive-effect cleanup runs — still restore to this session's xterm.
+    assert.equal(
+      restoreTerminalFocusFromDisconnectedDialog({
+        activeElement: body as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      true,
+    );
+    assert.equal(textarea.focusCalls, 2);
+    assert.equal(
+      restoreTerminalFocusFromDisconnectedDialog({
+        activeElement: otherPane as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      false,
+    );
+    assert.equal(textarea.focusCalls, 2);
+
+    // Popup terminals have no data-session-id ancestor — restore via local tree walk.
+    const popupTextarea = new FakeNode({ id: "textarea" });
+    const popupDialog = new FakeNode({ id: "dialog" });
+    const popupRoot = new FakeNode({ id: "popup-root", children: [popupTextarea, popupDialog] });
+    assert.equal(
+      resolveDisconnectedDialogTerminalRoot(popupDialog as unknown as Element, null),
+      popupRoot as unknown as Element,
+    );
+    assert.equal(
+      restoreTerminalFocusFromDisconnectedDialog({
+        activeElement: popupDialog as unknown as Element,
+        dialogNode: popupDialog as unknown as HTMLElement,
+        sessionRoot: null,
+        documentBody: body as unknown as Element,
+      }),
+      true,
+    );
+    assert.equal(popupTextarea.focusCalls, 1);
+    assert.equal(
+      shouldClaimDisconnectedDialogFocus({
+        activeElement: popupTextarea as unknown as Element,
+        dialogNode: popupDialog as unknown as HTMLElement,
+        sessionRoot: null,
+        documentBody: body as unknown as Element,
+      }),
+      true,
+    );
+    // Detached popup dialog (parent cleared) + body focus: use captured terminal root.
+    popupDialog.opts.parent = null;
+    assert.equal(
+      restoreTerminalFocusFromDisconnectedDialog({
+        activeElement: body as unknown as Element,
+        dialogNode: popupDialog as unknown as HTMLElement,
+        sessionRoot: popupRoot as unknown as Element,
+        documentBody: body as unknown as Element,
+      }),
+      true,
+    );
+    assert.equal(popupTextarea.focusCalls, 2);
+
+    // Unfocused split sibling must not restore when browser parked focus on body.
+    assert.equal(
+      restoreTerminalFocusFromDisconnectedDialog({
+        activeElement: body as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+        isFocusedPane: false,
+      }),
+      false,
+    );
+    assert.equal(textarea.focusCalls, 2);
+    assert.equal(
+      restoreTerminalFocusFromDisconnectedDialog({
+        activeElement: body as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+        isFocusedPane: true,
+      }),
+      true,
+    );
+    assert.equal(textarea.focusCalls, 3);
+    // Dialog actually owned focus — restore even if pane focus flag flipped.
+    assert.equal(
+      restoreTerminalFocusFromDisconnectedDialog({
+        activeElement: dialog as unknown as Element,
+        dialogNode: dialog as unknown as HTMLElement,
+        sessionRoot: session as unknown as Element,
+        documentBody: body as unknown as Element,
+        isFocusedPane: false,
+      }),
+      true,
+    );
+    assert.equal(textarea.focusCalls, 4);
+  } finally {
+    globalThis.HTMLElement = previousHTMLElement;
+  }
+});
+
+test("xterm focus restore is skipped while the connection overlay stays mounted", () => {
+  assert.equal(
+    shouldRestoreDisconnectedDialogTerminalFocus({ isConnected: true } as HTMLElement),
+    false,
+  );
+  assert.equal(
+    shouldRestoreDisconnectedDialogTerminalFocus({ isConnected: false } as HTMLElement),
+    true,
+  );
+  assert.equal(shouldRestoreDisconnectedDialogTerminalFocus(null), false);
+});
+
+test("connection dialog is hidden while a reused SSH channel is opening", () => {
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      status: "connecting",
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+      hideConnectingDialogForConnectionReuse: true,
+    }),
+    false,
+  );
+});
+
+test("connection dialog remains visible when reuse is not actually supported", () => {
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      status: "connecting",
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+      hideConnectingDialogForConnectionReuse: false,
+    }),
+    true,
+  );
+});
+
+test("connection dialog still appears for fresh remote connections", () => {
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      status: "connecting",
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    true,
+  );
+});
+
+test("connection dialog keeps existing local and disconnected behavior", () => {
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      status: "connecting",
+      isLocalConnection: true,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      status: "connected",
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      status: "disconnected",
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: true,
+    }),
+    false,
+  );
+});
+
+test("established sessions use the selected disconnected presentation", () => {
+  const base = {
+    status: "disconnected" as const,
+    hasEverConnected: true,
+  };
+
+  assert.equal(
+    shouldShowTerminalDisconnectedNotice({
+      ...base,
+      disconnectedNoticeMode: "terminal",
+    }),
+    true,
+  );
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      ...base,
+      disconnectedNoticeMode: "terminal",
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldShowTerminalDisconnectedNotice({
+      ...base,
+      disconnectedNoticeMode: "dialog",
+    }),
+    false,
+  );
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      ...base,
+      disconnectedNoticeMode: "dialog",
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    true,
+  );
+});
+
+test("terminal notice never hides first-connect failures or restored session guidance", () => {
+  const dialogArgs = {
+    status: "disconnected" as const,
+    disconnectedNoticeMode: "terminal" as const,
+    isLocalConnection: false,
+    isSerialConnection: false,
+    isDisconnectedDialogDismissed: false,
+  };
+
+  assert.equal(
+    shouldShowTerminalDisconnectedNotice({
+      status: "disconnected",
+      disconnectedNoticeMode: "terminal",
+      hasEverConnected: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldShowTerminalConnectionDialog({ ...dialogArgs, hasEverConnected: false }),
+    true,
+  );
+  assert.equal(
+    shouldShowTerminalDisconnectedNotice({
+      status: "disconnected",
+      disconnectedNoticeMode: "terminal",
+      hasEverConnected: true,
+      restoreState: "restored-disconnected",
+    }),
+    false,
+  );
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      ...dialogArgs,
+      hasEverConnected: true,
+      restoreState: "restored-disconnected",
+    }),
+    true,
+  );
+});
+
+test("terminal notice is absent while connected", () => {
+  assert.equal(
+    shouldShowTerminalDisconnectedNotice({
+      status: "connected",
+      disconnectedNoticeMode: "terminal",
+      hasEverConnected: true,
+    }),
+    false,
+  );
+});
+
+test("established manual reconnect stays non-blocking until input is required", () => {
+  const base = {
+    status: "connecting" as const,
+    disconnectedNoticeMode: "terminal" as const,
+    hasEverConnected: true,
+    isReconnectActive: true,
+  };
+
+  assert.equal(shouldShowTerminalDisconnectedNotice(base), true);
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      ...base,
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    false,
+  );
+
+  assert.equal(
+    shouldShowTerminalDisconnectedNotice({ ...base, requiresUserInput: true }),
+    false,
+  );
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      ...base,
+      requiresUserInput: true,
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    true,
+  );
+});
+
+test("established automatic reconnect stays non-blocking until input is required", () => {
+  const base = {
+    status: "connecting" as const,
+    disconnectedNoticeMode: "terminal" as const,
+    hasEverConnected: true,
+    isReconnectActive: true,
+  };
+
+  assert.equal(shouldShowTerminalDisconnectedNotice(base), true);
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      ...base,
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    false,
+  );
+
+  assert.equal(
+    shouldShowTerminalDisconnectedNotice({ ...base, requiresUserInput: true }),
+    false,
+  );
+  assert.equal(
+    shouldShowTerminalConnectionDialog({
+      ...base,
+      requiresUserInput: true,
+      isLocalConnection: false,
+      isSerialConnection: false,
+      isDisconnectedDialogDismissed: false,
+    }),
+    true,
+  );
+});
+
+test("connection reuse hides connecting dialog only while reuse is still possible", () => {
+  assert.equal(
+    shouldHideConnectingDialogForConnectionReuse({
+      reuseConnectionFromSessionId: undefined,
+      host: host(),
+      connectionReuseFellBack: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldHideConnectingDialogForConnectionReuse({
+      reuseConnectionFromSessionId: "source-session",
+      host: host(),
+      connectionReuseFellBack: false,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldHideConnectingDialogForConnectionReuse({
+      reuseConnectionFromSessionId: "source-session",
+      host: host({ x11Forwarding: true }),
+      connectionReuseFellBack: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldHideConnectingDialogForConnectionReuse({
+      reuseConnectionFromSessionId: "source-session",
+      host: host({ moshEnabled: true }),
+      connectionReuseFellBack: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldHideConnectingDialogForConnectionReuse({
+      reuseConnectionFromSessionId: "source-session",
+      host: host({ etEnabled: true }),
+      connectionReuseFellBack: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldHideConnectingDialogForConnectionReuse({
+      reuseConnectionFromSessionId: "source-session",
+      host: host(),
+      connectionReuseFellBack: true,
+    }),
+    false,
+  );
+});
+
+test("auto-run snippets only delay multi-line input in line-by-line mode", () => {
+  assert.equal(AUTO_RUN_SNIPPET_LINE_DELAY_MS > 0, true);
+  assert.equal(shouldDelayAutoRunSnippetInput("tthdf 0 2323\nadmin\ntest123", { noAutoRun: false }), false);
+  assert.equal(
+    shouldDelayAutoRunSnippetInput("sudo apt install gconf2-common -y\necho \"123456\"", {
+      noAutoRun: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldDelayAutoRunSnippetInput("tthdf 0 2323\nadmin\ntest123", {
+      noAutoRun: false,
+      multiLineRunMode: "lineDelay",
+    }),
+    true,
+  );
+  assert.equal(shouldDelayAutoRunSnippetInput("tthdf 0 2323\nadmin\ntest123", { noAutoRun: true }), false);
+  assert.equal(shouldDelayAutoRunSnippetInput("show version", { noAutoRun: false }), false);
+  assert.equal(shouldDelayAutoRunSnippetInput("show version\r", { noAutoRun: false }), false);
+});