@hoox-sh/hoox-tui 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoox-sh/hoox-tui",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Hoox algorithmic trading terminal operations center — OpenTUI dashboard",
   "type": "module",
   "main": "./dist/main.js",
@@ -32,7 +32,7 @@
     "prepublishOnly": "bun run typecheck && bun run build"
   },
   "dependencies": {
-    "@hoox-sh/hoox-shared": "^1.2.0",
+    "@hoox-sh/hoox-shared": "^1.3.0",
     "@opentui-ui/dialog": "^0.1.2",
     "@opentui-ui/toast": "^0.0.5",
     "@opentui/core": "^0.5.1",

package/src/app.tsx

@@ -131,38 +131,16 @@ function AppRootInner({ safeMode = false }: { safeMode?: boolean }) {
   }, [closePalette, showModal, dismissModal]);
 
   // ── Session restore on mount ────────────────────────────────────────────
-  // Shared restoreSession currently only accepts the original 9 ViewIds.
-  // Re-read session.json and accept any registry ViewId so newer views
-  // (queues, kv, secrets, …) actually restore after restart.
+  // Shared restoreSession validates all 16 ViewIds (unknown → dashboard).
   useEffect(() => {
     let cancelled = false;
     (async () => {
       const session = await restoreSession();
       if (cancelled) return;
 
-      let view: ViewId = session.activeView;
-      let expanded = session.sidebarExpanded;
-
-      try {
-        const rawPath = resolveTuiStatePath("session.json");
-        const file = Bun.file(rawPath);
-        if (await file.exists()) {
-          const raw = (await file.json()) as {
-            activeView?: unknown;
-            sidebarExpanded?: unknown;
-          };
-          if (isRegisteredViewId(raw.activeView)) {
-            view = raw.activeView;
-          }
-          if (typeof raw.sidebarExpanded === "boolean") {
-            expanded = raw.sidebarExpanded;
-          }
-        }
-      } catch {
-        // Corrupt raw session — keep shared restore result
-      }
+      const view: ViewId = session.activeView;
+      const expanded = session.sidebarExpanded;
 
-      if (cancelled) return;
       if (isRegisteredViewId(view)) {
         setView(view);
       }
@@ -479,10 +457,15 @@ function AppRootInner({ safeMode = false }: { safeMode?: boolean }) {
         return;
       }
 
-      // Ctrl+R: refresh worker data (no-op in safe mode network sense — still allowed)
+      // Ctrl+R: refresh worker data + force reconnect from offline
       if (key.ctrl && !key.alt && name === "r") {
         if (!safeMode) {
-          void useServiceStore.getState().fetchWorkers();
+          const store = useServiceStore.getState();
+          if (store.connectionStatus === "offline") {
+            store.forceRetry();
+          } else {
+            void store.fetchWorkers();
+          }
         }
         return;
       }
@@ -493,13 +476,20 @@ function AppRootInner({ safeMode = false }: { safeMode?: boolean }) {
         return;
       }
 
-      // Escape: dismiss modal, then palette
+      // Escape: modal → palette → goBack (when previousView set)
       if (name === "escape") {
         if (modal) {
           dismissModal();
           return;
         }
-        closePalette();
+        if (commandPaletteOpen) {
+          closePalette();
+          return;
+        }
+        const prev = useUIStore.getState().previousView;
+        if (prev) {
+          useUIStore.getState().goBack();
+        }
       }
     },
     [
@@ -555,6 +545,22 @@ function AppRootInner({ safeMode = false }: { safeMode?: boolean }) {
 
         {/* Content area: View (fills remaining space) */}
         <box flexDirection="column" flexGrow={1} padding={1}>
+          {safeMode ? (
+            <box
+              flexDirection="row"
+              paddingLeft={1}
+              paddingRight={1}
+              backgroundColor={Colors.card}
+            >
+              <text fg={Colors.warning} bold>
+                SAFE MODE
+              </text>
+              <text fg={Colors.muted} dim>
+                {" "}
+                — network / CLI / SSE disabled · restart for full ops
+              </text>
+            </box>
+          ) : null}
           {renderView(dialog)}
         </box>
       </box>
@@ -571,7 +577,16 @@ function AppRootInner({ safeMode = false }: { safeMode?: boolean }) {
             if (selection.action === "setView" && selection.command.id) {
               setView(selection.command.id as ViewId);
             } else if (selection.command.id === "refresh") {
-              void useServiceStore.getState().fetchWorkers();
+              const store = useServiceStore.getState();
+              if (store.connectionStatus === "offline") {
+                store.forceRetry();
+              } else {
+                void store.fetchWorkers();
+              }
+            } else if (selection.command.id === "force-retry") {
+              useServiceStore.getState().forceRetry();
+            } else if (selection.command.id === "expand-error") {
+              useUIStore.getState().toggleStatusErrorExpanded();
             } else if (selection.command.id === "toggle-sidebar") {
               toggleSidebar();
             } else if (selection.command.id === "quit") {

package/src/cli-bridge-test-double.ts

@@ -188,13 +188,48 @@ export function resetCliBridgeDouble(): void {
   applyDefaults();
 }
 
+/**
+ * Real CliBridgeImpl singleton loaded before mock.module installs the double.
+ * Used by method-level unit tests that stub `exec` without spawning CLI.
+ */
+export let realCliBridge: {
+  exec: (...args: unknown[]) => Promise<unknown>;
+  dbQuery: (sql: string) => Promise<unknown>;
+  monitorQueueDepth: () => Promise<unknown>;
+  monitorKillSwitch: (action: string) => Promise<unknown>;
+  configKvList: () => Promise<unknown>;
+  configKvGet: (key: string) => Promise<unknown>;
+  configKvSet: (key: string, value: string) => Promise<unknown>;
+  configSecretsList: () => Promise<unknown>;
+  agentHealthCheck: () => Promise<unknown>;
+  pyneHealthCheck: () => Promise<unknown>;
+  deployAll: (...args: unknown[]) => Promise<unknown>;
+  deployWorker: (...args: unknown[]) => Promise<unknown>;
+  checkHealth: () => Promise<unknown>;
+  checkHealthFix: () => Promise<unknown>;
+  checkFix: () => Promise<unknown>;
+  workerLogs: (name: string) => Promise<unknown>;
+  configShow: () => Promise<unknown>;
+  configValidate: () => Promise<unknown>;
+  monitorStatus: () => Promise<unknown>;
+  rebuild: (...args: unknown[]) => Promise<unknown>;
+  repairWorker: (...args: unknown[]) => Promise<unknown>;
+  checkSetup: () => Promise<unknown>;
+  resolveBinary: () => Promise<string>;
+  invalidateCache: () => void;
+  onError: (sink: (details: unknown) => void) => () => void;
+  abort: (tag: string) => void;
+  dispose: () => void;
+} | null = null;
+
 /** Factory for mock.module — re-exports real standalone + index helpers. */
 export async function createCliBridgeModuleMock(): Promise<
   Record<string, unknown>
 > {
   // Load real module exports *before* mock.module is installed so tests that
-  // import tryParseJsonLoose / sanitizeCliArgsForLog still get the real fns.
+  // import pure parsers / sanitize helpers still get the real fns.
   const realBridge = await import("./services/cli-bridge/index");
+  realCliBridge = realBridge.cliBridge as typeof realCliBridge;
   const standalone = await import("./services/cli-bridge/standalone");
   const types = await import("./services/cli-bridge/types");
   return {
@@ -204,6 +239,18 @@ export async function createCliBridgeModuleMock(): Promise<
     AI_MODEL_OPTIONS: standalone.AI_MODEL_OPTIONS,
     tryParseJsonLoose: realBridge.tryParseJsonLoose,
     sanitizeCliArgsForLog: realBridge.sanitizeCliArgsForLog,
+    parseDbQueryResult: realBridge.parseDbQueryResult,
+    deriveQueueDepthStatus: realBridge.deriveQueueDepthStatus,
+    parseQueueDepths: realBridge.parseQueueDepths,
+    parseSecretsList: realBridge.parseSecretsList,
+    inferSecretType: realBridge.inferSecretType,
+    parseKvList: realBridge.parseKvList,
+    parseKvManifest: realBridge.parseKvManifest,
+    stripAnsi: realBridge.stripAnsi,
+    parseKillSwitchStatus: realBridge.parseKillSwitchStatus,
+    parsePyneHealth: realBridge.parsePyneHealth,
+    parseAgentHealth: realBridge.parseAgentHealth,
+    extractNamespaceId: realBridge.extractNamespaceId,
     // Type re-exports are erased at runtime; keep values if any exist
     ...Object.fromEntries(
       Object.entries(types).filter(([, v]) => typeof v !== "undefined")

package/src/components/layout/sidebar.tsx

@@ -42,27 +42,43 @@ export function Sidebar() {
       </CoolBrackets>
       <text fg={Colors.dim}>─────────────────</text>
 
-      {/* Navigation items (registry order) */}
+      {/* Navigation items (registry order) — shortcut from registry */}
       {SIDEBAR_ITEMS.map((item) => {
         const isActive = item.id === activeView;
+        // Pad label so shortcut sits right-aligned in the fixed-width rail
+        const shortcutHint = item.shortcut;
         return (
-          <box flexDirection="row" gap={1} key={item.id}>
-            {isActive ? <CoolGlyph char="▸" /> : <text fg={Colors.dim}> </text>}
-            <text
-              fg={isActive ? Colors.accent : Colors.muted}
-              bold={isActive}
-              onMouseUp={() => setView(item.id)}
-            >
-              {item.label}
+          <box
+            flexDirection="row"
+            gap={1}
+            key={item.id}
+            justifyContent="space-between"
+          >
+            <box flexDirection="row" gap={1} flexGrow={1}>
+              {isActive ? (
+                <CoolGlyph char="▸" />
+              ) : (
+                <text fg={Colors.dim}> </text>
+              )}
+              <text
+                fg={isActive ? Colors.accent : Colors.muted}
+                bold={isActive}
+                onMouseUp={() => setView(item.id)}
+              >
+                {item.label}
+              </text>
+            </box>
+            <text fg={Colors.dim} dim>
+              {shortcutHint}
             </text>
           </box>
         );
       })}
 
-      {/* Shortcut hints — digits are Ctrl; letter chords are Ctrl+Alt */}
+      {/* Shortcut legend — digits are Ctrl; ^X chords are Ctrl+Alt */}
       <box flexGrow={1} />
       <text fg={Colors.dim} dim>
-        Ctrl+0-9 · Ctrl+Alt+…
+        1-9 Ctrl · ^X Ctrl+Alt
       </text>
     </box>
   );

package/src/components/layout/statusbar.test.tsx

@@ -197,7 +197,7 @@ describe("StatusBar", () => {
       });
       const output = await renderStatusBar();
       // The expand hint is rendered when pillInteractive is true
-      expect(output).toContain("click for details");
+      expect(output).toContain("details");
     });
 
     it("does not show the expand hint when no error details are present", async () => {
@@ -224,11 +224,12 @@ describe("StatusBar", () => {
   // ── Keyboard hints ─────────────────────────────────────────────────────
 
   describe("keyboard hints", () => {
-    it("shows ^P PALETTE · ^B SIDEBAR · ^Q QUIT hint", async () => {
+    it("shows global shortcut hints including diagnostics chord", async () => {
       const output = await renderStatusBar();
-      expect(output).toContain("PALETTE");
-      expect(output).toContain("SIDEBAR");
-      expect(output).toContain("QUIT");
+      expect(output).toContain("^P");
+      expect(output).toContain("^B");
+      expect(output).toContain("^Q");
+      expect(output).toContain("^⇧D");
     });
   });
 
@@ -278,10 +279,23 @@ describe("StatusBar", () => {
       process.env.HOOX_TUI_MODE = "remote";
       process.env.HOOX_API_URL = "https://gw.test";
       delete process.env.HOOX_API_TOKEN;
+      delete process.env.CF_ACCESS_CLIENT_ID;
+      delete process.env.CF_ACCESS_CLIENT_SECRET;
       const output = await renderStatusBar();
       expect(output).toContain("AUTH?");
       expect(output).toContain("gw.test");
     });
+
+    it("does not show AUTH? for Access-only remote credentials", async () => {
+      process.env.HOOX_TUI_MODE = "remote";
+      process.env.HOOX_API_URL = "https://gw.test";
+      delete process.env.HOOX_API_TOKEN;
+      process.env.CF_ACCESS_CLIENT_ID = "access-id";
+      process.env.CF_ACCESS_CLIENT_SECRET = "access-secret";
+      const output = await renderStatusBar();
+      expect(output).not.toContain("AUTH?");
+      expect(output).toContain("gw.test");
+    });
   });
 });
 

package/src/components/layout/statusbar.tsx

@@ -20,22 +20,24 @@
  *     known error types so the user gets a suggested next step, not just
  *     the raw error.
  */
-import { useState, useCallback, memo } from "react";
+import { useCallback, memo } from "react";
+import { useKeyboard } from "@opentui/react";
 import {
   Colors,
   ConnectionStatusColor,
   useServiceStore,
+  useUIStore,
   formatRelativeTimeFromTime as formatRelativeTime,
   type CliErrorType,
   type CliErrorDetails,
 } from "@hoox-sh/hoox-shared";
 import {
   classifyConnectionError,
-  hasApiToken,
   resolveTuiConnectionEnv,
 } from "../../services/tui-connection";
 import { redactSecretsInText } from "../../services/dev-log";
 import { CoolGlyph } from "../shared/cool-brackets";
+import { isShellOverlayOpen } from "../../hooks/shell-overlay";
 
 /** Map each CliErrorType to a short, human-readable label. */
 const ERROR_TYPE_LABELS: Record<CliErrorType, string> = {
@@ -231,26 +233,40 @@ export function StatusBar() {
   const lastErrorDetails = useServiceStore((s) => s.lastErrorDetails);
   const retryCount = useServiceStore((s) => s.retryCount);
   const reconnectDelay = useServiceStore((s) => s.reconnectDelay);
+  const errorExpanded = useUIStore((s) => s.statusErrorExpanded);
+  const toggleStatusErrorExpanded = useUIStore(
+    (s) => s.toggleStatusErrorExpanded
+  );
 
   const conn = resolveTuiConnectionEnv();
   const tuiMode = conn.mode;
   const apiHost = conn.apiHost;
-  const tokenPresent = hasApiToken();
+  // Fail-closed readiness: Bearer and/or Access pair (not token alone)
+  const authReady = conn.hasAuth;
   const errorKind = classifyConnectionError(lastError);
-  // Compact AUTH cue: missing token (remote) or auth error — keep short for host room
+  // Compact AUTH cue: missing any remote credential, or auth error
   const showAuthHint =
     tuiMode === "remote" &&
-    (!tokenPresent ||
-      errorKind === "auth" ||
-      Boolean(lastError?.includes("401")));
-
-  // Local UI state — expansion is purely a presentation concern, so it
-  // lives in component state rather than the global store.
-  const [errorExpanded, setErrorExpanded] = useState<boolean>(false);
+    (!authReady || errorKind === "auth" || Boolean(lastError?.includes("401")));
 
   const toggleError = useCallback(() => {
-    setErrorExpanded((prev) => !prev);
-  }, []);
+    toggleStatusErrorExpanded();
+  }, [toggleStatusErrorExpanded]);
+
+  // Keyboard expand diagnostics: Ctrl+Shift+D (does not steal view chords)
+  useKeyboard((key) => {
+    if (isShellOverlayOpen()) return;
+    const name = String(key.name ?? "").toLowerCase();
+    if (key.ctrl && key.shift && name === "d") {
+      const details = useServiceStore.getState().lastErrorDetails;
+      const status = useServiceStore.getState().connectionStatus;
+      const canExpand =
+        details !== null && (status === "offline" || status === "reconnecting");
+      if (canExpand) {
+        useUIStore.getState().toggleStatusErrorExpanded();
+      }
+    }
+  });
 
   const statusLabel: Record<string, string> = {
     connected: "CONNECTED",
@@ -285,7 +301,7 @@ export function StatusBar() {
   );
 
   if (showAuthHint) {
-    parts.push(!tokenPresent ? "| AUTH?" : "| AUTH!");
+    parts.push(!authReady ? "| AUTH?" : "| AUTH!");
   }
 
   if (lastError && isErrorState && errorKind !== "auth") {
@@ -294,11 +310,11 @@ export function StatusBar() {
   }
 
   // The expand hint appears whenever a clickable error is available so
-  // users know they can drill in.
+  // users know they can drill in (mouse or Ctrl+Shift+D).
   const expandHint = pillInteractive
     ? errorExpanded
-      ? "▾ click to collapse"
-      : "▸ click for details"
+      ? "▾ collapse (^⇧D)"
+      : "▸ details (^⇧D)"
     : "";
 
   return (
@@ -335,7 +351,7 @@ export function StatusBar() {
           <CoolGlyph char="┐" />
         </box>
         <text fg={Colors.dim} dim>
-          ^P PALETTE · ^B SIDEBAR · ^Q QUIT
+          ^P · ^B · ^Q · ^⇧D err
         </text>
       </box>
 

package/src/components/shared/crash-screen.tsx

@@ -11,11 +11,11 @@
  *   - "Something went wrong" banner
  *   - Error message (first line)
  *   - Three action buttons: [Restart] [Safe Mode] [Report Bug]
+ *   - Keyboard: R restart · S safe mode · B report bug
  *
- * This component is a plain function (not a class) because it's meant to be
- * rendered in a degraded state — no hooks, no stores, no external state.
  * Colors use Hoox design tokens via @hoox-sh/hoox-shared.
  */
+import { useKeyboard } from "@opentui/react";
 import { Colors } from "@hoox-sh/hoox-shared";
 import { redactSecretsInText } from "../../services/dev-log";
 
@@ -56,6 +56,22 @@ export function CrashScreen({
     ? redactSecretsInText(secondRaw).slice(0, 80)
     : undefined;
 
+  // Keyboard recovery (mouse optional / TUI_MOUSE=0)
+  useKeyboard((key) => {
+    const name = String(key.name ?? "").toLowerCase();
+    if (name === "r" || name === "1") {
+      onAction("restart");
+      return;
+    }
+    if (!safeMode && (name === "s" || name === "2")) {
+      onAction("safe-mode");
+      return;
+    }
+    if (name === "b" || name === "3") {
+      onAction("report-bug");
+    }
+  });
+
   return (
     <box
       flexDirection="column"
@@ -162,6 +178,12 @@ export function CrashScreen({
           </text>
         </box>
       </box>
+
+      <text fg={Colors.dim} dim>
+        {safeMode
+          ? "Keys: R restart · B report bug"
+          : "Keys: R restart · S safe mode · B report bug"}
+      </text>
     </box>
   );
 }

package/src/components/shared/error-boundary.tsx

@@ -12,6 +12,7 @@
  * Colors use Hoox design tokens — no hardcoded hex.
  */
 import { Component, type ReactNode } from "react";
+import { useKeyboard } from "@opentui/react";
 import { Colors } from "@hoox-sh/hoox-shared";
 import { redactSecretsInText } from "../../services/dev-log";
 
@@ -37,6 +38,56 @@ export function formatBoundaryErrorMessage(error: Error, maxLen = 160): string {
     : scrubbed;
 }
 
+/** Keyboard + mouse retry chrome (hooks require a function component). */
+function ErrorRecoveryPanel({
+  viewName,
+  message,
+  onRetry,
+}: {
+  viewName: string;
+  message: string;
+  onRetry: () => void;
+}) {
+  useKeyboard((key) => {
+    const name = String(key.name ?? "").toLowerCase();
+    if (name === "return" || name === "enter" || name === "r") {
+      onRetry();
+    }
+  });
+
+  return (
+    <box
+      flexDirection="column"
+      padding={2}
+      gap={1}
+      border={true}
+      borderStyle="single"
+      borderColor={Colors.border}
+      backgroundColor={Colors.card}
+    >
+      <box flexDirection="row" gap={1}>
+        <text fg={Colors.error} bold>
+          ⚠
+        </text>
+        <text fg={Colors.error} bold>
+          Failed to load {viewName}
+        </text>
+      </box>
+
+      <text fg={Colors.muted}>{message}</text>
+
+      <box paddingTop={1} flexDirection="row" gap={2}>
+        <text fg={Colors.accent} bg={Colors.card} onMouseUp={onRetry}>
+          {"  [Retry]  "}
+        </text>
+        <text fg={Colors.dim} dim>
+          Enter / R
+        </text>
+      </box>
+    </box>
+  );
+}
+
 // ── Component ──────────────────────────────────────────────────────────────
 
 export class ErrorBoundary extends Component<
@@ -58,39 +109,11 @@ export class ErrorBoundary extends Component<
     if (this.state.error) {
       const message = formatBoundaryErrorMessage(this.state.error);
       return (
-        <box
-          flexDirection="column"
-          padding={2}
-          gap={1}
-          border={true}
-          borderStyle="single"
-          borderColor={Colors.border}
-          backgroundColor={Colors.card}
-        >
-          {/* Header: view name + error indicator */}
-          <box flexDirection="row" gap={1}>
-            <text fg={Colors.error} bold>
-              ⚠
-            </text>
-            <text fg={Colors.error} bold>
-              Failed to load {this.props.viewName}
-            </text>
-          </box>
-
-          {/* Error message (redacted, first line only) */}
-          <text fg={Colors.muted}>{message}</text>
-
-          {/* Retry action */}
-          <box paddingTop={1}>
-            <text
-              fg={Colors.accent}
-              bg={Colors.card}
-              onMouseUp={this.handleRetry}
-            >
-              {"  [Retry]  "}
-            </text>
-          </box>
-        </box>
+        <ErrorRecoveryPanel
+          viewName={this.props.viewName}
+          message={message}
+          onRetry={this.handleRetry}
+        />
       );
     }
 

package/src/components/ui/connection-toasts.test.ts

@@ -11,6 +11,19 @@ import {
   messageConnectionLost,
   messageOfflineStartup,
   messageReconnected,
+  toastReconnected,
+  toastReconnectedMode,
+  toastRateLimited,
+  toastConfigSaved,
+  toastDeployStarted,
+  toastDeployCompleted,
+  toastDeployFailed,
+  toastConnectionLost,
+  toastConnectionLostMode,
+  toastConnectedMode,
+  toastAuthRequiredMode,
+  toastAuthMissingRemote,
+  toastOfflineStartup,
 } from "./connection-toasts";
 
 describe("connection-toasts messages", () => {
@@ -36,15 +49,59 @@ describe("connection-toasts messages", () => {
     expect(msg).toContain("downtime");
   });
 
+  it("reconnected clamps negative downtime to zero", () => {
+    const msg = messageReconnected("local", "h", 10_000, 1_000);
+    expect(msg).toContain("downtime");
+  });
+
   it("auth messages are explicit", () => {
     expect(messageAuthRequired("remote", "gw")).toContain("Auth failed");
+    expect(messageAuthRequired("local", "localhost")).toContain("LOCAL");
     expect(messageAuthMissing("gw")).toContain("No API credentials");
   });
 
-  it("offline startup distinguishes auth", () => {
+  it("offline startup distinguishes kinds", () => {
     expect(messageOfflineStartup("remote", "gw", "auth")).toContain("(auth)");
     expect(
       messageOfflineStartup("local", "localhost:8787", "network")
     ).not.toContain("(auth)");
+    expect(messageOfflineStartup("remote", "gw", "rate-limit")).toContain(
+      "(rate limited)"
+    );
+    expect(messageOfflineStartup("local", "h", "unknown")).toBe(
+      "Could not connect · LOCAL · h"
+    );
+  });
+});
+
+describe("connection-toasts factory functions", () => {
+  // Toast singleton may no-op without a mounted Toaster; factories must not throw.
+  it("toast factories are callable without a mounted toaster", () => {
+    expect(() => toastReconnected(Date.now() - 5_000)).not.toThrow();
+    expect(() =>
+      toastReconnectedMode("remote", "gw.test", Date.now() - 2_000)
+    ).not.toThrow();
+    expect(() => toastRateLimited()).not.toThrow();
+    expect(() => toastConfigSaved()).not.toThrow();
+    expect(() => toastDeployStarted("trade-worker")).not.toThrow();
+    expect(() => toastDeployCompleted("trade-worker")).not.toThrow();
+    expect(() => toastDeployFailed("trade-worker", "timeout")).not.toThrow();
+    expect(() => toastConnectionLost()).not.toThrow();
+    expect(() =>
+      toastConnectionLostMode("local", "localhost:8787")
+    ).not.toThrow();
+    expect(() => toastConnectionLostMode("remote", "gw")).not.toThrow();
+    expect(() => toastConnectedMode("local", "localhost:8787")).not.toThrow();
+    expect(() => toastAuthRequiredMode("remote", "gw")).not.toThrow();
+    expect(() => toastAuthRequiredMode("local", "localhost")).not.toThrow();
+    expect(() => toastAuthMissingRemote("gw")).not.toThrow();
+    expect(() => toastOfflineStartup("remote", "gw", "auth")).not.toThrow();
+    expect(() => toastOfflineStartup("remote", "gw", "network")).not.toThrow();
+    expect(() =>
+      toastOfflineStartup("local", "localhost", "rate-limit")
+    ).not.toThrow();
+    expect(() =>
+      toastOfflineStartup("local", "localhost", "unknown")
+    ).not.toThrow();
   });
 });