@nastechai/agent 0.16.0 → 0.17.0

package/src/lib/dashboard-flags.ts

@@ -0,0 +1,15 @@
+declare global {
+  interface Window {
+    /** Set true by the server only for `nastech dashboard --tui` (or NASTECH_DASHBOARD_TUI=1). */
+    __NASTECH_DASHBOARD_EMBEDDED_CHAT__?: boolean;
+    /** @deprecated Older injected name; treated as on when true. */
+    __NASTECH_DASHBOARD_TUI__?: boolean;
+  }
+}
+
+/** True only when the dashboard was started with embedded TUI Chat (`nastech dashboard --tui`). */
+export function isDashboardEmbeddedChatEnabled(): boolean {
+  if (typeof window === "undefined") return false;
+  if (window.__NASTECH_DASHBOARD_EMBEDDED_CHAT__ === true) return true;
+  return window.__NASTECH_DASHBOARD_TUI__ === true;
+}

package/src/lib/format.ts

@@ -0,0 +1,9 @@
+/**
+ * Format a token count as a human-readable string (e.g. 1M, 128K, 4096).
+ * Strips trailing ".0" for clean round numbers.
+ */
+export function formatTokenCount(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(n % 1_000_000 === 0 ? 0 : 1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(n % 1_000 === 0 ? 0 : 1)}K`;
+  return String(n);
+}

package/src/lib/fuzzy.ts

@@ -0,0 +1,192 @@
+// Lightweight fuzzy subsequence scorer for picker filtering.
+//
+// Matches a query as an ordered subsequence of the target (so `g4o` matches
+// `gpt-4o`) and scores by match quality so callers can rank results. Higher
+// score is a better match. Returns the matched character indices so callers
+// can highlight them.
+//
+// The scoring favours, in rough order: exact full match, prefix match, matches
+// that start on a word boundary (after `-`, `_`, `/`, `.`, space, or a
+// lower→upper case transition), contiguous runs, and earlier matches. This is
+// intentionally simple — no external dependency — but good enough to make
+// `son4` rank `claude-sonnet-4` above an incidental scattered hit.
+//
+// This is a logically identical copy of ui-tui/src/lib/fuzzy.ts (only prettier
+// formatting differs); keep the two in sync. The TUI copy carries the vitest
+// suite (this `web` package has no test runner), so behavioural changes should
+// be validated there.
+
+export interface FuzzyMatch {
+  /** Total score; higher is better. */
+  score: number;
+  /** Indices into the original (non-lowercased) target that were matched. */
+  positions: number[];
+}
+
+const WORD_BOUNDARY = /[-_/.\s]/;
+
+function isBoundary(target: string, index: number): boolean {
+  if (index === 0) {
+    return true;
+  }
+
+  const prev = target[index - 1];
+
+  if (WORD_BOUNDARY.test(prev)) {
+    return true;
+  }
+
+  // camelCase / lower→upper transition (e.g. the `O` in `gptO`).
+  const cur = target[index];
+
+  return (
+    prev === prev.toLowerCase() &&
+    cur !== cur.toLowerCase() &&
+    cur === cur.toUpperCase()
+  );
+}
+
+/**
+ * Score a single query token against a target. Returns null when the token is
+ * not a subsequence of the target. An empty query scores 0 with no positions.
+ */
+export function fuzzyScore(target: string, query: string): FuzzyMatch | null {
+  if (!query) {
+    return { score: 0, positions: [] };
+  }
+
+  const lowerTarget = target.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+
+  const positions: number[] = [];
+  let score = 0;
+  let prevIndex = -1;
+  let searchFrom = 0;
+
+  for (const ch of lowerQuery) {
+    const idx = lowerTarget.indexOf(ch, searchFrom);
+
+    if (idx < 0) {
+      return null;
+    }
+
+    positions.push(idx);
+
+    // Base point for the matched character.
+    score += 1;
+
+    // Contiguous with the previous match → strong bonus.
+    if (prevIndex >= 0 && idx === prevIndex + 1) {
+      score += 5;
+    } else if (prevIndex >= 0) {
+      // Penalise the gap we had to skip (capped), so contiguous beats scattered.
+      score -= Math.min(idx - prevIndex - 1, 3);
+    }
+
+    // Word-boundary / start-of-string matches are meaningful.
+    if (isBoundary(target, idx)) {
+      score += 3;
+    }
+
+    // Matching the very first character of the target is the strongest signal.
+    if (idx === 0) {
+      score += 5;
+    }
+
+    prevIndex = idx;
+    searchFrom = idx + 1;
+  }
+
+  // Prefix bonus: the query matched a contiguous prefix of the target.
+  if (
+    positions.length &&
+    positions[0] === 0 &&
+    positions[positions.length - 1] === positions.length - 1
+  ) {
+    score += 8;
+  }
+
+  // Exact full match dominates everything else.
+  if (lowerTarget === lowerQuery) {
+    score += 20;
+  }
+
+  // Slightly prefer shorter targets when scores are otherwise close, so a
+  // query that fully prefixes a short id beats the same prefix on a long one.
+  score -= lowerTarget.length * 0.01;
+
+  return { score, positions };
+}
+
+/**
+ * Score a target against a whitespace-separated, multi-token query. Every token
+ * must match (AND semantics); the result aggregates per-token scores and the
+ * union of matched positions. Returns null if any token fails to match.
+ */
+export function fuzzyScoreMulti(
+  target: string,
+  query: string,
+): FuzzyMatch | null {
+  const tokens = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+
+  if (!tokens.length) {
+    return { score: 0, positions: [] };
+  }
+
+  let score = 0;
+  const positionSet = new Set<number>();
+
+  for (const token of tokens) {
+    const match = fuzzyScore(target, token);
+
+    if (!match) {
+      return null;
+    }
+
+    score += match.score;
+
+    for (const pos of match.positions) {
+      positionSet.add(pos);
+    }
+  }
+
+  return { score, positions: [...positionSet].sort((a, b) => a - b) };
+}
+
+export interface RankedItem<T> {
+  item: T;
+  score: number;
+  positions: number[];
+}
+
+/**
+ * Filter + rank a list by a fuzzy query against a derived text key. Non-matching
+ * items are dropped; matches are sorted by score (descending), ties broken by
+ * the original index so ordering is stable for equal scores. An empty query
+ * returns every item in original order with no positions.
+ */
+export function fuzzyRank<T>(
+  items: readonly T[],
+  query: string,
+  toText: (item: T) => string,
+): RankedItem<T>[] {
+  const trimmed = query.trim();
+
+  if (!trimmed) {
+    return items.map((item) => ({ item, score: 0, positions: [] }));
+  }
+
+  const ranked: Array<RankedItem<T> & { index: number }> = [];
+
+  items.forEach((item, index) => {
+    const match = fuzzyScoreMulti(toText(item), trimmed);
+
+    if (match) {
+      ranked.push({ item, score: match.score, positions: match.positions, index });
+    }
+  });
+
+  ranked.sort((a, b) => b.score - a.score || a.index - b.index);
+
+  return ranked.map(({ item, score, positions }) => ({ item, score, positions }));
+}

package/src/lib/gatewayClient.ts

@@ -0,0 +1,253 @@
+/**
+ * Browser WebSocket client for the tui_gateway JSON-RPC protocol.
+ *
+ * Speaks the exact same newline-delimited JSON-RPC dialect that the Ink TUI
+ * drives over stdio. The server-side transport abstraction
+ * (tui_gateway/transport.py + ws.py) routes the same dispatcher's writes
+ * onto either stdout or a WebSocket depending on how the client connected.
+ *
+ *   const gw = new GatewayClient()
+ *   await gw.connect()
+ *   const { session_id } = await gw.request<{ session_id: string }>("session.create")
+ *   gw.on("message.delta", (ev) => console.log(ev.payload?.text))
+ *   await gw.request("prompt.submit", { session_id, text: "hi" })
+ */
+
+import { NASTECH_BASE_PATH, getWsTicket } from "@/lib/api";
+
+export type GatewayEventName =
+  | "gateway.ready"
+  | "session.info"
+  | "message.start"
+  | "message.delta"
+  | "message.complete"
+  | "thinking.delta"
+  | "reasoning.delta"
+  | "reasoning.available"
+  | "status.update"
+  | "tool.start"
+  | "tool.progress"
+  | "tool.complete"
+  | "tool.generating"
+  | "clarify.request"
+  | "approval.request"
+  | "sudo.request"
+  | "secret.request"
+  | "background.complete"
+  | "error"
+  | "skin.changed"
+  | (string & {});
+
+export interface GatewayEvent<P = unknown> {
+  type: GatewayEventName;
+  session_id?: string;
+  payload?: P;
+}
+
+export type ConnectionState =
+  | "idle"
+  | "connecting"
+  | "open"
+  | "closed"
+  | "error";
+
+interface Pending {
+  resolve: (v: unknown) => void;
+  reject: (e: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
+
+/** Wildcard listener key: subscribe to every event regardless of type. */
+const ANY = "*";
+
+export class GatewayClient {
+  private ws: WebSocket | null = null;
+  private reqId = 0;
+  private pending = new Map<string, Pending>();
+  private listeners = new Map<string, Set<(ev: GatewayEvent) => void>>();
+  private _state: ConnectionState = "idle";
+  private stateListeners = new Set<(s: ConnectionState) => void>();
+
+  get state(): ConnectionState {
+    return this._state;
+  }
+
+  private setState(s: ConnectionState) {
+    if (this._state === s) return;
+    this._state = s;
+    for (const cb of this.stateListeners) cb(s);
+  }
+
+  onState(cb: (s: ConnectionState) => void): () => void {
+    this.stateListeners.add(cb);
+    cb(this._state);
+    return () => this.stateListeners.delete(cb);
+  }
+
+  /** Subscribe to a specific event type. Returns an unsubscribe function. */
+  on<P = unknown>(
+    type: GatewayEventName,
+    cb: (ev: GatewayEvent<P>) => void,
+  ): () => void {
+    let set = this.listeners.get(type);
+    if (!set) {
+      set = new Set();
+      this.listeners.set(type, set);
+    }
+    set.add(cb as (ev: GatewayEvent) => void);
+    return () => set!.delete(cb as (ev: GatewayEvent) => void);
+  }
+
+  /** Subscribe to every event (fires after type-specific listeners). */
+  onAny(cb: (ev: GatewayEvent) => void): () => void {
+    return this.on(ANY as GatewayEventName, cb);
+  }
+
+  async connect(token?: string): Promise<void> {
+    if (this._state === "open" || this._state === "connecting") return;
+    this.setState("connecting");
+
+    // Gated mode: legacy ``?token=`` is rejected by ``_ws_auth_ok``; the
+    // SPA must fetch a single-use ticket via /api/auth/ws-ticket instead.
+    // Explicit ``token`` overrides the gate check (test-only path).
+    let authParamName: string;
+    let authParamValue: string;
+    if (token) {
+      authParamName = "token";
+      authParamValue = token;
+    } else if (window.__NASTECH_AUTH_REQUIRED__) {
+      const { ticket } = await getWsTicket();
+      authParamName = "ticket";
+      authParamValue = ticket;
+    } else {
+      authParamName = "token";
+      authParamValue = window.__NASTECH_SESSION_TOKEN__ ?? "";
+      if (!authParamValue) {
+        this.setState("error");
+        throw new Error(
+          "Session token not available — page must be served by the NasTech dashboard",
+        );
+      }
+    }
+
+    const scheme = location.protocol === "https:" ? "wss:" : "ws:";
+    const ws = new WebSocket(
+      `${scheme}//${location.host}${NASTECH_BASE_PATH}/api/ws?${authParamName}=${encodeURIComponent(authParamValue)}`,
+    );
+    this.ws = ws;
+
+    // Register message + close BEFORE awaiting open — the server emits
+    // `gateway.ready` immediately after accept, so a listener attached
+    // after the open promise resolves can race past it and drop the
+    // initial skin payload.
+    ws.addEventListener("message", (ev) => {
+      try {
+        this.dispatch(JSON.parse(ev.data));
+      } catch {
+        /* malformed frame — ignore */
+      }
+    });
+
+    ws.addEventListener("close", () => {
+      this.setState("closed");
+      this.rejectAllPending(new Error("WebSocket closed"));
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      const onOpen = () => {
+        ws.removeEventListener("error", onError);
+        this.setState("open");
+        resolve();
+      };
+      const onError = () => {
+        ws.removeEventListener("open", onOpen);
+        this.setState("error");
+        reject(new Error("WebSocket connection failed"));
+      };
+      ws.addEventListener("open", onOpen, { once: true });
+      ws.addEventListener("error", onError, { once: true });
+    });
+  }
+
+  close() {
+    this.ws?.close();
+    this.ws = null;
+  }
+
+  private dispatch(msg: Record<string, unknown>) {
+    const id = msg.id as string | undefined;
+
+    if (id !== undefined && this.pending.has(id)) {
+      const p = this.pending.get(id)!;
+      this.pending.delete(id);
+      clearTimeout(p.timer);
+
+      const err = msg.error as { message?: string } | undefined;
+      if (err) p.reject(new Error(err.message ?? "request failed"));
+      else p.resolve(msg.result);
+      return;
+    }
+
+    if (msg.method !== "event") return;
+
+    const params = (msg.params ?? {}) as GatewayEvent;
+    if (typeof params.type !== "string") return;
+
+    for (const cb of this.listeners.get(params.type) ?? []) cb(params);
+    for (const cb of this.listeners.get(ANY) ?? []) cb(params);
+  }
+
+  private rejectAllPending(err: Error) {
+    for (const p of this.pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+
+  /** Send a JSON-RPC request. Rejects on error response or timeout. */
+  request<T = unknown>(
+    method: string,
+    params: Record<string, unknown> = {},
+    timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+  ): Promise<T> {
+    if (!this.ws || this._state !== "open") {
+      return Promise.reject(
+        new Error(`gateway not connected (state=${this._state})`),
+      );
+    }
+
+    const id = `w${++this.reqId}`;
+
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pending.delete(id)) {
+          reject(new Error(`request timed out: ${method}`));
+        }
+      }, timeoutMs);
+
+      this.pending.set(id, {
+        resolve: (v) => resolve(v as T),
+        reject,
+        timer,
+      });
+
+      try {
+        this.ws!.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    });
+  }
+}
+
+declare global {
+  interface Window {
+    __NASTECH_SESSION_TOKEN__?: string;
+    __NASTECH_AUTH_REQUIRED__?: boolean;
+  }
+}

