@threadbase-sh/streamer 1.26.0 → 1.27.0

package/dist/index.cjs

@@ -2653,17 +2653,17 @@ var corsMiddleware = (configValue) => {
       const raw = c.env.outgoing;
       raw.setHeader("Access-Control-Allow-Origin", allowedOrigin);
       raw.setHeader("Vary", "Origin");
-      raw.setHeader("Access-Control-Allow-Methods", "GET, POST, PATCH, OPTIONS");
+      raw.setHeader("Access-Control-Allow-Methods", "GET, POST, PATCH, QUERY, OPTIONS");
       raw.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, If-None-Match");
-      raw.setHeader("Access-Control-Expose-Headers", "ETag");
+      raw.setHeader("Access-Control-Expose-Headers", "ETag, Accept-Query");
       c.res.headers.set("Access-Control-Allow-Origin", allowedOrigin);
       c.res.headers.set("Vary", "Origin");
-      c.res.headers.set("Access-Control-Allow-Methods", "GET, POST, PATCH, OPTIONS");
+      c.res.headers.set("Access-Control-Allow-Methods", "GET, POST, PATCH, QUERY, OPTIONS");
       c.res.headers.set(
         "Access-Control-Allow-Headers",
         "Authorization, Content-Type, If-None-Match"
       );
-      c.res.headers.set("Access-Control-Expose-Headers", "ETag");
+      c.res.headers.set("Access-Control-Expose-Headers", "ETag, Accept-Query");
     }
     if (c.req.method === "OPTIONS") {
       return c.newResponse(null, allowedOrigin ? 204 : 403);
@@ -2707,6 +2707,11 @@ var createConversationRoutes = (deps) => {
     await deps.handleConversationsCount(url, c.env.outgoing);
     return alreadyHandled2();
   });
