@hoox-sh/hoox-tui 0.2.0 → 0.3.0

package/src/services/clipboard.test.ts

@@ -3,14 +3,35 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { describe, it, expect } from "bun:test";
-import { copyToClipboard, copyViaSystemClipboard } from "./clipboard";
+import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
+import {
+  copyToClipboard,
+  copyViaSystemClipboard,
+  enableAutoCopyOnSelection,
+  type ClipboardRenderer,
+} from "./clipboard";
 import { messageCopiedToClipboard } from "../components/ui/toast";
+import { setRendererRef } from "../hooks";
 
 describe("clipboard", () => {
+  const originalWhich = Bun.which;
+  const originalSpawn = Bun.spawn;
+
+  afterEach(() => {
+    (Bun as { which: typeof Bun.which }).which = originalWhich;
+    (Bun as { spawn: typeof Bun.spawn }).spawn = originalSpawn;
+    setRendererRef(null);
+  });
+
   it("treats empty text as success without throwing", async () => {
     const result = await copyToClipboard("   ", null);
     expect(result.ok).toBe(true);
+    if (result.ok) expect(result.method).toBe("osc52");
+  });
+
+  it("treats empty string as success", async () => {
+    const result = await copyToClipboard("", null);
+    expect(result.ok).toBe(true);
   });
 
   it("copyViaSystemClipboard returns a tool name or null", async () => {
@@ -19,9 +40,139 @@ describe("clipboard", () => {
     expect(tool === null || typeof tool === "string").toBe(true);
   });
 
+  it("copyViaSystemClipboard returns null when no tools exist", async () => {
+    (Bun as { which: typeof Bun.which }).which = (() =>
+      null) as typeof Bun.which;
+    const tool = await copyViaSystemClipboard("x");
+    expect(tool).toBeNull();
+  });
+
+  it("copyViaSystemClipboard returns tool name on successful spawn", async () => {
+    (Bun as { which: typeof Bun.which }).which = ((bin: string) =>
+      bin === "wl-copy" ? "/usr/bin/wl-copy" : null) as typeof Bun.which;
+
+    (Bun as { spawn: typeof Bun.spawn }).spawn = (() => {
+      const writes: string[] = [];
+      return {
+        stdin: {
+          write: (t: string | Uint8Array) => {
+            writes.push(
+              typeof t === "string" ? t : new TextDecoder().decode(t)
+            );
+          },
+          end: () => {},
+        },
+        stdout: null,
+        stderr: null,
+        killed: false,
+        kill: () => {},
+        exited: Promise.resolve(0),
+      };
+    }) as unknown as typeof Bun.spawn;
+
+    const tool = await copyViaSystemClipboard("secret-text");
+    expect(tool).toBe("wl-copy");
+  });
+
+  it("copyViaSystemClipboard skips tools that exit non-zero", async () => {
+    let whichCalls = 0;
+    (Bun as { which: typeof Bun.which }).which = ((bin: string) => {
+      whichCalls++;
+      if (bin === "wl-copy") return "/usr/bin/wl-copy";
+      if (bin === "xclip") return "/usr/bin/xclip";
+      return null;
+    }) as typeof Bun.which;
+
+    let spawnN = 0;
+    (Bun as { spawn: typeof Bun.spawn }).spawn = ((cmd: string[]) => {
+      spawnN++;
+      const bin = cmd[0];
+      return {
+        stdin: { write: () => {}, end: () => {} },
+        killed: false,
+        kill: () => {},
+        exited: Promise.resolve(bin === "wl-copy" ? 1 : 0),
+      };
+    }) as unknown as typeof Bun.spawn;
+
+    const tool = await copyViaSystemClipboard("payload");
+    expect(tool).toBe("xclip");
+    expect(spawnN).toBe(2);
+    expect(whichCalls).toBeGreaterThan(0);
+  });
+
+  it("copyViaSystemClipboard continues after spawn throw", async () => {
+    (Bun as { which: typeof Bun.which }).which = ((bin: string) =>
+      bin === "wl-copy" || bin === "pbcopy"
+        ? `/bin/${bin}`
+        : null) as typeof Bun.which;
+
+    (Bun as { spawn: typeof Bun.spawn }).spawn = ((cmd: string[]) => {
+      if (cmd[0] === "wl-copy") throw new Error("spawn failed");
+      return {
+        stdin: { write: () => {}, end: () => {} },
+        killed: false,
+        kill: () => {},
+        exited: Promise.resolve(0),
+      };
+    }) as unknown as typeof Bun.spawn;
+
+    const tool = await copyViaSystemClipboard("x");
+    expect(tool).toBe("pbcopy");
+  });
+
+  it("copyToClipboard uses OSC52 when renderer succeeds", async () => {
+    (Bun as { which: typeof Bun.which }).which = (() =>
+      null) as typeof Bun.which;
+    const renderer: ClipboardRenderer = {
+      copyToClipboardOSC52: () => true,
+      on: () => renderer,
+      off: () => renderer,
+    };
+    const result = await copyToClipboard("hello", renderer);
+    expect(result).toEqual({ ok: true, method: "osc52" });
+  });
+
+  it("copyToClipboard falls through when OSC52 returns false", async () => {
+    (Bun as { which: typeof Bun.which }).which = ((bin: string) =>
+      bin === "xsel" ? "/usr/bin/xsel" : null) as typeof Bun.which;
+    (Bun as { spawn: typeof Bun.spawn }).spawn = (() => ({
+      stdin: { write: () => {}, end: () => {} },
+      killed: false,
+      kill: () => {},
+      exited: Promise.resolve(0),
+    })) as unknown as typeof Bun.spawn;
+
+    const renderer: ClipboardRenderer = {
+      copyToClipboardOSC52: () => false,
+      on: () => renderer,
+      off: () => renderer,
+    };
+    const result = await copyToClipboard("hello", renderer);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.method).toBe("system");
+      expect(result.tool).toBe("xsel");
+    }
+  });
+
+  it("copyToClipboard falls through when OSC52 throws", async () => {
+    (Bun as { which: typeof Bun.which }).which = (() =>
+      null) as typeof Bun.which;
+    const renderer: ClipboardRenderer = {
+      copyToClipboardOSC52: () => {
+        throw new Error("no osc");
+      },
+      on: () => renderer,
+      off: () => renderer,
+    };
+    const result = await copyToClipboard("hello", renderer);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toMatch(/clipboard/i);
+  });
+
   it("copyToClipboard falls back when no renderer is available", async () => {
     const result = await copyToClipboard("hello from hoox tui", null);
-    // Success if system tool exists; otherwise structured failure
     if (result.ok) {
       expect(result.method === "osc52" || result.method === "system").toBe(
         true
@@ -36,6 +187,65 @@ describe("clipboard", () => {
     const result = await copyToClipboard("notify me", null, { notify: true });
     expect(typeof result.ok).toBe("boolean");
   });
+
+  it("uses getRendererRef when renderer arg omitted", async () => {
+    const renderer: ClipboardRenderer = {
+      copyToClipboardOSC52: () => true,
+      on: () => renderer,
+      off: () => renderer,
+    };
+    setRendererRef(renderer as unknown as import("@opentui/core").CliRenderer);
+    (Bun as { which: typeof Bun.which }).which = (() =>
+      null) as typeof Bun.which;
+    const result = await copyToClipboard("via-ref");
+    expect(result).toEqual({ ok: true, method: "osc52" });
+  });
+});
+
+describe("enableAutoCopyOnSelection", () => {
+  it("registers selection listener and ignores drag/empty/debounced", async () => {
+    const handlers = new Map<string, (...args: unknown[]) => void>();
+    const osc = mock(() => true);
+    const renderer: ClipboardRenderer = {
+      copyToClipboardOSC52: osc,
+      on: (event, listener) => {
+        handlers.set(event, listener as (...args: unknown[]) => void);
+        return renderer;
+      },
+      off: (event) => {
+        handlers.delete(event);
+        return renderer;
+      },
+    };
+
+    const unsub = enableAutoCopyOnSelection(renderer);
+    expect(handlers.has("selection")).toBe(true);
+    const onSelection = handlers.get("selection")!;
+
+    // dragging → ignore
+    onSelection({ isDragging: true, getSelectedText: () => "nope" });
+    expect(osc).not.toHaveBeenCalled();
+
+    // empty → ignore
+    onSelection({ isDragging: false, getSelectedText: () => "  " });
+    expect(osc).not.toHaveBeenCalled();
+
+    // valid selection
+    onSelection({ isDragging: false, getSelectedText: () => "selected" });
+    await Promise.resolve();
+    expect(osc).toHaveBeenCalled();
+
+    // debounce identical text within 400ms
+    const callsBefore = osc.mock.calls.length;
+    onSelection({ isDragging: false, getSelectedText: () => "selected" });
+    await Promise.resolve();
+    expect(osc.mock.calls.length).toBe(callsBefore);
+
+    // missing selection object is safe
+    onSelection(undefined);
+    unsub();
+    expect(handlers.has("selection")).toBe(false);
+  });
 });
 
 describe("messageCopiedToClipboard", () => {
@@ -54,4 +264,8 @@ describe("messageCopiedToClipboard", () => {
   it("collapses whitespace", () => {
     expect(messageCopiedToClipboard("a\n\nb")).toBe("Copied: “a b”");
   });
+
+  it("handles empty after trim", () => {
+    expect(messageCopiedToClipboard("   ")).toBe("Copied to clipboard");
+  });
 });

package/src/services/dashboard-settings-loader.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Tests for loadDashboardSettingsManifests — thin runtime-root wrapper.
+ */
+import { describe, it, expect } from "bun:test";
+import { join } from "node:path";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { loadDashboardSettingsManifests } from "./dashboard-settings-loader";
+
+describe("loadDashboardSettingsManifests", () => {
+  it("loads manifests from an explicit monorepo root", () => {
+    // packages/tui → monorepo root (…/hoox)
+    const monorepoRoot = join(import.meta.dir, "..", "..", "..", "..");
+    const manifests = loadDashboardSettingsManifests(monorepoRoot);
+    expect(Array.isArray(manifests)).toBe(true);
+    // Real checkout has worker dashboard.jsonc files
+    expect(manifests.length).toBeGreaterThan(0);
+    for (const m of manifests) {
+      expect(typeof m.worker).toBe("string");
+      expect(m.worker.length).toBeGreaterThan(0);
+      expect(Array.isArray(m.sections)).toBe(true);
+    }
+  });
+
+  it("returns empty list when workers dir is missing", () => {
+    const emptyRoot = mkdtempSync(join(tmpdir(), "hoox-dash-loader-"));
+    try {
+      const manifests = loadDashboardSettingsManifests(emptyRoot);
+      expect(manifests).toEqual([]);
+    } finally {
+      rmSync(emptyRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("accepts null runtimeRoot and still resolves via fallback root", () => {
+    // null → resolveHooxRuntimeRoot or packages/tui walk-up fallback
+    const manifests = loadDashboardSettingsManifests(null);
+    expect(Array.isArray(manifests)).toBe(true);
+  });
+
+  it("accepts undefined runtimeRoot (default argument path)", () => {
+    const manifests = loadDashboardSettingsManifests();
+    expect(Array.isArray(manifests)).toBe(true);
+  });
+});

package/src/services/tui-connection.test.ts

@@ -16,6 +16,7 @@ import {
   isRemoteAuthReady,
   resolveTuiConnectionEnv,
   shouldUseCliFallback,
+  remoteAuthMissingHint,
 } from "./tui-connection";
 
 describe("tui-connection", () => {
@@ -38,6 +39,18 @@ describe("tui-connection", () => {
         "https://gw.example.com"
       );
     });
+    it("falls back when URL is invalid", () => {
+      expect(getApiHost("not a url")).toBe("not a url");
+      expect(getApiHost("://bad")).toBe("://bad");
+    });
+  });
+
+  describe("remoteAuthMissingHint", () => {
+    it("mentions token and Access credentials", () => {
+      const hint = remoteAuthMissingHint();
+      expect(hint).toContain("HOOX_API_TOKEN");
+      expect(hint).toContain("CF_ACCESS_CLIENT_ID");
+    });
   });
 
   describe("hasApiToken", () => {
@@ -166,6 +179,14 @@ describe("tui-connection", () => {
     it("mentions Access when only Access is set", () => {
       expect(formatAuthBanner(false, "remote", true)).toContain("Access");
     });
+    it("mentions Bearer + Access when both present", () => {
+      expect(formatAuthBanner(true, "remote", true)).toContain(
+        "Bearer + Access"
+      );
+    });
+    it("notes optional token for local mode", () => {
+      expect(formatAuthBanner(false, "local")).toContain("optional");
+    });
   });
 
   describe("getSettingsConnectionSnapshot", () => {

package/src/stores/service-store.test.ts

@@ -41,8 +41,9 @@ import {
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function resetStore() {
-  // Tear down any SSE handles before clearing state (avoids cross-test leaks)
+  // Tear down SSE + reconnect timers before clearing state
   useServiceStore.getState().stopStreams();
+  useServiceStore.getState().resetRetries();
   useServiceStore.setState({
     workers: [],
     tradeStream: [],
@@ -262,12 +263,60 @@ describe("useServiceStore", () => {
 
       // retryCount goes to 5, which is >= MAX_RETRIES (5)
       expect(useServiceStore.getState().connectionStatus).toBe("offline");
+      // Root-cause message is preserved with a retry exhaustion note
       expect(useServiceStore.getState().lastError).toContain(
-        "Connection lost after 5 retries"
+        "gave up after 5 retries"
       );
     });
   });
 
+  // ── Alert triage ──────────────────────────────────────────────────────────
+
+  describe("alert acknowledge / dismiss", () => {
+    it("acknowledgeAlert marks the matching alert", () => {
+      useServiceStore.getState().addAlert({
+        id: "a1",
+        type: "system",
+        severity: "warning",
+        message: "hello",
+        timestamp: Date.now(),
+        acknowledged: false,
+      });
+      useServiceStore.getState().acknowledgeAlert("a1");
+      expect(
+        useServiceStore.getState().alerts.find((a) => a.id === "a1")
+          ?.acknowledged
+      ).toBe(true);
+    });
+
+    it("dismissAlert removes the matching alert", () => {
+      useServiceStore.getState().addAlert({
+        id: "a2",
+        type: "system",
+        severity: "info",
+        message: "bye",
+        timestamp: Date.now(),
+        acknowledged: false,
+      });
+      useServiceStore.getState().dismissAlert("a2");
+      expect(
+        useServiceStore.getState().alerts.find((a) => a.id === "a2")
+      ).toBeUndefined();
+    });
+
+    it("clearLogs empties the log ring", () => {
+      useServiceStore.getState().pushLog({
+        id: "l1",
+        level: "info",
+        message: "x",
+        timestamp: Date.now(),
+      });
+      expect(useServiceStore.getState().logs.length).toBeGreaterThan(0);
+      useServiceStore.getState().clearLogs();
+      expect(useServiceStore.getState().logs).toHaveLength(0);
+    });
+  });
+
   // ── Connection State Machine ──────────────────────────────────────────────
 
   describe("connection state machine", () => {
@@ -329,8 +378,9 @@ describe("useServiceStore", () => {
       useServiceStore.getState().handleConnectionFailure("Final fail");
 
       expect(useServiceStore.getState().connectionStatus).toBe("offline");
+      expect(useServiceStore.getState().lastError).toContain("Final fail");
       expect(useServiceStore.getState().lastError).toContain(
-        "Connection lost after 5 retries"
+        "gave up after 5 retries"
       );
     });
 
@@ -361,11 +411,47 @@ describe("useServiceStore", () => {
       });
       useServiceStore.getState().forceRetry();
 
+      // Immediate transition is polling; deferred fetch may later connect
       expect(useServiceStore.getState().connectionStatus).toBe("polling");
       expect(useServiceStore.getState().retryCount).toBe(0);
       expect(useServiceStore.getState().lastError).toBeNull();
     });
 
+    it("schedules a real reconnect fetch after handleConnectionFailure", async () => {
+      setMockApiData([
+        {
+          id: "w1",
+          name: "worker-1",
+          status: "operational",
+          uptime: 1,
+          cpu: 0,
+          memory: 0,
+          requests: 0,
+          durableObjectCount: 0,
+          edgeCount: 0,
+          version: "1",
+          lastDeployed: 0,
+        },
+      ]);
+      useServiceStore.setState({
+        connectionStatus: "connected",
+        retryCount: 0,
+      });
+      // Fail once → reconnecting with delay
+      setMockApiFailure(true, "blip");
+      await useServiceStore.getState().fetchWorkers();
+      expect(useServiceStore.getState().connectionStatus).toBe("reconnecting");
+      expect(useServiceStore.getState().reconnectDelay).toBeGreaterThan(0);
+
+      // Allow success on the scheduled retry
+      setMockApiFailure(false);
+      // Wait slightly longer than first backoff (1s) for the timer
+      await new Promise((r) => setTimeout(r, 1100));
+      // If network double is wired, we should be connected; if not, still reconnecting
+      const status = useServiceStore.getState().connectionStatus;
+      expect(["connected", "reconnecting", "polling"]).toContain(status);
+    });
+
     it("forceRetry does nothing when not offline", () => {
       useServiceStore.setState({
         connectionStatus: "connected",

package/src/stores/ui-store.test.ts

@@ -24,6 +24,7 @@ function resetStore() {
     modal: null,
     commandPaletteOpen: false,
     previousView: null,
+    statusErrorExpanded: false,
   });
 }
 
@@ -208,6 +209,28 @@ describe("useUIStore", () => {
     });
   });
 
+  // ── Status error diagnostics panel ──────────────────────────────────────
+
+  describe("statusErrorExpanded", () => {
+    it("starts collapsed", () => {
+      expect(useUIStore.getState().statusErrorExpanded).toBe(false);
+    });
+
+    it("toggleStatusErrorExpanded flips the flag", () => {
+      useUIStore.getState().toggleStatusErrorExpanded();
+      expect(useUIStore.getState().statusErrorExpanded).toBe(true);
+      useUIStore.getState().toggleStatusErrorExpanded();
+      expect(useUIStore.getState().statusErrorExpanded).toBe(false);
+    });
+
+    it("setStatusErrorExpanded sets absolute value", () => {
+      useUIStore.getState().setStatusErrorExpanded(true);
+      expect(useUIStore.getState().statusErrorExpanded).toBe(true);
+      useUIStore.getState().setStatusErrorExpanded(false);
+      expect(useUIStore.getState().statusErrorExpanded).toBe(false);
+    });
+  });
+
   // ── goBack ────────────────────────────────────────────────────────────────
 
   describe("goBack", () => {

package/src/test-setup.ts

@@ -227,23 +227,32 @@ async function installNetworkDoubles(): Promise<void> {
     subscribeSSE: subscribeSSEMock,
   });
 
-  // From packages/tui/src → ../../shared/src (sibling package)
+  // From packages/tui/src → ../../shared (sibling package). Cover both source
+  // and dist (package exports point at dist/stores/* for store imports).
   const apiPaths = [
     new URL("../../shared/src/api-client.ts", import.meta.url).href,
     new URL("../../shared/src/api-client.ts", import.meta.url).pathname,
+    new URL("../../shared/dist/api-client.js", import.meta.url).href,
+    new URL("../../shared/dist/api-client.js", import.meta.url).pathname,
     "@hoox-sh/hoox-shared/api-client",
-    // Relative as resolved from packages/shared/src/stores/service-store.ts
+    // Relative as resolved from packages/shared/src|dist/stores/service-store
     "../api-client",
     "../api-client.ts",
+    "../api-client.js",
     "../../../../packages/shared/src/api-client",
+    "../../../../packages/shared/dist/api-client.js",
   ];
   const ssePaths = [
     new URL("../../shared/src/sse.ts", import.meta.url).href,
     new URL("../../shared/src/sse.ts", import.meta.url).pathname,
+    new URL("../../shared/dist/sse.js", import.meta.url).href,
+    new URL("../../shared/dist/sse.js", import.meta.url).pathname,
     "@hoox-sh/hoox-shared/sse",
     "../sse",
     "../sse.ts",
+    "../sse.js",
     "../../../../packages/shared/src/sse",
+    "../../../../packages/shared/dist/sse.js",
   ];
 
   for (const p of apiPaths) {

package/src/types.ts

@@ -112,6 +112,7 @@ export const DEFAULT_SHORTCUTS: ShortcutMap = {
   "Ctrl+B": "TOGGLE SIDEBAR",
   "Ctrl+R": "REFRESH DATA",
   "Ctrl+Q": "QUIT",
+  "Ctrl+Shift+D": "ERROR DIAGNOSTICS",
   Esc: "BACK / CLOSE",
   Tab: "NEXT FOCUS",
   "Shift+Tab": "PREVIOUS FOCUS",

package/src/view-registry.test.ts

@@ -107,9 +107,11 @@ describe("view-registry", () => {
     expect(isRegisteredViewId("")).toBe(false);
   });
 
-  it("action commands include refresh, toggle-sidebar, quit", () => {
+  it("action commands include refresh, reconnect, diagnostics, sidebar, quit", () => {
     const ids = ACTION_COMMANDS.map((c) => c.id);
     expect(ids).toContain("refresh");
+    expect(ids).toContain("force-retry");
+    expect(ids).toContain("expand-error");
     expect(ids).toContain("toggle-sidebar");
     expect(ids).toContain("quit");
   });

package/src/view-registry.tsx

@@ -125,7 +125,7 @@ export const VIEW_REGISTRY: ViewRegistryEntry[] = [
     key: "7",
     keyMod: "ctrl",
     paletteShortcut: "^7",
-    aliases: ["edit", "settings"],
+    aliases: ["edit", "config", "toml", "json"],
     factory: () => <ConfigEditor />,
   },
   {
@@ -346,6 +346,19 @@ export const ACTION_COMMANDS: CommandEntry[] = [
     shortcut: "^R",
     aliases: ["reload"],
   },
+  {
+    id: "force-retry",
+    name: "FORCE RECONNECT",
+    category: "action",
+    aliases: ["retry", "reconnect", "online"],
+  },
+  {
+    id: "expand-error",
+    name: "TOGGLE ERROR DIAGNOSTICS",
+    category: "action",
+    shortcut: "^⇧D",
+    aliases: ["diagnostics", "stderr", "cli-error", "expand-error"],
+  },
   {
     id: "toggle-sidebar",
     name: "TOGGLE SIDEBAR",