package/src/lib/nested.ts

@@ -0,0 +1,23 @@
+export function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  const parts = path.split(".");
+  let cur: unknown = obj;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== "object") return undefined;
+    cur = (cur as Record<string, unknown>)[p];
+  }
+  return cur;
+}
+
+export function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): Record<string, unknown> {
+  const clone = structuredClone(obj);
+  const parts = path.split(".");
+  let cur: Record<string, unknown> = clone;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (cur[parts[i]] == null || typeof cur[parts[i]] !== "object") {
+      cur[parts[i]] = {};
+    }
+    cur = cur[parts[i]] as Record<string, unknown>;
+  }
+  cur[parts[parts.length - 1]] = value;
+  return clone;
+}

package/src/lib/resolve-page-title.ts

@@ -0,0 +1,41 @@
+import type { Translations } from "@/i18n/types";
+
+const BUILTIN: Record<string, keyof Translations["app"]["nav"]> = {
+  "/chat": "chat",
+  "/sessions": "sessions",
+  "/analytics": "analytics",
+  "/models": "models",
+  "/logs": "logs",
+  "/cron": "cron",
+  "/skills": "skills",
+  "/plugins": "plugins",
+  "/profiles": "profiles",
+  "/config": "config",
+  "/env": "keys",
+  "/docs": "documentation",
+};
+
+export function resolvePageTitle(
+  pathname: string,
+  t: Translations,
+  pluginTabs: { path: string; label: string }[],
+): string {
+  const normalized = pathname.replace(/\/$/, "") || "/";
+  if (normalized === "/") {
+    return t.app.nav.sessions;
+  }
+  const plugin = pluginTabs.find((p) => p.path === normalized);
+  if (plugin) {
+    return plugin.label;
+  }
+  const key = BUILTIN[normalized];
+  if (key) {
+    return t.app.nav[key];
+  }
+  // Derive title from pathname: "/profiles" → "Profiles"
+  const segment = normalized.slice(1);
+  if (segment) {
+    return segment.charAt(0).toUpperCase() + segment.slice(1);
+  }
+  return t.app.webUi;
+}