+  app.on("QUERY", "/:id{.+}/search-target", async (c) => {
+    const id = c.req.param("id");
+    await deps.handleSearchTarget(id, c.env.incoming, c.env.outgoing);
+    return alreadyHandled2();
+  });
   app.get("/:id{.+}", async (c) => {
     const id = c.req.param("id");
     const url = new URL(c.req.url);
@@ -4525,6 +4530,55 @@ var ConversationWatcher = class {
   }
 };
 
+// src/services/conversations/findSearchTarget.ts
+var SNIPPET_CONTEXT = 60;
+var MAX_MATCH_INDEXES = 1e3;
+function buildSnippet(source, matchStart, matchLength) {
+  const start = Math.max(0, matchStart - SNIPPET_CONTEXT);
+  const end = Math.min(source.length, matchStart + matchLength + SNIPPET_CONTEXT);
+  const prefix = start > 0 ? "\u2026" : "";
+  const suffix = end < source.length ? "\u2026" : "";
+  return `${prefix}${source.slice(start, end).replace(/\s+/g, " ").trim()}${suffix}`;
+}
+function extendedBody(m) {
+  const parts = [];
+  if (m.isThinking && m.thinkingContent) parts.push(m.thinkingContent);
+  for (const b of m.metadata?.toolUseBlocks ?? []) {
+    if (b.input !== void 0) parts.push(JSON.stringify(b.input));
+  }
+  for (const r of m.metadata?.toolResults ?? []) {
+    if (r.content !== void 0) parts.push(JSON.stringify(r.content));
+  }
+  return parts.join("\n");
+}
+function collectMatches(messages, needle, body) {
+  const indexes = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (body(messages[i]).toLowerCase().includes(needle)) indexes.push(i);
+  }
+  return indexes;
+}
+function findSearchTarget(messages, query) {
+  const needle = query.toLowerCase();
+  let body = (m) => m.text ?? "";
+  let matches = collectMatches(messages, needle, body);
+  if (matches.length === 0) {
+    body = extendedBody;
+    matches = collectMatches(messages, needle, body);
+  }
+  if (matches.length === 0) return null;
+  const anchorIndex = matches[matches.length - 1];
+  const anchorBody = body(messages[anchorIndex]);
+  const at = anchorBody.toLowerCase().indexOf(needle);
+  return {
+    messageIndex: anchorIndex,
+    uuid: messages[anchorIndex].uuid ?? null,
+    snippet: buildSnippet(anchorBody, at, query.length),
+    matchIndexes: matches.slice(-MAX_MATCH_INDEXES),
+    totalMatches: matches.length
+  };
+}
+
 // src/services/conversations/pruneAgentConversations.ts
 var import_fs11 = require("fs");
 function pruneAgentConversations(cache) {
@@ -5410,6 +5464,7 @@ var StreamerServer = class {
       handleConversationsCount: (url, res) => this.handleConversationsCount(url, res),
       handleGetConversation: (id, url, res, ifNoneMatch) => this.handleGetConversation(id, url, res, ifNoneMatch),
       handleSearch: (url, res) => this.handleSearch(url, res),
+      handleSearchTarget: (id, req, res) => this.handleSearchTarget(id, req, res),
       handleListProjects: (url, res) => handleListProjects(url, res),
       handleGetPopularProjects: (url, res) => this.handleGetPopularProjects(url, res),
       handlePairStart: (res) => this.handlePairStart(res),
@@ -6310,7 +6365,7 @@ var StreamerServer = class {
       messageCount: etagSource.messageCount,
       timestamp: etagSource.timestamp
     });
-    const isFirstPage = !url.searchParams.has("before_index");
+    const isFirstPage = !url.searchParams.has("before_index") && !url.searchParams.has("anchor_index") && !url.searchParams.has("after_index");
     if (isFirstPage && ifNoneMatch && ifNoneMatch === etag) {
       res.writeHead(304, { ETag: etag, "Access-Control-Expose-Headers": "ETag" });
       res.end();
@@ -6318,29 +6373,53 @@ var StreamerServer = class {
     }
     const filtered = conversation.messages;
     const total = filtered.length;
-    const usePaging = url.searchParams.has("msg_limit") || url.searchParams.has("before_index");
+    const hasAnchor = url.searchParams.has("anchor_index");
+    const hasAfter = url.searchParams.has("after_index");
+    const usePaging = url.searchParams.has("msg_limit") || url.searchParams.has("before_index") || hasAnchor || hasAfter;
     let slice = filtered;
     let fromIdx = 0;
     let messagePagination;
     if (usePaging) {
       const limit = Math.min(Math.max(intParam(url, "msg_limit", 80), 1), 500);
       let beforeIndex = total;
+      let scanLimit = limit;
+      let anchorIndex = null;
+      let newerPaging = false;
       if (url.searchParams.has("before_index")) {
         beforeIndex = intParam(url, "before_index", total);
         beforeIndex = Math.min(Math.max(beforeIndex, 0), total);
+      } else if (hasAfter) {
+        const from = Math.min(Math.max(intParam(url, "after_index", 0), 0), total);
+        beforeIndex = Math.min(total, from + limit);
+        scanLimit = beforeIndex - from;
+        newerPaging = true;
+      } else if (hasAnchor) {
+        anchorIndex = Math.min(
+          Math.max(intParam(url, "anchor_index", 0), 0),
+          Math.max(0, total - 1)
+        );
+        const from = Math.max(0, anchorIndex - Math.floor(limit / 2));
+        beforeIndex = Math.min(total, from + limit);
+        newerPaging = true;
       }
       const pagedScanner = this.scannerReady ? await this.getScanner(true) : null;
-      const page = pagedScanner && typeof pagedScanner.getConversationPage === "function" ? await pagedScanner.getConversationPage(id, { beforeIndex, limit }) : null;
-      const start = page?.fromIndex ?? Math.max(0, beforeIndex - limit);
+      const page = scanLimit > 0 && pagedScanner && typeof pagedScanner.getConversationPage === "function" ? await pagedScanner.getConversationPage(id, { beforeIndex, limit: scanLimit }) : null;
+      const start = page?.fromIndex ?? Math.max(0, beforeIndex - scanLimit);
       slice = page?.messages ?? filtered.slice(start, beforeIndex);
       fromIdx = start;
+      const effectiveTotal = page?.total ?? total;
       messagePagination = {
-        total: page?.total ?? total,
+        total: effectiveTotal,
         before_index: beforeIndex,
         from_index: start,
         has_more_older: start > 0,
         next_before_index: start > 0 ? start : null
       };
+      if (anchorIndex != null) messagePagination.anchor_index = anchorIndex;
+      if (newerPaging) {
+        messagePagination.has_more_newer = beforeIndex < effectiveTotal;
+        messagePagination.next_after_index = beforeIndex < effectiveTotal ? beforeIndex : null;
+      }
     }
     const messagesPayload = slice.map((m, localIdx) => {
       const content = [];
@@ -6415,6 +6494,65 @@ var StreamerServer = class {
     });
     res.end(JSON.stringify(body));
   }
+  // Resolves an active search query to the message a client should anchor to
+  // inside one conversation. Matching is body-only (text first, then
+  // thinking/tool payloads) — a metadata-only search hit (project path, title)
+  // has no scroll target and returns 404 search_target_not_found.
+  //
+  // Implements HTTP QUERY (RFC 10008): the search query travels in a JSON
+  // request body instead of a URL query param — QUERY is safe + idempotent +
+  // cacheable like GET, but (like POST) can carry a body, which fits this
+  // endpoint's single-string input exactly. `Accept-Query` advertises the
+  // supported request media type per the spec.
+  async handleSearchTarget(id, req, res) {
+    const contentType = (req.headers["content-type"] ?? "").split(";")[0].trim();
+    if (contentType && contentType !== "application/json") {
+      res.setHeader("Accept-Query", "application/json");
+      json(res, 415, {
+        error: "Unsupported Content-Type; expected application/json",
+        code: "unsupported_media_type"
+      });
+      return;
+    }
+    let body;
+    try {
+      body = await readBody(req);
+    } catch {
+      res.setHeader("Accept-Query", "application/json");
+      json(res, 422, { error: "Malformed JSON body", code: "invalid_query" });
+      return;
+    }
+    const q = typeof body?.q === "string" ? body.q.trim() : "";
+    if (!q) {
+      res.setHeader("Accept-Query", "application/json");
+      json(res, 422, { error: "Missing or empty query field: q", code: "invalid_query" });
+      return;
+    }
+    if (q.length > 256) {
+      res.setHeader("Accept-Query", "application/json");
+      json(res, 422, { error: "Query too long (max 256 characters)", code: "invalid_query" });
+      return;
+    }
+    const conversation = await this.findConversationByUuid(id);
+    if (!conversation) {
+      json(res, 404, { error: "Conversation not found", code: "not_found" });
+      return;
+    }
+    const target = findSearchTarget(conversation.messages, q);
+    if (!target) {
+      json(res, 404, { error: "No message body matches query", code: "search_target_not_found" });
+      return;
+    }
+    res.setHeader("Accept-Query", "application/json");
+    json(res, 200, {
+      query: q,
+      message_index: target.messageIndex,
+      uuid: target.uuid,
+      snippet: target.snippet,
+      match_indexes: target.matchIndexes,
+      total_matches: target.totalMatches
+    });
+  }
   async handleSearch(url, res) {
     const q = url.searchParams.get("q") ?? "";
     if (!q) {
@@ -6434,7 +6572,11 @@ var StreamerServer = class {
       scanner
     );
     const adapted = results.map((r) => ({
-      id: r.meta.id.split("/").pop()?.replace(/\.jsonl$/, "") || r.meta.id,
+      // Use sessionId so the id matches /api/conversations and resolves via
+      // findConversationByUuid — a client can round-trip a search result into
+      // GET /api/conversations/:id or the search-target QUERY. The old
+      // filename-stem derivation produced an id no other endpoint recognized.
+      id: r.meta.sessionId || r.meta.id,
       title: r.meta.projectName,
       sessionName: r.meta.sessionName || void 0,
       filePath: r.meta.filePath,