@hoox-sh/hoox-shared 1.2.0

package/dist/session.js

@@ -0,0 +1,261 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/path-utils.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+function createHooxPath(path) {
+  return path;
+}
+function getHooxHome() {
+  try {
+    const override = process.env.HOOX_HOME?.trim();
+    if (override) {
+      return createHooxPath(resolve(override));
+    }
+    const home = homedir();
+    if (!home || home.length === 0) {
+      return createHooxPath(resolve(process.cwd(), ".hoox"));
+    }
+    return createHooxPath(join(home, ".hoox"));
+  } catch {
+    return createHooxPath(resolve(process.cwd(), ".hoox"));
+  }
+}
+function isHooxSetupRoot(dir) {
+  if (!dir)
+    return false;
+  try {
+    const root = resolve(dir);
+    return existsSync(join(root, "wrangler.jsonc")) && existsSync(join(root, "packages", "cli", "package.json"));
+  } catch {
+    return false;
+  }
+}
+function findHooxSetupRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  for (;; ) {
+    if (isHooxSetupRoot(dir))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function resolveHooxRuntimeRoot(options) {
+  const env = options?.env ?? process.env;
+  const cwd = resolve(options?.cwd ?? process.cwd());
+  const globalRepo = getHooxRepoPath();
+  const envRepo = env.HOOX_REPO?.trim();
+  if (envRepo) {
+    const resolved = resolve(envRepo);
+    if (isHooxSetupRoot(resolved)) {
+      return {
+        root: resolved,
+        source: "env",
+        checked: {
+          env: resolved,
+          cwd: findHooxSetupRoot(cwd),
+          global: globalRepo
+        }
+      };
+    }
+    return {
+      root: null,
+      source: "env",
+      checked: {
+        env: resolved,
+        cwd: findHooxSetupRoot(cwd),
+        global: globalRepo
+      }
+    };
+  }
+  const local = findHooxSetupRoot(cwd);
+  if (local) {
+    return {
+      root: local,
+      source: "cwd",
+      checked: { cwd: local, global: globalRepo }
+    };
+  }
+  if (isHooxSetupRoot(globalRepo)) {
+    return {
+      root: globalRepo,
+      source: "global",
+      checked: { cwd: null, global: globalRepo }
+    };
+  }
+  return {
+    root: null,
+    source: "none",
+    checked: { cwd: null, global: globalRepo }
+  };
+}
+function getTuiEntryCandidates(runtimeRoot) {
+  const root = resolve(runtimeRoot);
+  return [
+    join(root, "packages", "tui", "src", "main.tsx"),
+    join(root, "packages", "tui", "dist", "main.js"),
+    join(root, "packages", "tui", "src", "main.ts")
+  ];
+}
+function resolveHooxPath(relativePath) {
+  if (!relativePath || typeof relativePath !== "string") {
+    throw new Error("relativePath must be a non-empty string");
+  }
+  if (relativePath.includes("..")) {
+    throw new Error(`Path traversal detected in relativePath: "${relativePath}"`);
+  }
+  const normalizedPath = relativePath.replace(/\\/g, "/");
+  const hooxHome = getHooxHome();
+  const fullPath = join(hooxHome, normalizedPath);
+  const resolvedPath = resolve(fullPath);
+  const resolvedHome = resolve(hooxHome);
+  if (!resolvedPath.startsWith(resolvedHome)) {
+    throw new Error(`Resolved path "${resolvedPath}" is outside Hoox home directory`);
+  }
+  return createHooxPath(resolvedPath);
+}
+function isWithinHooxHome(path) {
+  try {
+    const hooxHome = getHooxHome();
+    const resolvedPath = resolve(path);
+    const resolvedHome = resolve(hooxHome);
+    return resolvedPath.startsWith(resolvedHome);
+  } catch {
+    return false;
+  }
+}
+function getRelativeHooxPath(absolutePath) {
+  try {
+    if (!isWithinHooxHome(absolutePath)) {
+      return null;
+    }
+    const hooxHome = getHooxHome();
+    const resolvedPath = resolve(absolutePath);
+    const resolvedHome = resolve(hooxHome);
+    const relativePath = resolvedPath.slice(resolvedHome.length);
+    return relativePath.startsWith("/") || relativePath.startsWith("\\") ? relativePath.slice(1) : relativePath;
+  } catch {
+    return null;
+  }
+}
+function getHooxRepoPath() {
+  return resolveHooxPath("repo");
+}
+function getHooxConfigDir() {
+  return resolveHooxPath("config");
+}
+function getHooxDataDir() {
+  return resolveHooxPath("data");
+}
+function getHooxWranglerPath() {
+  return resolveHooxPath("config/wrangler.jsonc");
+}
+function getHooxStatePath() {
+  return resolveHooxPath("data/state.json");
+}
+
+// src/session.ts
+import { z } from "zod";
+var SessionStateFileSchema = z.object({
+  activeView: z.string().optional(),
+  sidebarExpanded: z.boolean().optional(),
+  windowSize: z.object({
+    cols: z.number().int().positive(),
+    rows: z.number().int().positive()
+  }).optional(),
+  lastData: z.number().nonnegative().optional(),
+  savedAt: z.string().optional()
+}).strict();
+var TUI_STATE_DIR = ".tui-state";
+function getSessionFilePath() {
+  try {
+    const hooxHome = getHooxHome();
+    return `${hooxHome}/${TUI_STATE_DIR}/session.json`;
+  } catch {
+    return `${process.cwd()}/${TUI_STATE_DIR}/session.json`;
+  }
+}
+var DEFAULT_SESSION = {
+  activeView: "dashboard",
+  sidebarExpanded: true,
+  windowSize: { cols: 80, rows: 24 },
+  lastData: 0,
+  savedAt: new Date().toISOString()
+};
+async function saveSession(activeView, sidebarExpanded, windowSize, lastData) {
+  try {
+    const session = {
+      activeView,
+      sidebarExpanded,
+      windowSize,
+      lastData,
+      savedAt: new Date().toISOString()
+    };
+    await Bun.write(getSessionFilePath(), JSON.stringify(session, null, 2));
+  } catch (error) {
+    console.error("[session] Failed to save session:", error.message);
+  }
+}
+async function restoreSession() {
+  try {
+    const file = Bun.file(getSessionFilePath());
+    const exists = await file.exists();
+    if (!exists)
+      return { ...DEFAULT_SESSION };
+    const raw = await file.text();
+    const result = SessionStateFileSchema.safeParse(JSON.parse(raw));
+    const parsed = result.success ? result.data : {};
+    return {
+      activeView: validateViewId(parsed.activeView) ? parsed.activeView : DEFAULT_SESSION.activeView,
+      sidebarExpanded: typeof parsed.sidebarExpanded === "boolean" ? parsed.sidebarExpanded : DEFAULT_SESSION.sidebarExpanded,
+      windowSize: parsed.windowSize ?? DEFAULT_SESSION.windowSize,
+      lastData: typeof parsed.lastData === "number" ? parsed.lastData : DEFAULT_SESSION.lastData,
+      savedAt: parsed.savedAt ?? DEFAULT_SESSION.savedAt
+    };
+  } catch {
+    return { ...DEFAULT_SESSION };
+  }
+}
+var VALID_VIEW_IDS = new Set([
+  "dashboard",
+  "workers",
+  "worker-detail",
+  "trade-monitor",
+  "logs-viewer",
+  "service-manager",
+  "config-editor",
+  "setup-wizard",
+  "settings",
+  "queue-depth",
+  "kv-viewer",
+  "secrets-viewer",
+  "db-query",
+  "ai-chat",
+  "edge-topology",
+  "worker-settings"
+]);
+function validateViewId(id) {
+  return typeof id === "string" && VALID_VIEW_IDS.has(id);
+}
+export {
+  saveSession,
+  restoreSession
+};

package/dist/sse.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * SSE Streaming Client — subscribes to Server-Sent Events from the Hoox
+ * operator management API.
+ *
+ * Uses Bun's native fetch with ReadableStream reader for SSE parsing.
+ * Supports reconnection with exponential backoff.
+ * Events must be JSON-encoded in the "data:" field.
+ *
+ * Auth: operator transport profile (Bearer + optional Access service token).
+ */
+import { type OperatorTransportEnv, type OperatorTransportProfile } from "./operator-transport";
+export type SSECallback<T> = (event: T) => void;
+export type SSEStatusCallback = (status: "connected" | "reconnecting" | "disconnected") => void;
+interface SSESubscription {
+    abort: () => void;
+}
+export interface SubscribeSSEOptions {
+    transport?: OperatorTransportProfile;
+    transportEnv?: OperatorTransportEnv;
+}
+/**
+ * Subscribe to an SSE endpoint and invoke the callback for each parsed event.
+ *
+ * Automatically reconnects on connection loss with exponential backoff.
+ * Returns an object with an `abort()` method to cancel the subscription.
+ *
+ * @param path     API path (e.g. "/v1/trades/stream")
+ * @param callback Called with each parsed event of type T
+ * @param onStatus Optional callback for connection status updates
+ * @param options  Optional transport profile override
+ * @returns        Subscription controller with abort method
+ */
+export declare function subscribeSSE<T>(path: string, callback: SSECallback<T>, onStatus?: SSEStatusCallback, options?: SubscribeSSEOptions): SSESubscription;
+export {};
+//# sourceMappingURL=sse.d.ts.map

package/dist/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../src/sse.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC9B,MAAM,sBAAsB,CAAC;AAS9B,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAChD,MAAM,MAAM,iBAAiB,GAAG,CAC9B,MAAM,EAAE,WAAW,GAAG,cAAc,GAAG,cAAc,KAClD,IAAI,CAAC;AAEV,UAAU,eAAe;IACvB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,wBAAwB,CAAC;IACrC,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EACxB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,OAAO,CAAC,EAAE,mBAAmB,GAC5B,eAAe,CAsFjB"}

package/dist/sse.js

@@ -0,0 +1,154 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/operator-transport.ts
+function stripTrailingSlashes(url) {
+  return url.replace(/\/+$/, "");
+}
+function parseTransport(raw) {
+  if (!raw)
+    return null;
+  const v = raw.trim().toLowerCase();
+  if (VALID_TRANSPORTS.has(v)) {
+    return v;
+  }
+  return null;
+}
+function resolveOperatorTransportProfile(env = process.env, options = {}) {
+  const accessClientId = env.CF_ACCESS_CLIENT_ID?.trim() ?? "";
+  const accessClientSecret = env.CF_ACCESS_CLIENT_SECRET?.trim() ?? "";
+  const hasAccess = Boolean(accessClientId && accessClientSecret);
+  const explicit = parseTransport(env.HOOX_TRANSPORT) ?? parseTransport(options.configTransport);
+  const transport = explicit ?? (hasAccess ? "access" : "public");
+  const apiFromEnv = env.HOOX_API_URL?.trim();
+  const apiFromConfig = options.configApiUrl?.trim();
+  const tokenFromEnv = env.HOOX_API_TOKEN?.trim();
+  const tokenFromConfig = options.configApiToken?.trim();
+  return {
+    transport,
+    apiBase: stripTrailingSlashes(apiFromEnv || apiFromConfig || DEFAULT_API_BASE),
+    bearerToken: tokenFromEnv || tokenFromConfig || "",
+    accessClientId,
+    accessClientSecret
+  };
+}
+function buildOperatorAuthHeaders(profile) {
+  const headers = {};
+  if (profile.bearerToken) {
+    headers.Authorization = `Bearer ${profile.bearerToken}`;
+  }
+  const useAccessHeaders = profile.transport === "access" || Boolean(profile.accessClientId) && Boolean(profile.accessClientSecret);
+  if (useAccessHeaders && profile.accessClientId && profile.accessClientSecret) {
+    headers["CF-Access-Client-Id"] = profile.accessClientId;
+    headers["CF-Access-Client-Secret"] = profile.accessClientSecret;
+  }
+  return headers;
+}
+function hasOperatorClientCredentials(profile) {
+  if (profile.bearerToken)
+    return true;
+  return Boolean(profile.accessClientId && profile.accessClientSecret);
+}
+function operatorUrl(profile, path) {
+  const base = profile.apiBase.replace(/\/+$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${p}`;
+}
+var DEFAULT_API_BASE = "http://localhost:8787", VALID_TRANSPORTS;
+var init_operator_transport = __esm(() => {
+  VALID_TRANSPORTS = new Set([
+    "public",
+    "access",
+    "mtls",
+    "tunnel"
+  ]);
+});
+
+// src/sse.ts
+var exports_sse = {};
+__export(exports_sse, {
+  subscribeSSE: () => subscribeSSE
+});
+function subscribeSSE(path, callback, onStatus, options) {
+  let aborted = false;
+  const profile = options?.transport ?? (options?.transportEnv ? resolveOperatorTransportProfile(options.transportEnv) : resolveOperatorTransportProfile());
+  const run = async () => {
+    let attempt = 0;
+    while (!aborted && attempt < MAX_RECONNECT_ATTEMPTS) {
+      try {
+        const url = operatorUrl(profile, path);
+        const response = await fetch(url, {
+          headers: {
+            Accept: "text/event-stream",
+            ...buildOperatorAuthHeaders(profile)
+          }
+        });
+        if (!response.ok || !response.body) {
+          throw new Error(`SSE connection failed: HTTP ${response.status}`);
+        }
+        attempt = 0;
+        onStatus?.("connected");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        while (!aborted) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("data: ")) {
+              try {
+                const parsed = JSON.parse(trimmed.slice(6));
+                callback(parsed);
+              } catch {}
+            }
+          }
+        }
+      } catch {
+        if (aborted)
+          break;
+        onStatus?.("reconnecting");
+        const delay = Math.min(RECONNECT_BASE_MS * Math.pow(2, attempt), RECONNECT_MAX_MS);
+        attempt++;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    if (!aborted) {
+      onStatus?.("disconnected");
+    }
+  };
+  run();
+  return {
+    abort: () => {
+      aborted = true;
+    }
+  };
+}
+var RECONNECT_BASE_MS = 1000, RECONNECT_MAX_MS = 16000, MAX_RECONNECT_ATTEMPTS = 10;
+var init_sse = __esm(() => {
+  init_operator_transport();
+});
+init_sse();
+
+export {
+  subscribeSSE
+};

package/dist/stores/config-store.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ViewId, LogFilter, NotificationPreferences } from "../types";
+export interface ConfigState {
+    theme: "dark" | "light";
+    refreshIntervalMs: number;
+    defaultView: ViewId;
+    activeExchanges: string[];
+    keyboardShortcuts: Record<string, string>;
+    logFilters: LogFilter;
+    notifications: NotificationPreferences;
+    soundEnabled: boolean;
+}
+interface ConfigActions {
+    /** Merge partial config — only provided fields are updated. */
+    updateConfig: (partial: Partial<ConfigState>) => void;
+    /** Reset all settings to factory defaults. */
+    resetDefaults: () => void;
+    /** Update a single keyboard shortcut. */
+    setShortcut: (action: string, key: string) => void;
+    /** Toggle a specific notification channel. */
+    toggleNotification: (channel: keyof NotificationPreferences) => void;
+}
+export declare const useConfigStore: import("zustand").UseBoundStore<Omit<Omit<import("zustand").StoreApi<ConfigState & ConfigActions>, "setState" | "persist"> & {
+    setState(partial: (ConfigState & ConfigActions) | Partial<ConfigState & ConfigActions> | ((state: ConfigState & ConfigActions) => (ConfigState & ConfigActions) | Partial<ConfigState & ConfigActions>), replace?: false | undefined): unknown;
+    setState(state: (ConfigState & ConfigActions) | ((state: ConfigState & ConfigActions) => ConfigState & ConfigActions), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<ConfigState & ConfigActions, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ConfigState & ConfigActions) => void) => () => void;
+        onFinishHydration: (fn: (state: ConfigState & ConfigActions) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<ConfigState & ConfigActions, unknown, unknown>>;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: (ConfigState & ConfigActions) | Partial<ConfigState & ConfigActions> | ((state: {
+        theme: "dark" | "light";
+        refreshIntervalMs: number;
+        defaultView: ViewId;
+        activeExchanges: string[];
+        keyboardShortcuts: {
+            [x: string]: string;
+        };
+        logFilters: {
+            levels: import("..").LogLevel[];
+            workers: string[];
+            searchText: string;
+        };
+        notifications: {
+            alerts: boolean;
+            trades: boolean;
+            debug: boolean;
+            system: boolean;
+        };
+        soundEnabled: boolean;
+        updateConfig: (partial: Partial<ConfigState>) => void;
+        resetDefaults: () => void;
+        setShortcut: (action: string, key: string) => void;
+        toggleNotification: (channel: keyof NotificationPreferences) => void;
+    }) => void), shouldReplace?: false): unknown;
+    setState(nextStateOrUpdater: (ConfigState & ConfigActions) | ((state: {
+        theme: "dark" | "light";
+        refreshIntervalMs: number;
+        defaultView: ViewId;
+        activeExchanges: string[];
+        keyboardShortcuts: {
+            [x: string]: string;
+        };
+        logFilters: {
+            levels: import("..").LogLevel[];
+            workers: string[];
+            searchText: string;
+        };
+        notifications: {
+            alerts: boolean;
+            trades: boolean;
+            debug: boolean;
+            system: boolean;
+        };
+        soundEnabled: boolean;
+        updateConfig: (partial: Partial<ConfigState>) => void;
+        resetDefaults: () => void;
+        setShortcut: (action: string, key: string) => void;
+        toggleNotification: (channel: keyof NotificationPreferences) => void;
+    }) => void), shouldReplace: true): unknown;
+}>;
+export {};
+//# sourceMappingURL=config-store.d.ts.map

package/dist/stores/config-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-store.d.ts","sourceRoot":"","sources":["../../src/stores/config-store.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiBH,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAoF3E,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,UAAU,EAAE,SAAS,CAAC;IACtB,aAAa,EAAE,uBAAuB,CAAC;IACvC,YAAY,EAAE,OAAO,CAAC;CACvB;AAID,UAAU,aAAa;IACrB,+DAA+D;IAC/D,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;IACtD,8CAA8C;IAC9C,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,yCAAyC;IACzC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,8CAA8C;IAC9C,kBAAkB,EAAE,CAAC,OAAO,EAAE,MAAM,uBAAuB,KAAK,IAAI,CAAC;CACtE;AAiBD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;eAtClB,MAAM,GAAG,OAAO;2BACJ,MAAM;qBACZ,MAAM;;;;;;;;;;;;;;;;sBAKL,OAAO;sBAOP,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI;uBAEtC,MAAM,IAAI;qBAEZ,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI;4BAE9B,CAAC,OAAO,EAAE,MAAM,uBAAuB,KAAK,IAAI;;;eApB7D,MAAM,GAAG,OAAO;2BACJ,MAAM;qBACZ,MAAM;;;;;;;;;;;;;;;;sBAKL,OAAO;sBAOP,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI;uBAEtC,MAAM,IAAI;qBAEZ,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI;4BAE9B,CAAC,OAAO,EAAE,MAAM,uBAAuB,KAAK,IAAI;;EA+ErE,CAAC"}