@wolfx/opencode-magic-context 0.30.1 → 0.30.3

package/dist/index.js

@@ -64,6 +64,9 @@ function getMagicContextTempDir(harness = getHarness()) {
   return path.join(os.tmpdir(), harness, "magic-context");
 }
 function getMagicContextLogPath(harness = getHarness()) {
+  const envPath = process.env.MAGIC_CONTEXT_LOG_PATH?.trim();
+  if (envPath)
+    return envPath;
   return path.join(getMagicContextTempDir(harness), "magic-context.log");
 }
 function getProjectMagicContextDir(directory) {
@@ -157659,12 +157662,30 @@ var init_safe_notification_target = __esm(() => {
 // src/shared/rpc-notifications.ts
 var exports_rpc_notifications = {};
 __export(exports_rpc_notifications, {
+  registerNotificationSink: () => registerNotificationSink,
   pushNotification: () => pushNotification,
   isTuiConnected: () => isTuiConnected,
   drainNotifications: () => drainNotifications
 });
+function registerNotificationSink(sink) {
+  sinks.add(sink);
+  return () => {
+    sinks.delete(sink);
+  };
+}
+function notificationMatchesSink(notification, sink) {
+  return notification.sessionId === undefined || sink.sessionId === undefined || notification.sessionId === sink.sessionId;
+}
 function pushNotification(type, payload, sessionId) {
-  queue.push({ id: nextNotificationId++, type, payload, sessionId });
+  const notification = { id: nextNotificationId++, type, payload, sessionId };
+  queue.push(notification);
+  for (const sink of sinks) {
+    if (!notificationMatchesSink(notification, sink))
+      continue;
+    try {
+      sink.send(notification);
+    } catch {}
+  }
   if (queue.length > 100) {
     const newestPerSession = new Map;
     for (const n of queue) {
@@ -157684,10 +157705,6 @@ function pushNotification(type, payload, sessionId) {
   }
 }
 function drainNotifications(lastReceivedId = 0, sessionId) {
-  const now = Date.now();
-  lastDrainAtAny = now;
-  if (sessionId !== undefined)
-    lastDrainAtBySession.set(sessionId, now);
   const matchesClient = (notification) => sessionId === undefined || notification.sessionId === undefined || notification.sessionId === sessionId;
   if (lastReceivedId > 0) {
     queue = queue.filter((notification) => !(notification.id <= lastReceivedId && matchesClient(notification)));
@@ -157695,17 +157712,20 @@ function drainNotifications(lastReceivedId = 0, sessionId) {
   return queue.filter((notification) => notification.id > lastReceivedId && matchesClient(notification));
 }
 function isTuiConnected(sessionId) {
-  const now = Date.now();
-  if (sessionId !== undefined) {
-    const at = lastDrainAtBySession.get(sessionId) ?? 0;
-    return at > 0 && now - at < TUI_CONNECTED_WINDOW_MS;
+  if (sinks.size === 0)
+    return false;
+  if (sessionId === undefined)
+    return true;
+  for (const sink of sinks) {
+    if (sink.sessionId === undefined || sink.sessionId === sessionId)
+      return true;
   }
-  return lastDrainAtAny > 0 && now - lastDrainAtAny < TUI_CONNECTED_WINDOW_MS;
+  return false;
 }
-var queue, nextNotificationId = 1, lastDrainAtBySession, lastDrainAtAny = 0, TUI_CONNECTED_WINDOW_MS = 3000;
+var queue, nextNotificationId = 1, sinks;
 var init_rpc_notifications = __esm(() => {
   queue = [];
-  lastDrainAtBySession = new Map;
+  sinks = new Set;
 });
 
 // src/plugin/conflict-warning-hook.ts
@@ -158381,6 +158401,94 @@ function parseFields(json2) {
 }
 var init_compartment_events = () => {};
 
+// src/features/magic-context/recursive-text-splitter.ts
+function splitOnSeparator(text, separator) {
+  const splits = separator ? text.split(separator) : text.split("");
+  return splits.filter((s) => s !== "");
+}
+function mergeSplits(splits, separator, chunkSize, lengthFunction) {
+  const docs = [];
+  const currentDoc = [];
+  let total = 0;
+  const joinDocs = (docsToJoin) => {
+    const joined = docsToJoin.join(separator).trim();
+    return joined === "" ? null : joined;
+  };
+  for (const d of splits) {
+    const len = lengthFunction(d);
+    if (total + len + currentDoc.length * separator.length > chunkSize) {
+      if (currentDoc.length > 0) {
+        const doc3 = joinDocs(currentDoc);
+        if (doc3 !== null)
+          docs.push(doc3);
+        while (total > 0 && currentDoc.length > 0) {
+          total -= lengthFunction(currentDoc[0]);
+          currentDoc.shift();
+        }
+      }
+    }
+    currentDoc.push(d);
+    total += len;
+  }
+  const doc2 = joinDocs(currentDoc);
+  if (doc2 !== null)
+    docs.push(doc2);
+  return docs;
+}
+function splitTextRecursive(text, separators, chunkSize, lengthFunction) {
+  const finalChunks = [];
+  let separator = separators[separators.length - 1];
+  let newSeparators;
+  for (let i = 0;i < separators.length; i += 1) {
+    const s = separators[i];
+    if (s === "") {
+      separator = s;
+      break;
+    }
+    if (text.includes(s)) {
+      separator = s;
+      newSeparators = separators.slice(i + 1);
+      break;
+    }
+  }
+  const splits = splitOnSeparator(text, separator);
+  let goodSplits = [];
+  for (const s of splits) {
+    if (lengthFunction(s) < chunkSize) {
+      goodSplits.push(s);
+    } else {
+      if (goodSplits.length) {
+        finalChunks.push(...mergeSplits(goodSplits, separator, chunkSize, lengthFunction));
+        goodSplits = [];
+      }
+      if (!newSeparators) {
+        finalChunks.push(s);
+      } else {
+        finalChunks.push(...splitTextRecursive(s, newSeparators, chunkSize, lengthFunction));
+      }
+    }
+  }
+  if (goodSplits.length) {
+    finalChunks.push(...mergeSplits(goodSplits, separator, chunkSize, lengthFunction));
+  }
+  return finalChunks;
+}
+function recursiveCharacterSplit(text, options) {
+  const chunkSize = options.chunkSize;
+  const lengthFunction = options.lengthFunction ?? ((t) => t.length);
+  const separators = options.separators ?? DEFAULT_SEPARATORS;
+  if (text.length === 0)
+    return [];
+  return splitTextRecursive(text, separators, chunkSize, lengthFunction);
+}
+var DEFAULT_SEPARATORS;
+var init_recursive_text_splitter = __esm(() => {
+  DEFAULT_SEPARATORS = [`
+
+`, `
+`, " ", ""];
+});
+
 // src/features/magic-context/compartment-chunk-embedding.ts
 import { createHash as createHash6 } from "node:crypto";
 function getLoadFtsRowsStatement(db) {
@@ -158648,6 +158756,19 @@ function chunkCanonicalText(canonicalText, startOrdinal, endOrdinal, maxInputTok
     const lineStart = range?.start ?? startOrdinal;
     const lineEnd = range?.end ?? lineStart;
     const lineTokens = estimateTokens(line);
+    if (lineTokens > effectiveMax) {
+      flush2();
+      for (const slice of splitOversizedLine(line, effectiveMax)) {
+        windows.push({
+          windowIndex: windows.length + 1,
+          startOrdinal: lineStart,
+          endOrdinal: lineEnd,
+          text: slice,
+          chunkHash: hashChunkText(slice)
+        });
+      }
+      continue;
+    }
     if (currentLines.length > 0 && currentTokens + lineTokens > effectiveMax) {
       flush2();
     }
@@ -158661,6 +158782,56 @@ function chunkCanonicalText(canonicalText, startOrdinal, endOrdinal, maxInputTok
   flush2();
   return windows;
 }
+function splitOversizedLine(line, effectiveMax) {
+  let slices = [];
+  try {
+    slices = recursiveCharacterSplit(line, {
+      chunkSize: effectiveMax,
+      lengthFunction: estimateTokens
+    });
+  } catch (error51) {
+    log("[magic-context] recursiveCharacterSplit failed; using char-budget fallback:", error51);
+    slices = [];
+  }
+  if (slices.length === 0) {
+    slices = charBudgetSplit(line, effectiveMax);
+  }
+  const safe = [];
+  const pushChecked = (slice) => {
+    if (estimateTokens(slice) > effectiveMax && slice.length > 1) {
+      safe.push(...charBudgetSplit(slice, effectiveMax));
+      return;
+    }
+    safe.push(slice);
+  };
+  for (const slice of slices) {
+    if (estimateTokens(slice) <= effectiveMax) {
+      safe.push(slice);
+    } else {
+      for (const sub of charBudgetSplit(slice, effectiveMax))
+        pushChecked(sub);
+    }
+  }
+  return safe.filter((s) => s.length > 0);
+}
+function charBudgetSplit(text, effectiveMax) {
+  const totalTokens = Math.max(1, estimateTokens(text));
+  const charsPerToken = Math.max(1, Math.floor(text.length / totalTokens));
+  const sliceChars = Math.max(1, effectiveMax * charsPerToken);
+  const out = [];
+  let pos = 0;
+  while (pos < text.length) {
+    let end = Math.min(text.length, pos + sliceChars);
+    let slice = text.slice(pos, end);
+    while (slice.length > 1 && estimateTokens(slice) > effectiveMax) {
+      end = pos + Math.max(1, Math.floor((end - pos) / 2));
+      slice = text.slice(pos, end);
+    }
+    out.push(slice);
+    pos = end;
+  }
+  return out;
+}
 function getExistingChunkHashes(db, compartmentId, modelId, projectPath) {
   const scoped = typeof projectPath === "string" && projectPath.length > 0;
   const rows = scoped ? getExistingHashStatement(db, true).all(compartmentId, modelId, projectPath) : getExistingHashStatement(db, false).all(compartmentId, modelId);
@@ -158828,6 +158999,8 @@ function countSessionCompartmentEmbedCoverage(db, projectPath, sessionId, modelI
 var DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS = 512, CHUNK_WINDOW_SAFETY_RATIO = 0.9, loadFtsRowsStatements, existingHashStatements, existingHashByProjectStatements, deleteByCompartmentStatements, insertEmbeddingStatements, distinctModelStatements, clearProjectStatements, clearProjectModelStatements, searchRowsStatements, searchRowsByModelStatements, backfillCandidateStatements, sessionBackfillCandidateStatements;
 var init_compartment_chunk_embedding = __esm(() => {
   init_read_session_formatting();
+  init_logger();
+  init_recursive_text_splitter();
   loadFtsRowsStatements = new WeakMap;
   existingHashStatements = new WeakMap;
   existingHashByProjectStatements = new WeakMap;
@@ -159036,6 +159209,7 @@ class OpenAICompatibleEmbeddingProvider {
     if (texts.length === 0) {
       return [];
     }
+    const requestTexts = texts.map((t) => t.trim().length === 0 ? " " : t);
     if (!await this.initialize()) {
       return Array.from({ length: texts.length }, () => null);
     }
@@ -159067,7 +159241,7 @@ class OpenAICompatibleEmbeddingProvider {
         },
         body: JSON.stringify({
           model: this.model,
-          input: texts,
+          input: requestTexts,
           ...inputTypeForRequest ? { input_type: inputTypeForRequest } : {},
           ...this.truncate ? { truncate: this.truncate } : {}
         }),
@@ -160149,6 +160323,32 @@ async function embedBatchForProject(projectIdentity, texts, signal, purpose = "p
   }
   return { vectors, modelId, generation };
 }
+async function embedTextsWindowBounded(projectIdentity, texts, signal) {
+  if (texts.length <= MAX_WINDOWS_PER_EMBED_CALL) {
+    return embedBatchForProject(projectIdentity, texts, signal);
+  }
+  const vectors = [];
+  let modelId = null;
+  let generation = null;
+  for (let start = 0;start < texts.length; start += MAX_WINDOWS_PER_EMBED_CALL) {
+    if (signal?.aborted)
+      return null;
+    const sub = texts.slice(start, start + MAX_WINDOWS_PER_EMBED_CALL);
+    const result = await embedBatchForProject(projectIdentity, sub, signal);
+    if (!result)
+      return null;
+    if (modelId === null) {
+      modelId = result.modelId;
+      generation = result.generation;
+    } else if (result.modelId !== modelId || result.generation !== generation) {
+      return null;
+    }
+    vectors.push(...result.vectors);
+  }
+  if (modelId === null || generation === null)
+    return null;
+  return { vectors, modelId, generation };
+}
 function isUnembeddedMemoryRow(row) {
   if (row === null || typeof row !== "object")
     return false;
@@ -160282,7 +160482,7 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
       let result = null;
       const attemptStart = Date.now();
       try {
-        result = await embedBatchForProject(projectIdentity, texts, signal);
+        result = await embedTextsWindowBounded(projectIdentity, texts, signal);
       } catch (error51) {
         log("[magic-context] failed to proactively embed compartment chunks:", error51);
       }
@@ -176489,11 +176689,11 @@ function shouldShowAnnouncement() {
   }
   return ordering > 0;
 }
-var ANNOUNCEMENT_VERSION = "0.30.1", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
+var ANNOUNCEMENT_VERSION = "0.30.2", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
 var init_announcement = __esm(() => {
   init_data_path();
   ANNOUNCEMENT_FEATURES = [
-    "Local embeddings work on OpenCode Desktop again (#195): /ctx-embed no longer fails with 'Unsupported device: cpu' on the Desktop app."
+    "Fixed high idle CPU from the TUI sidebar (#200): it now uses a single persistent connection to the plugin instead of polling, so an idle session no longer burns CPU."
   ];
 });
 
@@ -193710,7 +193910,6 @@ function calibrateBuckets(input) {
 // src/plugin/rpc-handlers.ts
 init_announcement();
 init_logger();
-init_rpc_notifications();
 var workMetricsCarryBySession = new Map;
 function resolveSidebarWorkMetrics(db, sessionId, persistedNewWork, persistedTotalInput) {
   if (!openCodeDbExists()) {
@@ -194222,12 +194421,6 @@ function registerRpcHandlers(rpcServer, args) {
     const resolved = typeof config2.toast_duration_ms === "number" && Number.isFinite(config2.toast_duration_ms) ? config2.toast_duration_ms : 5000;
     return { toastDurationMs: resolved };
   });
-  rpcServer.handle("pending-notifications", async (params) => {
-    const lastReceivedId = Number(params.lastReceivedId ?? 0);
-    const sessionId = typeof params.sessionId === "string" && params.sessionId.length > 0 ? params.sessionId : undefined;
-    const notifications = drainNotifications(Number.isFinite(lastReceivedId) ? lastReceivedId : 0, sessionId);
-    return { messages: notifications };
-  });
   rpcServer.handle("get-announcement", async () => {
     if (!shouldShowAnnouncement()) {
       return { show: false };
@@ -195597,6 +195790,7 @@ init_models_dev_cache();
 
 // src/shared/rpc-server.ts
 init_logger();
+init_rpc_notifications();
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import {
   chmodSync as chmodSync2,
@@ -195608,7 +195802,6 @@ import {
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { createServer } from "node:http";
 import { dirname as dirname5 } from "node:path";
 
 // src/shared/rpc-utils.ts
@@ -195666,6 +195859,9 @@ function isValidPort(port) {
 }
 
 // src/shared/rpc-server.ts
+var MAX_BODY_BYTES = 1048576;
+var WS_AUTH_TIMEOUT_MS = 5000;
+var WS_CLOSE_UNAUTHORIZED = 4401;
 function tokensMatch(presented, expected) {
   const a = Buffer.from(presented, "utf8");
   const b = Buffer.from(expected, "utf8");
@@ -195681,6 +195877,7 @@ class MagicContextRpcServer {
   portFilePath;
   portDir;
   startedAt = Date.now();
+  sockets = new Set;
   token = randomBytes(32).toString("hex");
   constructor(storageDir, directory) {
     this.portFilePath = rpcPortFilePath(storageDir, directory);
@@ -195690,49 +195887,77 @@ class MagicContextRpcServer {
     this.handlers.set(method, handler);
   }
   async start() {
-    return new Promise((resolve3, reject) => {
-      const server = createServer((req, res) => this.dispatch(req, res));
-      server.on("error", (err) => {
-        log(`[rpc] server error: ${err.message}`);
-        reject(err);
-      });
-      server.listen(0, "127.0.0.1", () => {
-        const addr = server.address();
-        if (!addr || typeof addr === "string") {
-          reject(new Error("Failed to get server address"));
-          return;
-        }
-        this.port = addr.port;
-        this.server = server;
-        try {
-          this.warnIfOtherLiveInstance();
-          const dir = dirname5(this.portFilePath);
-          mkdirSync9(dir, { recursive: true, mode: 448 });
-          try {
-            chmodSync2(dir, 448);
-          } catch {}
-          const tmpPath = `${this.portFilePath}.tmp`;
-          try {
-            rmSync2(tmpPath, { force: true });
-          } catch {}
-          writeFileSync8(tmpPath, JSON.stringify({
-            port: this.port,
-            pid: process.pid,
-            started_at: this.startedAt,
-            token: this.token
-          }), { encoding: "utf-8", mode: 384 });
-          renameSync3(tmpPath, this.portFilePath);
-          try {
-            chmodSync2(this.portFilePath, 384);
-          } catch {}
-          log(`[rpc] server listening on 127.0.0.1:${this.port}`);
-        } catch (err) {
-          log(`[rpc] failed to write port file: ${err}`);
+    const self2 = this;
+    const server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      fetch(req, srv) {
+        return self2.handleFetch(req, srv);
+      },
+      websocket: {
+        open(ws) {
+          ws.data.authTimer = setTimeout(() => {
+            if (!ws.data.authed)
+              ws.close(WS_CLOSE_UNAUTHORIZED, "auth timeout");
+          }, WS_AUTH_TIMEOUT_MS);
+        },
+        message(ws, raw) {
+          self2.handleWsMessage(ws, raw);
+        },
+        close(ws) {
+          if (ws.data.authTimer)
+            clearTimeout(ws.data.authTimer);
+          ws.data.unregister?.();
+          self2.sockets.delete(ws);
         }
-        resolve3(this.port);
-      });
-      server.unref();
+      }
     });
+    this.server = server;
+    this.port = server.port ?? 0;
+    try {
+      this.warnIfOtherLiveInstance();
+      const dir = dirname5(this.portFilePath);
+      mkdirSync9(dir, { recursive: true, mode: 448 });
+      try {
+        chmodSync2(dir, 448);
+      } catch {}
+      const tmpPath = `${this.portFilePath}.tmp`;
+      try {
+        rmSync2(tmpPath, { force: true });
+      } catch {}
+      writeFileSync8(tmpPath, JSON.stringify({
+        port: this.port,
+        pid: process.pid,
+        started_at: this.startedAt,
+        token: this.token
+      }), { encoding: "utf-8", mode: 384 });
+      renameSync3(tmpPath, this.portFilePath);
+      try {
+        chmodSync2(this.portFilePath, 384);
+      } catch {}
+      log(`[rpc] server listening on 127.0.0.1:${this.port}`);
+    } catch (err) {
+      log(`[rpc] failed to write port file: ${err}`);
+    }
+    return this.port;
+  }
+  stop() {
+    for (const ws of this.sockets) {
+      try {
+        if (ws.data.authTimer)
+          clearTimeout(ws.data.authTimer);
+        ws.data.unregister?.();
+        ws.close();
+      } catch {}
+    }
+    this.sockets.clear();
+    if (this.server) {
+      this.server.stop(true);
+      this.server = null;
+    }
+    try {
+      unlinkSync4(this.portFilePath);
+    } catch {}
   }
   warnIfOtherLiveInstance() {
     try {
@@ -195747,73 +195972,99 @@ class MagicContextRpcServer {
       }
     } catch {}
   }
-  stop() {
-    if (this.server) {
-      this.server.close();
-      this.server = null;
+  async handleFetch(req, srv) {
+    const url2 = new URL(req.url);
+    if (url2.pathname === "/ws") {
+      const ok = srv.upgrade(req, { data: { authed: false } });
+      if (ok)
+        return;
+      return new Response("upgrade failed", { status: 400 });
     }
-    try {
-      unlinkSync4(this.portFilePath);
-    } catch {}
-  }
-  dispatch(req, res) {
-    const url2 = req.url ?? "";
-    if (req.method === "GET" && url2 === "/health") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true, pid: process.pid }));
-      return;
+    if (req.method === "GET" && url2.pathname === "/health") {
+      return json2({ ok: true, pid: process.pid });
     }
-    if (req.method !== "POST" || !url2.startsWith("/rpc/")) {
-      res.writeHead(404);
-      res.end("Not Found");
-      return;
+    if (req.method !== "POST" || !url2.pathname.startsWith("/rpc/")) {
+      return new Response("Not Found", { status: 404 });
     }
-    const auth = req.headers.authorization;
+    const auth = req.headers.get("authorization");
     const presented = typeof auth === "string" ? auth.replace(/^Bearer\s+/i, "") : "";
     if (!tokensMatch(presented, this.token)) {
-      res.writeHead(401, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Unauthorized" }));
-      req.resume();
-      return;
+      return json2({ error: "Unauthorized" }, 401);
     }
-    const method = url2.slice(5);
+    const method = url2.pathname.slice(5);
     const handler = this.handlers.get(method);
     if (!handler) {
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: `Unknown method: ${method}` }));
-      return;
+      return json2({ error: `Unknown method: ${method}` }, 404);
     }
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString();
-      if (body.length > 1048576) {
-        res.writeHead(413);
-        res.end("Request too large");
-        req.destroy();
-      }
-    });
-    req.on("end", () => {
-      let params = {};
+    const bodyText = await req.text();
+    if (bodyText.length > MAX_BODY_BYTES) {
+      return new Response("Request too large", { status: 413 });
+    }
+    let params = {};
+    if (bodyText.length > 0) {
       try {
-        if (body.length > 0) {
-          params = JSON.parse(body);
-        }
+        params = JSON.parse(bodyText);
       } catch {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Invalid JSON" }));
+        return json2({ error: "Invalid JSON" }, 400);
+      }
+    }
+    try {
+      const result = await handler(params);
+      return json2(result);
+    } catch (err) {
+      log(`[rpc] handler error: ${method} => ${err}`);
+      return json2({ error: String(err) }, 500);
+    }
+  }
+  handleWsMessage(ws, raw) {
+    let msg;
+    try {
+      msg = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
+    } catch {
+      return;
+    }
+    if (msg.type === "hello") {
+      if (!tokensMatch(typeof msg.token === "string" ? msg.token : "", this.token)) {
+        ws.send(JSON.stringify({ type: "error", error: "unauthorized" }));
+        ws.close(WS_CLOSE_UNAUTHORIZED, "bad token");
         return;
       }
-      handler(params).then((result) => {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(result));
-      }).catch((err) => {
-        log(`[rpc] handler error: ${method} => ${err}`);
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: String(err) }));
-      });
-    });
+      if (ws.data.authTimer) {
+        clearTimeout(ws.data.authTimer);
+        ws.data.authTimer = undefined;
+      }
+      ws.data.authed = true;
+      ws.data.sessionId = typeof msg.sessionId === "string" && msg.sessionId.length > 0 ? msg.sessionId : undefined;
+      const sink = {
+        sessionId: ws.data.sessionId,
+        send: (notification) => {
+          ws.send(JSON.stringify({ type: "notification", notification }));
+        }
+      };
+      ws.data.unregister = registerNotificationSink(sink);
+      this.sockets.add(ws);
+      const lastReceivedId = Number(msg.lastReceivedId ?? 0);
+      const backlog = drainNotifications(Number.isFinite(lastReceivedId) ? lastReceivedId : 0, ws.data.sessionId);
+      for (const notification of backlog) {
+        ws.send(JSON.stringify({ type: "notification", notification }));
+      }
+      ws.send(JSON.stringify({ type: "hello-ack" }));
+      return;
+    }
+    if (msg.type === "ack") {
+      const lastReceivedId = Number(msg.lastReceivedId ?? 0);
+      if (Number.isFinite(lastReceivedId) && lastReceivedId > 0) {
+        drainNotifications(lastReceivedId, ws.data.sessionId);
+      }
+    }
   }
 }
+function json2(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
 
 // src/index.ts
 var server = async (ctx) => {

package/dist/plugin/rpc-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-handlers.d.ts","sourceRoot":"","sources":["../../src/plugin/rpc-handlers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE,OAAO,EACH,KAAK,eAAe,IAAI,QAAQ,EAGnC,MAAM,mCAAmC,CAAC;AAc3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAqBlF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAe,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AA0FtF,wBAAgB,oBAAoB,CAChC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,EAK9B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,eAAe,CAuVjB;AAED,wBAAgB,iBAAiB,CAC7B,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,GAC/B,YAAY,CAyKd;AA4BD;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,gBAAgB,CAAC;CACtC,GACF,IAAI,CAyPN"}
+{"version":3,"file":"rpc-handlers.d.ts","sourceRoot":"","sources":["../../src/plugin/rpc-handlers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE,OAAO,EACH,KAAK,eAAe,IAAI,QAAQ,EAGnC,MAAM,mCAAmC,CAAC;AAc3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAoBlF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAe,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AA0FtF,wBAAgB,oBAAoB,CAChC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,EAK9B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,eAAe,CAuVjB;AAED,wBAAgB,iBAAiB,CAC7B,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,GAC/B,YAAY,CAyKd;AA4BD;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,gBAAgB,CAAC;CACtC,GACF,IAAI,CA4ON"}

package/dist/shared/announcement.d.ts

@@ -18,7 +18,7 @@
  * Bump only when there are user-visible changes worth a startup dialog.
  * Does NOT need to match the published package version.
  */
-export declare const ANNOUNCEMENT_VERSION = "0.30.1";
+export declare const ANNOUNCEMENT_VERSION = "0.30.2";
 /**
  * Short, user-facing bullet strings. Keep each line ~80 chars or shorter so the
  * TUI dialog renders cleanly without horizontal scroll on a typical terminal.

package/dist/shared/data-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-path.d.ts","sourceRoot":"","sources":["../../src/shared/data-path.ts"],"names":[],"mappings":"AAGA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAEvD,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAEhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAErF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnE;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAkBxE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,uCAAuC,IAAI,MAAM,CAEhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}
+{"version":3,"file":"data-path.d.ts","sourceRoot":"","sources":["../../src/shared/data-path.ts"],"names":[],"mappings":"AAGA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAEvD,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAEhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAOhF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAErF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnE;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAkBxE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,uCAAuC,IAAI,MAAM,CAEhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}