@threadbase-sh/streamer 1.31.1 → 1.31.3

package/dist/cli.cjs

@@ -29489,6 +29489,7 @@ var require_receiver = __commonJS({
         this._opcode = 0;
         this._totalPayloadLength = 0;
         this._messageLength = 0;
+        this._numFragments = 0;
         this._fragments = [];
         this._errored = false;
         this._loop = false;
@@ -29839,23 +29840,23 @@ var require_receiver = __commonJS({
           this.controlMessage(data, cb2);
           return;
         }
+        if (this._maxFragments > 0 && ++this._numFragments > this._maxFragments) {
+          const error51 = this.createError(
+            RangeError,
+            "Too many message fragments",
+            false,
+            1008,
+            "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+          );
+          cb2(error51);
+          return;
+        }
         if (this._compressed) {
           this._state = INFLATING;
           this.decompress(data, cb2);
           return;
         }
         if (data.length) {
-          if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
-            const error51 = this.createError(
-              RangeError,
-              "Too many message fragments",
-              false,
-              1008,
-              "WS_ERR_TOO_MANY_BUFFERED_PARTS"
-            );
-            cb2(error51);
-            return;
-          }
           this._messageLength = this._totalPayloadLength;
           this._fragments.push(data);
         }
@@ -29885,17 +29886,6 @@ var require_receiver = __commonJS({
               cb2(error51);
               return;
             }
-            if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
-              const error51 = this.createError(
-                RangeError,
-                "Too many message fragments",
-                false,
-                1008,
-                "WS_ERR_TOO_MANY_BUFFERED_PARTS"
-              );
-              cb2(error51);
-              return;
-            }
             this._fragments.push(buf);
           }
           this.dataMessage(cb2);
@@ -29918,6 +29908,7 @@ var require_receiver = __commonJS({
         this._totalPayloadLength = 0;
         this._messageLength = 0;
         this._fragmented = 0;
+        this._numFragments = 0;
         this._fragments = [];
         if (this._opcode === 2) {
           let data;
@@ -31418,8 +31409,8 @@ var require_websocket = __commonJS({
         autoPong: true,
         closeTimeout: CLOSE_TIMEOUT,
         protocolVersion: protocolVersions[1],
-        maxBufferedChunks: 1024 * 1024,
-        maxFragments: 128 * 1024,
+        maxBufferedChunks: 256 * 1024,
+        maxFragments: 16 * 1024,
         maxPayload: 100 * 1024 * 1024,
         skipUTF8Validation: false,
         perMessageDeflate: true,
@@ -32006,9 +31997,9 @@ var require_websocket_server = __commonJS({
        *     called
        * @param {Function} [options.handleProtocols] A hook to handle protocols
        * @param {String} [options.host] The hostname where to bind the server
-       * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+       * @param {Number} [options.maxBufferedChunks=262144] The maximum number of
        *     buffered data chunks
-       * @param {Number} [options.maxFragments=131072] The maximum number of message
+       * @param {Number} [options.maxFragments=16384] The maximum number of message
        *     fragments
        * @param {Number} [options.maxPayload=104857600] The maximum allowed message
        *     size
@@ -32031,8 +32022,8 @@ var require_websocket_server = __commonJS({
         options = {
           allowSynchronousEvents: true,
           autoPong: true,
-          maxBufferedChunks: 1024 * 1024,
-          maxFragments: 128 * 1024,
+          maxBufferedChunks: 256 * 1024,
+          maxFragments: 16 * 1024,
           maxPayload: 100 * 1024 * 1024,
           skipUTF8Validation: false,
           perMessageDeflate: false,
@@ -145337,14 +145328,8 @@ var StreamerServer = class {
           this.conversationsRepo = new ConversationsRepository(this.cache);
           this.sessionsRepo = new SessionsRepository(this.sessionStore);
           this.cacheMetadataRepo = new CacheMetadataRepository(db);
-          if (this.scanProfiles && this.scanProfiles.length > 0) {
-            for (const profile of this.scanProfiles) {
-              if (profile.enabled) {
-                this.fileWatcher.watchDirectory((0, import_path23.join)(profile.configDir, "projects"));
-              }
-            }
-          } else {
-            this.fileWatcher.watchDirectory((0, import_path23.join)((0, import_os11.homedir)(), ".claude", "projects"));
+          for (const dir of this.projectsDirs()) {
+            this.fileWatcher.watchDirectory(dir);
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -145925,20 +145910,35 @@ var StreamerServer = class {
     await this.scannerReady;
     return scanner;
   }
+  /**
+   * The projects dirs disk discovery should walk — the single source of truth
+   * for "where do this server's JSONLs live", mirroring the warm-up watcher
+   * (see listen()). Derived from the enabled scanProfiles' configDirs, or the
+   * real ~/.claude/projects when no profiles are configured. An all-disabled
+   * profile set intentionally yields [] (nothing to discover), matching the
+   * watcher — it does NOT fall back to home in that case.
+   */
+  projectsDirs() {
+    if (this.scanProfiles && this.scanProfiles.length > 0) {
+      return this.scanProfiles.filter((p2) => p2.enabled).map((p2) => (0, import_path23.join)(p2.configDir, "projects"));
+    }
+    return [(0, import_path23.join)((0, import_os11.homedir)(), ".claude", "projects")];
+  }
   findJsonlPath(uuid3) {
-    const projectsDir = (0, import_path23.join)((0, import_os11.homedir)(), ".claude", "projects");
-    if (!(0, import_fs26.existsSync)(projectsDir)) return null;
     const filename = `${uuid3}.jsonl`;
-    for (const dir of (0, import_fs26.readdirSync)(projectsDir)) {
-      const fp = (0, import_path23.join)(projectsDir, dir, filename);
-      if ((0, import_fs26.existsSync)(fp)) return fp;
-      const projectDir = (0, import_path23.join)(projectsDir, dir);
-      try {
-        for (const sub of (0, import_fs26.readdirSync)(projectDir)) {
-          const subagentPath = (0, import_path23.join)(projectDir, sub, "subagents", filename);
-          if ((0, import_fs26.existsSync)(subagentPath)) return subagentPath;
+    for (const projectsDir of this.projectsDirs()) {
+      if (!(0, import_fs26.existsSync)(projectsDir)) continue;
+      for (const dir of (0, import_fs26.readdirSync)(projectsDir)) {
+        const fp = (0, import_path23.join)(projectsDir, dir, filename);
+        if ((0, import_fs26.existsSync)(fp)) return fp;
+        const projectDir = (0, import_path23.join)(projectsDir, dir);
+        try {
+          for (const sub of (0, import_fs26.readdirSync)(projectDir)) {
+            const subagentPath = (0, import_path23.join)(projectDir, sub, "subagents", filename);
+            if ((0, import_fs26.existsSync)(subagentPath)) return subagentPath;
+          }
+        } catch {
         }
-      } catch {
       }
     }
     return null;
@@ -147757,7 +147757,81 @@ async function stopService(opts = {}) {
   const { stdout: stdout2, stderr } = await execFileP("schtasks.exe", ["/End", "/TN", label]).catch(
     (err) => ({ stdout: "", stderr: String(err) })
   );
-  return { method: "schtasks-end", stdout: stdout2, stderr };
+  const listenerResult = await stopWindowsListener(opts.port ?? 8766);
+  return {
+    method: "schtasks-end",
+    stdout: `${stdout2}
+${listenerResult.stdout}`,
+    stderr: `${stderr}
+${listenerResult.stderr}`
+  };
+}
+async function stopWindowsListener(port) {
+  let netstat;
+  try {
+    netstat = await execFileP("netstat.exe", ["-ano", "-p", "tcp"]);
+  } catch (err) {
+    return { stdout: "", stderr: `Could not inspect port ${port}: ${String(err)}` };
+  }
+  const pids = /* @__PURE__ */ new Set();
+  for (const line of netstat.stdout.split(/\r?\n/)) {
+    const columns = line.trim().split(/\s+/);
+    if (columns.length < 5 || columns[0]?.toUpperCase() !== "TCP") continue;
+    const [localAddress, state, pid] = [columns[1], columns[3], columns[4]];
+    if (state?.toUpperCase() !== "LISTENING" || !pid || pid === "0") continue;
+    if (localAddress?.endsWith(`:${port}`)) pids.add(pid);
+  }
+  const output = [];
+  const errors = [];
+  for (const pid of pids) {
+    try {
+      const result = await execFileP("taskkill.exe", ["/PID", pid, "/T", "/F"]);
+      output.push(result.stdout);
+      if (result.stderr) errors.push(result.stderr);
+    } catch (err) {
+      errors.push(`Could not stop PID ${pid} on port ${port}: ${String(err)}`);
+    }
+  }
+  return { stdout: output.join("\n"), stderr: errors.join("\n") };
+}
+
+// src/updater/restart-health.ts
+function isExpectedVersion(actual, expected) {
+  return actual === expected || actual.startsWith(`${expected}+`);
+}
+async function waitForRestartHealth(opts) {
+  const timeoutMs = opts.timeoutMs ?? 15e3;
+  const pollIntervalMs = opts.pollIntervalMs ?? 250;
+  const deadline = Date.now() + timeoutMs;
+  let lastFailure = "server did not respond";
+  while (Date.now() <= deadline) {
+    const controller = new AbortController();
+    const requestTimer = setTimeout(() => controller.abort(), Math.min(2e3, timeoutMs));
+    try {
+      const response = await fetch(`http://127.0.0.1:${opts.port}/healthz`, {
+        signal: controller.signal
+      });
+      if (response.ok) {
+        const body = await response.json();
+        if (body.ok === true && typeof body.version === "string") {
+          if (isExpectedVersion(body.version, opts.expectedVersion)) return;
+          lastFailure = `running version is ${body.version}, expected ${opts.expectedVersion}`;
+        } else {
+          lastFailure = "health response is missing ok/version";
+        }
+      } else {
+        lastFailure = `health endpoint returned ${response.status}`;
+      }
+    } catch (err) {
+      lastFailure = err instanceof Error ? err.message : String(err);
+    } finally {
+      clearTimeout(requestTimer);
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await new Promise((resolve6) => setTimeout(resolve6, Math.min(pollIntervalMs, remaining)));
+  }
+  throw new Error(`restart verification failed: ${lastFailure}`);
 }
 
 // src/updater/stamp-version.ts
@@ -150899,7 +150973,7 @@ async function runInstall(opts) {
   await unpackTarball({ tarballPath, destDir });
   stampVersionTxt(destDir, targetVersion);
   if (process.platform === "win32") {
-    await stopService().catch(() => {
+    await stopService({ port: opts.runningServer?.port }).catch(() => {
     });
   }
   swapCurrent(targetVersion);
@@ -150908,6 +150982,12 @@ async function runInstall(opts) {
   try {
     const r = await restartService();
     restartMethod = r.method;
+    if (opts.runningServer && r.method !== "none") {
+      await waitForRestartHealth({
+        port: opts.runningServer.port,
+        expectedVersion: targetVersion
+      });
+    }
   } catch (err) {
     restartMethod = `failed: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -150918,8 +150998,9 @@ async function runInstall(opts) {
     pruned,
     restart: { method: restartMethod }
   };
+  const outcome = restartMethod.startsWith("failed:") ? "failed" : "installed";
   appendUpdateLog(
-    `[installed] ${installed.previous} \u2192 ${installed.installed} restart=${installed.restart.method}${pruned.length > 0 ? ` pruned=${pruned.length}` : ""}`
+    `[${outcome}] ${installed.previous} \u2192 ${installed.installed} restart=${installed.restart.method}${pruned.length > 0 ? ` pruned=${pruned.length}` : ""}`
   );
   return installed;
 }
@@ -151378,11 +151459,20 @@ program2.command("update").description("Check for streamer updates from GitHub R
         );
         break;
       case "installed":
-        log7.info(
-          `Installed ${result.installed} (was ${result.previous}). Restart: ${result.restart.method}.`,
-          void 0,
-          "console"
-        );
+        if (result.restart.method.startsWith("failed:")) {
+          log7.error(
+            `Installed ${result.installed} on disk, but the running service was not updated. Restart: ${result.restart.method}.`,
+            void 0,
+            "console"
+          );
+          process.exitCode = 1;
+        } else {
+          log7.info(
+            `Installed ${result.installed} (was ${result.previous}). Restart: ${result.restart.method}.`,
+            void 0,
+            "console"
+          );
+        }
         if (result.pruned.length > 0) {
           log7.info(`Pruned old releases: ${result.pruned.join(", ")}`, void 0, "console");
         }