llm-kb 0.4.2 → 0.6.0

package/bin/server-QC5SN6T4.js

@@ -0,0 +1,1069 @@
+import {
+  createChat,
+  parseCitations
+} from "./chunk-Y2764FFH.js";
+import "./chunk-3WBSKCCH.js";
+import "./chunk-3YMNGUZZ.js";
+import "./chunk-LDHOKBJA.js";
+import "./chunk-5PYKQQLA.js";
+import "./chunk-EAQYK3U2.js";
+
+// src/web/server.ts
+import { Hono } from "hono";
+
+// node_modules/@hono/node-server/dist/index.mjs
+import { createServer as createServerHTTP } from "http";
+import { Http2ServerRequest as Http2ServerRequest2, constants as h2constants } from "http2";
+import { Http2ServerRequest } from "http2";
+import { Readable } from "stream";
+import crypto from "crypto";
+var RequestError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+};
+var toRequestError = (e) => {
+  if (e instanceof RequestError) {
+    return e;
+  }
+  return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var Request = class extends GlobalRequest {
+  constructor(input, options) {
+    if (typeof input === "object" && getRequestCache in input) {
+      input = input[getRequestCache]();
+    }
+    if (typeof options?.body?.getReader !== "undefined") {
+      ;
+      options.duplex ??= "half";
+    }
+    super(input, options);
+  }
+};
+var newHeadersFromIncoming = (incoming) => {
+  const headerRecord = [];
+  const rawHeaders = incoming.rawHeaders;
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const { [i]: key, [i + 1]: value } = rawHeaders;
+    if (key.charCodeAt(0) !== /*:*/
+    58) {
+      headerRecord.push([key, value]);
+    }
+  }
+  return new Headers(headerRecord);
+};
+var wrapBodyStream = /* @__PURE__ */ Symbol("wrapBodyStream");
+var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+  const init = {
+    method,
+    headers,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request(url, init);
+    Object.defineProperty(req, "method", {
+      get() {
+        return "TRACE";
+      }
+    });
+    return req;
+  }
+  if (!(method === "GET" || method === "HEAD")) {
+    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+      init.body = new ReadableStream({
+        start(controller) {
+          controller.enqueue(incoming.rawBody);
+          controller.close();
+        }
+      });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
+    } else {
+      init.body = Readable.toWeb(incoming);
+    }
+  }
+  return new Request(url, init);
+};
+var getRequestCache = /* @__PURE__ */ Symbol("getRequestCache");
+var requestCache = /* @__PURE__ */ Symbol("requestCache");
+var incomingKey = /* @__PURE__ */ Symbol("incomingKey");
+var urlKey = /* @__PURE__ */ Symbol("urlKey");
+var headersKey = /* @__PURE__ */ Symbol("headersKey");
+var abortControllerKey = /* @__PURE__ */ Symbol("abortControllerKey");
+var getAbortController = /* @__PURE__ */ Symbol("getAbortController");
+var requestPrototype = {
+  get method() {
+    return this[incomingKey].method || "GET";
+  },
+  get url() {
+    return this[urlKey];
+  },
+  get headers() {
+    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+  },
+  [getAbortController]() {
+    this[getRequestCache]();
+    return this[abortControllerKey];
+  },
+  [getRequestCache]() {
+    this[abortControllerKey] ||= new AbortController();
+    return this[requestCache] ||= newRequestFromIncoming(
+      this.method,
+      this[urlKey],
+      this.headers,
+      this[incomingKey],
+      this[abortControllerKey]
+    );
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "cache",
+  "credentials",
+  "destination",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal",
+  "keepalive"
+].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    get() {
+      return this[getRequestCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    value: function() {
+      return this[getRequestCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+var newRequest = (incoming, defaultHostname) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const incomingUrl = incoming.url || "";
+  if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
+  (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+    if (incoming instanceof Http2ServerRequest) {
+      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+    }
+    try {
+      const url2 = new URL(incomingUrl);
+      req[urlKey] = url2.href;
+    } catch (e) {
+      throw new RequestError("Invalid absolute URL", { cause: e });
+    }
+    return req;
+  }
+  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host) {
+    throw new RequestError("Missing host header");
+  }
+  let scheme;
+  if (incoming instanceof Http2ServerRequest) {
+    scheme = incoming.scheme;
+    if (!(scheme === "http" || scheme === "https")) {
+      throw new RequestError("Unsupported scheme");
+    }
+  } else {
+    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+  }
+  const url = new URL(`${scheme}://${host}${incomingUrl}`);
+  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url.href;
+  return req;
+};
+var responseCache = /* @__PURE__ */ Symbol("responseCache");
+var getResponseCache = /* @__PURE__ */ Symbol("getResponseCache");
+var cacheKey = /* @__PURE__ */ Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+  #body;
+  #init;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    let headers;
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+        headers = new Headers(init.#init.headers);
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+      ;
+      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(
+          cache[2] || { "content-type": "text/plain; charset=UTF-8" }
+        );
+      }
+      return cache[2];
+    }
+    return this[getResponseCache]().headers;
+  }
+  get status() {
+    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+  }
+  get ok() {
+    const status = this.status;
+    return status >= 200 && status < 300;
+  }
+};
+["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const cancel = (error) => {
+    reader.cancel(error).catch(() => {
+    });
+  };
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+  });
+  function handleStreamError(error) {
+    if (error) {
+      writable.destroy(error);
+    }
+  }
+  function onDrain() {
+    reader.read().then(flow, handleStreamError);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
+        return reader.read().then(flow, handleStreamError);
+      }
+    } catch (e) {
+      handleStreamError(e);
+    }
+  }
+}
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  if (!(headers instanceof Headers)) {
+    headers = new Headers(headers ?? void 0);
+  }
+  const cookies = [];
+  for (const [k, v] of headers) {
+    if (k === "set-cookie") {
+      cookies.push(v);
+    } else {
+      res[k] = v;
+    }
+  }
+  if (cookies.length > 0) {
+    res["set-cookie"] = cookies;
+  }
+  res["content-type"] ??= "text/plain; charset=UTF-8";
+  return res;
+};
+var X_ALREADY_SENT = "x-hono-already-sent";
+if (typeof global.crypto === "undefined") {
+  global.crypto = crypto;
+}
+var outgoingEnded = /* @__PURE__ */ Symbol("outgoingEnded");
+var incomingDraining = /* @__PURE__ */ Symbol("incomingDraining");
+var DRAIN_TIMEOUT_MS = 500;
+var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+var drainIncoming = (incoming) => {
+  const incomingWithDrainState = incoming;
+  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+    return;
+  }
+  incomingWithDrainState[incomingDraining] = true;
+  if (incoming instanceof Http2ServerRequest2) {
+    try {
+      ;
+      incoming.stream?.close?.(h2constants.NGHTTP2_NO_ERROR);
+    } catch {
+    }
+    return;
+  }
+  let bytesRead = 0;
+  const cleanup = () => {
+    clearTimeout(timer);
+    incoming.off("data", onData);
+    incoming.off("end", cleanup);
+    incoming.off("error", cleanup);
+  };
+  const forceClose = () => {
+    cleanup();
+    const socket = incoming.socket;
+    if (socket && !socket.destroyed) {
+      socket.destroySoon();
+    }
+  };
+  const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+  timer.unref?.();
+  const onData = (chunk) => {
+    bytesRead += chunk.length;
+    if (bytesRead > MAX_DRAIN_BYTES) {
+      forceClose();
+    }
+  };
+  incoming.on("data", onData);
+  incoming.on("end", cleanup);
+  incoming.on("error", cleanup);
+  incoming.resume();
+};
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError = (e) => new Response(null, {
+  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+});
+var handleResponseError = (e, outgoing) => {
+  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    console.info("The user aborted a request.");
+  } else {
+    console.error(e);
+    if (!outgoing.headersSent) {
+      outgoing.writeHead(500, { "Content-Type": "text/plain" });
+    }
+    outgoing.end(`Error: ${err.message}`);
+    outgoing.destroy(err);
+  }
+};
+var flushHeaders = (outgoing) => {
+  if ("flushHeaders" in outgoing && outgoing.writable) {
+    outgoing.flushHeaders();
+  }
+};
+var responseViaCache = async (res, outgoing) => {
+  let [status, body, header] = res[cacheKey];
+  let hasContentLength = false;
+  if (!header) {
+    header = { "content-type": "text/plain; charset=UTF-8" };
+  } else if (header instanceof Headers) {
+    hasContentLength = header.has("content-length");
+    header = buildOutgoingHttpHeaders(header);
+  } else if (Array.isArray(header)) {
+    const headerObj = new Headers(header);
+    hasContentLength = headerObj.has("content-length");
+    header = buildOutgoingHttpHeaders(headerObj);
+  } else {
+    for (const key in header) {
+      if (key.length === 14 && key.toLowerCase() === "content-length") {
+        hasContentLength = true;
+        break;
+      }
+    }
+  }
+  if (!hasContentLength) {
+    if (typeof body === "string") {
+      header["Content-Length"] = Buffer.byteLength(body);
+    } else if (body instanceof Uint8Array) {
+      header["Content-Length"] = body.byteLength;
+    } else if (body instanceof Blob) {
+      header["Content-Length"] = body.size;
+    }
+  }
+  outgoing.writeHead(status, header);
+  if (typeof body === "string" || body instanceof Uint8Array) {
+    outgoing.end(body);
+  } else if (body instanceof Blob) {
+    outgoing.end(new Uint8Array(await body.arrayBuffer()));
+  } else {
+    flushHeaders(outgoing);
+    await writeFromReadableStream(body, outgoing)?.catch(
+      (e) => handleResponseError(e, outgoing)
+    );
+  }
+  ;
+  outgoing[outgoingEnded]?.();
+};
+var isPromise = (res) => typeof res.then === "function";
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+  if (isPromise(res)) {
+    if (options.errorHandler) {
+      try {
+        res = await res;
+      } catch (err) {
+        const errRes = await options.errorHandler(err);
+        if (!errRes) {
+          return;
+        }
+        res = errRes;
+      }
+    } else {
+      res = await res.catch(handleFetchError);
+    }
+  }
+  if (cacheKey in res) {
+    return responseViaCache(res, outgoing);
+  }
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  if (res.body) {
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+      let maxReadCount = 2;
+      for (let i = 0; i < maxReadCount; i++) {
+        currentReadPromise ||= reader.read();
+        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+          console.error(e);
+          done = true;
+        });
+        if (!chunk) {
+          if (i === 1) {
+            await new Promise((resolve) => setTimeout(resolve));
+            maxReadCount = 3;
+            continue;
+          }
+          break;
+        }
+        currentReadPromise = void 0;
+        if (chunk.value) {
+          values.push(chunk.value);
+        }
+        if (chunk.done) {
+          done = true;
+          break;
+        }
+      }
+      if (done && !("content-length" in resHeaderRecord)) {
+        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+      }
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
+    } else {
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+    }
+  } else if (resHeaderRecord[X_ALREADY_SENT]) {
+  } else {
+    outgoing.writeHead(res.status, resHeaderRecord);
+    outgoing.end();
+  }
+  ;
+  outgoing[outgoingEnded]?.();
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+  if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+    Object.defineProperty(global, "Request", {
+      value: Request
+    });
+    Object.defineProperty(global, "Response", {
+      value: Response2
+    });
+  }
+  return async (incoming, outgoing) => {
+    let res, req;
+    try {
+      req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof Http2ServerRequest2) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    drainIncoming(incoming);
+                  });
+                }
+              });
+            }
+          };
+        }
+        outgoing.on("finish", () => {
+          if (!incomingEnded) {
+            drainIncoming(incoming);
+          }
+        });
+      }
+      outgoing.on("close", () => {
+        const abortController = req[abortControllerKey];
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
+        }
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                drainIncoming(incoming);
+              });
+            }
+          });
+        }
+      });
+      res = fetchCallback(req, { incoming, outgoing });
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+    } catch (e) {
+      if (!res) {
+        if (options.errorHandler) {
+          res = await options.errorHandler(req ? e : toRequestError(e));
+          if (!res) {
+            return;
+          }
+        } else if (!req) {
+          res = handleRequestError();
+        } else {
+          res = handleFetchError(e);
+        }
+      } else {
+        return handleResponseError(e, outgoing);
+      }
+    }
+    try {
+      return await responseViaResponseObject(res, outgoing, options);
+    } catch (e) {
+      return handleResponseError(e, outgoing);
+    }
+  };
+};
+var createAdaptorServer = (options) => {
+  const fetchCallback = options.fetch;
+  const requestListener = getRequestListener(fetchCallback, {
+    hostname: options.hostname,
+    overrideGlobalObjects: options.overrideGlobalObjects,
+    autoCleanupIncoming: options.autoCleanupIncoming
+  });
+  const createServer = options.createServer || createServerHTTP;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3e3, options.hostname, () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
+
+// src/web/server.ts
+import { createNodeWebSocket } from "@hono/node-ws";
+import { readFile, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import { exec } from "child_process";
+
+// src/web/bridge.ts
+import { basename } from "path";
+function getToolLabel(toolName, args) {
+  if (toolName === "read" || toolName === "write" || toolName === "edit") {
+    const file = basename(args?.path ?? "");
+    if (!file || !/\.[a-z0-9]{1,6}$/i.test(file)) return null;
+    const verb = toolName === "read" ? "Reading" : toolName === "write" ? "Writing" : "Editing";
+    return `${verb}  ${file}`;
+  }
+  if (toolName === "bash" && args?.command) {
+    const cmd = args.command.toLowerCase();
+    if (cmd.includes("textitems") || cmd.includes("bbox") || cmd.includes(".json")) {
+      return "Looking up citations";
+    }
+    if (cmd.includes("readfilesync") || cmd.includes("readfile") || cmd.includes("cat ")) {
+      return "Searching files";
+    }
+    if (cmd.includes("grep") || cmd.includes("find") || cmd.includes("search")) {
+      return "Searching files";
+    }
+    return "Analyzing sources";
+  }
+  return null;
+}
+async function createWebChatSession(folder, ws, options) {
+  const { session, display } = await createChat(folder, {
+    authStorage: options.authStorage,
+    modelId: options.modelId
+  });
+  const send = (data) => {
+    try {
+      ws.send(JSON.stringify(data));
+    } catch (e) {
+      console.error("[bridge] WS send failed:", e);
+    }
+  };
+  let startTime = Date.now();
+  let filesReadCount = 0;
+  let shownToolCalls = /* @__PURE__ */ new Set();
+  let accumulatedAnswer = "";
+  session.subscribe((event) => {
+    if (event.type === "agent_start") {
+      startTime = Date.now();
+      filesReadCount = 0;
+      shownToolCalls = /* @__PURE__ */ new Set();
+      accumulatedAnswer = "";
+      const modelName = options.modelId ?? "claude-sonnet-4-6";
+      send({ type: "status", model: modelName });
+    }
+    if (event.type === "message_update") {
+      const ae = event.assistantMessageEvent;
+      if (ae.type === "thinking_start") send({ type: "thinking_start" });
+      if (ae.type === "thinking_delta") send({ type: "thinking_delta", text: ae.delta });
+      if (ae.type === "thinking_end") send({ type: "thinking_end" });
+    }
+    if (event.type === "message_update") {
+      const ae = event.assistantMessageEvent;
+      if (ae.type === "toolcall_end" && ae.toolCall) {
+        const label = getToolLabel(ae.toolCall.name, ae.toolCall.arguments);
+        if (label && !shownToolCalls.has(ae.toolCall.id)) {
+          shownToolCalls.add(ae.toolCall.id);
+          if (ae.toolCall.name === "read") filesReadCount++;
+          send({ type: "tool_start", id: ae.toolCall.id, label, name: ae.toolCall.name });
+        }
+      }
+    }
+    if (event.type === "tool_execution_start") {
+      const { toolCallId, toolName, args } = event;
+      if (!shownToolCalls.has(toolCallId)) {
+        const label = getToolLabel(toolName, args);
+        if (label) {
+          shownToolCalls.add(toolCallId);
+          if (toolName === "read") filesReadCount++;
+          send({ type: "tool_start", id: toolCallId, label, name: toolName });
+        }
+      }
+    }
+    if (event.type === "tool_execution_end") {
+      const { toolCallId, isError } = event;
+      send({ type: "tool_end", id: toolCallId, isError });
+    }
+    if (event.type === "message_update") {
+      const ae = event.assistantMessageEvent;
+      if (ae.type === "text_start") send({ type: "text_start" });
+      if (ae.type === "text_delta") {
+        accumulatedAnswer += ae.delta;
+        send({ type: "text_delta", text: ae.delta });
+      }
+      if (ae.type === "text_end") send({ type: "text_end" });
+    }
+    if (event.type === "agent_end") {
+      const elapsed = (Date.now() - startTime) / 1e3;
+      const messages = event.messages;
+      let fullAnswer = "";
+      for (const msg of messages) {
+        if (msg.role !== "assistant") continue;
+        for (const block of msg.content ?? []) {
+          if (block.type === "text" && block.text) {
+            fullAnswer += block.text;
+          }
+        }
+      }
+      const textToSearch = fullAnswer || accumulatedAnswer;
+      const parsed = parseCitations(textToSearch);
+      console.log(`[bridge] Full answer: ${fullAnswer.length} chars, streamed: ${accumulatedAnswer.length} chars, citations: ${parsed.citations.length}`);
+      if (parsed.citations.length === 0 && textToSearch.length > 0) {
+        console.log(`[bridge] No citations found. Last 300 chars: ...${textToSearch.slice(-300)}`);
+      }
+      const sendDone = () => send({
+        type: "done",
+        elapsed: Math.round(elapsed * 10) / 10,
+        filesRead: filesReadCount,
+        citationCount: parsed.citations.length,
+        answer: parsed.answer
+      });
+      if (parsed.citations.length > 0) {
+        send({ type: "citations", data: parsed.citations });
+      }
+      sendDone();
+    }
+  });
+  return {
+    async prompt(text) {
+      display.setQuestion(text);
+      session.setSessionName(`query: ${text}`);
+      await session.prompt(text);
+      await display.flush();
+    },
+    dispose() {
+      session.dispose();
+    }
+  };
+}
+
+// src/web/server.ts
+async function startWebUI(options) {
+  const { folder, port, open } = options;
+  const kbDir = join(folder, ".llm-kb");
+  const sourcesDir = join(kbDir, "wiki", "sources");
+  const app = new Hono();
+  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
+  const cliDir = dirname(fileURLToPath(import.meta.url));
+  app.get("/", async (c) => {
+    const candidates = [
+      join(cliDir, "public", "index.html"),
+      // bin/public/index.html
+      join(cliDir, "..", "bin", "public", "index.html"),
+      // from project root
+      join(cliDir, "..", "src", "web", "public", "index.html"),
+      // dev source
+      join(process.cwd(), "bin", "public", "index.html"),
+      // cwd fallback
+      join(process.cwd(), "src", "web", "public", "index.html")
+      // cwd dev fallback
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) {
+        const html = await readFile(p, "utf-8");
+        return c.html(html);
+      }
+    }
+    return c.text(`index.html not found. Searched: ${candidates.join(", ")}`, 404);
+  });
+  app.get("/api/status", async (c) => {
+    let sourceCount = 0;
+    let wikiExists = false;
+    let wikiConcepts = 0;
+    try {
+      const files = await readdir(sourcesDir);
+      sourceCount = files.filter((f) => f.endsWith(".md")).length;
+    } catch {
+    }
+    const wikiPath = join(kbDir, "wiki", "wiki.md");
+    if (existsSync(wikiPath)) {
+      wikiExists = true;
+      try {
+        const wiki = await readFile(wikiPath, "utf-8");
+        wikiConcepts = (wiki.match(/^## /gm) || []).length;
+      } catch {
+      }
+    }
+    return c.json({ sourceCount, wikiExists, wikiConcepts, folder });
+  });
+  app.get("/api/sources", async (c) => {
+    try {
+      const files = await readdir(sourcesDir);
+      const sources = [];
+      for (const f of files.filter((f2) => f2.endsWith(".json"))) {
+        try {
+          const data = JSON.parse(await readFile(join(sourcesDir, f), "utf-8"));
+          sources.push({
+            name: data.source || f.replace(".json", ".pdf"),
+            pages: data.totalPages || 0,
+            jsonFile: f,
+            mdFile: f.replace(".json", ".md")
+          });
+        } catch {
+        }
+      }
+      return c.json(sources);
+    } catch {
+      return c.json([]);
+    }
+  });
+  app.get("/api/sessions", async (c) => {
+    const sessionsDir = join(kbDir, "sessions");
+    const tracesDir = join(kbDir, "traces");
+    try {
+      const traceFiles = existsSync(tracesDir) ? (await readdir(tracesDir)).filter((f) => f.endsWith(".json")) : [];
+      const sessions = [];
+      for (const f of traceFiles) {
+        try {
+          const trace = JSON.parse(await readFile(join(tracesDir, f), "utf-8"));
+          if (trace.mode === "query" && trace.question) {
+            sessions.push({
+              id: trace.sessionId,
+              question: trace.question,
+              timestamp: trace.timestamp,
+              model: trace.model,
+              citationCount: trace.citations?.length ?? 0,
+              filesRead: trace.filesRead?.length ?? 0
+            });
+          }
+        } catch {
+        }
+      }
+      sessions.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+      return c.json(sessions);
+    } catch {
+      return c.json([]);
+    }
+  });
+  app.get("/api/sessions/:id", async (c) => {
+    const id = c.req.param("id");
+    const tracesDir = join(kbDir, "traces");
+    const tracePath = join(tracesDir, `${id}.json`);
+    if (!existsSync(tracePath)) return c.json({ error: "Not found" }, 404);
+    try {
+      const trace = JSON.parse(await readFile(tracePath, "utf-8"));
+      return c.json(trace);
+    } catch {
+      return c.json({ error: "Failed to read trace" }, 500);
+    }
+  });
+  app.get("/api/pdf/:filename", async (c) => {
+    const filename = decodeURIComponent(c.req.param("filename"));
+    const pdfPath = join(folder, filename);
+    if (existsSync(pdfPath)) {
+      const buf = await readFile(pdfPath);
+      return c.body(buf, { headers: { "Content-Type": "application/pdf" } });
+    }
+    try {
+      const files = await readdir(folder);
+      const match = files.find((f) => f.endsWith(".pdf") && f.includes(filename.replace(/^\d+\.\s*/, "")));
+      if (match) {
+        const buf = await readFile(join(folder, match));
+        return c.body(buf, { headers: { "Content-Type": "application/pdf" } });
+      }
+    } catch {
+    }
+    return c.text("PDF not found", 404);
+  });
+  app.get("/api/bbox/:filename", async (c) => {
+    const filename = decodeURIComponent(c.req.param("filename"));
+    const pageParam = c.req.query("page");
+    const baseName = filename.replace(/\.pdf$/i, "");
+    const pagesDir = join(sourcesDir, `${baseName}.pages`);
+    if (pageParam) {
+      const pageNum = parseInt(pageParam, 10);
+      const pageFile = join(pagesDir, `${pageNum}.json`);
+      if (existsSync(pageFile)) {
+        const data = JSON.parse(await readFile(pageFile, "utf-8"));
+        return c.json({ source: data.source, totalPages: data.totalPages, pages: [data] });
+      }
+      try {
+        const allDirs = await readdir(sourcesDir);
+        const needle = baseName.replace(/^\d+\.\s*/, "").toLowerCase();
+        const match = allDirs.find((d) => d.endsWith(".pages") && d.toLowerCase().includes(needle));
+        if (match) {
+          const fuzzyPageFile = join(sourcesDir, match, `${pageNum}.json`);
+          if (existsSync(fuzzyPageFile)) {
+            const data = JSON.parse(await readFile(fuzzyPageFile, "utf-8"));
+            return c.json({ source: data.source, totalPages: data.totalPages, pages: [data] });
+          }
+        }
+      } catch {
+      }
+    }
+    const jsonPath = join(sourcesDir, `${baseName}.json`);
+    if (existsSync(jsonPath)) {
+      const data = JSON.parse(await readFile(jsonPath, "utf-8"));
+      if (pageParam) {
+        const pageNum = parseInt(pageParam, 10);
+        const page = data.pages?.find((p) => p.page === pageNum);
+        if (!page) return c.json({ error: "Page not found" }, 404);
+        return c.json({ source: data.source, totalPages: data.totalPages, pages: [page] });
+      }
+      return c.json(data);
+    }
+    try {
+      const files = await readdir(sourcesDir);
+      const needle = baseName.replace(/^\d+\.\s*/, "").toLowerCase();
+      const match = files.find((f) => f.endsWith(".json") && f.toLowerCase().includes(needle));
+      if (match) {
+        const data = JSON.parse(await readFile(join(sourcesDir, match), "utf-8"));
+        if (pageParam) {
+          const pageNum = parseInt(pageParam, 10);
+          const page = data.pages?.find((p) => p.page === pageNum);
+          if (!page) return c.json({ error: "Page not found" }, 404);
+          return c.json({ source: data.source, totalPages: data.totalPages, pages: [page] });
+        }
+        return c.json(data);
+      }
+    } catch {
+    }
+    return c.json({ error: "Bbox data not found" }, 404);
+  });
+  app.get("/api/wiki", async (c) => {
+    const wikiPath = join(kbDir, "wiki", "wiki.md");
+    if (!existsSync(wikiPath)) return c.json({ content: "" });
+    try {
+      const content = await readFile(wikiPath, "utf-8");
+      return c.json({ content });
+    } catch {
+      return c.json({ content: "" });
+    }
+  });
+  app.get("/ws/chat", upgradeWebSocket((c) => {
+    let chatSession = null;
+    let creating = false;
+    let wsRef = null;
+    return {
+      onOpen(evt, ws) {
+        wsRef = ws;
+        console.log("[ws] Client connected");
+        ws.send(JSON.stringify({ type: "connected", message: "llm-kb web UI ready" }));
+        creating = true;
+        createWebChatSession(folder, {
+          send(data) {
+            try {
+              wsRef?.send(data);
+            } catch (e) {
+              console.error("[ws] send error:", e);
+            }
+          }
+        }, {
+          authStorage: options.authStorage,
+          modelId: options.modelId
+        }).then((session) => {
+          chatSession = session;
+          creating = false;
+          console.log("[ws] Agent session ready");
+          try {
+            wsRef?.send(JSON.stringify({ type: "ready" }));
+          } catch {
+          }
+        }).catch((err) => {
+          creating = false;
+          console.error("[ws] Session creation failed:", err.message);
+          try {
+            wsRef?.send(JSON.stringify({ type: "error", message: err.message }));
+          } catch {
+          }
+        });
+      },
+      onMessage(evt, ws) {
+        const raw = typeof evt.data === "string" ? evt.data : "";
+        let data;
+        try {
+          data = JSON.parse(raw);
+        } catch {
+          return;
+        }
+        console.log("[ws] Received:", data.type, data.text?.slice(0, 50));
+        if (data.type === "message" && data.text) {
+          if (!chatSession) {
+            const msg = creating ? "Session still initializing, please wait..." : "Session not ready";
+            ws.send(JSON.stringify({ type: "error", message: msg }));
+            return;
+          }
+          chatSession.prompt(data.text).catch((err) => {
+            console.error("[ws] Prompt error:", err.message);
+            try {
+              ws.send(JSON.stringify({ type: "error", message: err.message }));
+            } catch {
+            }
+          });
+        }
+      },
+      onClose() {
+        console.log("[ws] Client disconnected");
+        if (chatSession) {
+          chatSession.dispose();
+          chatSession = null;
+        }
+        wsRef = null;
+      }
+    };
+  }));
+  const server = serve({ fetch: app.fetch, port }, (info) => {
+    console.log(`
+  \u{1F310} llm-kb web UI running at http://localhost:${port}
+`);
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`
+  \u274C Port ${port} is already in use. Either:
+     - Close the other llm-kb instance
+     - Use a different port: llm-kb ui <folder> --port 3948
+`);
+      process.exit(1);
+    }
+    throw err;
+  });
+  injectWebSocket(server);
+  if (open) {
+    const url = `http://localhost:${port}`;
+    const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+    exec(cmd, () => {
+    });
+  }
+  await new Promise(() => {
+  });
+}
+export {
+  startWebUI
+};