@threadbase-sh/streamer 1.15.4 → 1.16.1

package/dist/index.cjs

@@ -1229,6 +1229,7 @@ function stripAnsi(str) {
 var import_node_ws = require("@hono/node-ws");
 var import_client = require("@temporalio/client");
 var import_scanner2 = require("@threadbase-sh/scanner");
+var import_events = require("events");
 var import_fs11 = require("fs");
 var import_promises5 = require("fs/promises");
 var import_http = require("http");
@@ -1878,6 +1879,10 @@ var createSessionRoutes = (deps) => {
     await deps.handleAdopt(c.req.param("id"), c.env.outgoing);
     return alreadyHandled6();
   });
+  app.post("/:id/stop", async (c) => {
+    await deps.handleStopSession(c.req.param("id"), c.env.outgoing);
+    return alreadyHandled6();
+  });
   app.get("/:id", (c) => {
     deps.handleGetSession(c.req.param("id"), c.env.outgoing);
     return alreadyHandled6();
@@ -3961,7 +3966,9 @@ var StreamerServer = class {
   log = getLogger("server");
   agentConfig;
   agentClient = null;
+  sessionStatusBus = new import_events.EventEmitter();
   constructor(config) {
+    this.sessionStatusBus.setMaxListeners(0);
     this.apiKey = config.apiKey;
     this.localNoAuth = config.localNoAuth ?? false;
     this.verbose = config.verbose ?? false;
@@ -4078,6 +4085,7 @@ var StreamerServer = class {
         if (resp) {
           this.wsHub.broadcast({ type: "session_update", session: resp });
         }
+        this.sessionStatusBus.emit(`status:${session.id}`, session.status);
       }
     });
     this.agentConfig = readAgentConfig();
@@ -4123,6 +4131,7 @@ var StreamerServer = class {
       handleGetOutput: (id, res) => this.handleGetOutput(id, res),
       handleSendInput: (id, req, res) => this.handleSendInput(id, req, res),
       handleCancel: (id, res) => this.handleCancel(id, res),
+      handleStopSession: (id, res) => this.handleStopSession(id, res),
       handleSetSessionName: (id, req, res) => this.handleSetSessionName(id, req, res),
       handleUploadFile: (id, req, res) => this.handleUploadFile(id, req, res),
       handleAdopt: (id, res) => this.handleAdopt(id, res),
@@ -4631,22 +4640,36 @@ var StreamerServer = class {
   async handleConversationsCount(url, res) {
     const project = url.searchParams.get("project") ?? void 0;
     const bustCache = url.searchParams.get("refresh") === "1";
-    if (bustCache) {
-      this.cache?.invalidate();
-      this.scanner = null;
-      this.scannerReady = null;
-    }
-    if (this.cache && !bustCache) {
+    if (this.cache) {
       const { total } = this.cache.listConversations({ project, limit: 0, offset: 0 });
       json(res, 200, { total });
+      if (bustCache) this.refreshCountInBackground();
       return;
     }
-    const scanner = await this.getScanner();
+    const scanner = await this.getScanner(true);
     let metas = [...scanner.getMetadataCache().values()];
     metas = (0, import_scanner2.applyIncludeFilter)(metas, "conversations");
     if (project) metas = (0, import_scanner2.applyProjectFilter)(metas, project);
     json(res, 200, { total: metas.length });
   }
+  // Fire-and-forget full rescan that reconciles the SQLite cache from disk so a
+  // later count reflects new/removed conversations. Never awaited by the request
+  // path — refresh=1 returns the cached total synchronously and this catches up.
+  refreshCountInBackground() {
+    void (async () => {
+      try {
+        const scanner = await this.getFreshScanner();
+        if (this.cache) {
+          this.cache.upsertFromScannerMeta([...scanner.getMetadataCache().values()]);
+        }
+      } catch (err) {
+        this.log.warn(
+          `Background count refresh failed: ${err instanceof Error ? err.message : String(err)}`,
+          { event: "count.refresh_failed" }
+        );
+      }
+    })();
+  }
   handleSessionsCount(res) {
     json(res, 200, { total: this.sessionStore.list(this.ptyAttachedIds()).length });
   }
@@ -5301,6 +5324,54 @@ var StreamerServer = class {
       json(res, 400, { error: message });
     }
   }
+  async handleStopSession(sessionId, res) {
+    const STOP_TIMEOUT_MS = 5e3;
+    const session = this.ptyManager.getSession(sessionId);
+    if (!session) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Session not found" }));
+      return;
+    }
+    if (session.status === "idle") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "already_idle", sessionId }));
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": "application/x-ndjson",
+      "Transfer-Encoding": "chunked",
+      "Cache-Control": "no-cache",
+      "X-Accel-Buffering": "no"
+    });
+    res.write(`${JSON.stringify({ event: "stopping", sessionId })}
+`);
+    const idlePromise = new Promise((resolve2) => {
+      const handler = (status) => {
+        if (status === "idle") {
+          this.sessionStatusBus.off(`status:${sessionId}`, handler);
+          resolve2("idle");
+        }
+      };
+      this.sessionStatusBus.on(`status:${sessionId}`, handler);
+    });
+    const timeoutPromise = new Promise(
+      (resolve2) => setTimeout(() => resolve2("timeout"), STOP_TIMEOUT_MS)
+    );
+    this.ptyManager.putOnHold(sessionId);
+    this.discoveryCache = null;
+    const outcome = await Promise.race([idlePromise, timeoutPromise]);
+    if (outcome === "idle") {
+      res.write(`${JSON.stringify({ event: "stopped", sessionId })}
+`);
+    } else {
+      res.write(`${JSON.stringify({ event: "timeout", sessionId })}
+`);
+      this.log.warn(
+        `[stop] session ${sessionId.slice(0, 8)} did not idle within ${STOP_TIMEOUT_MS}ms`
+      );
+    }
+    res.end();
+  }
   async handleAdopt(sessionId, res) {
     const discovered = await discoverClaudeProcesses();
     this.sessionStore.setDiscovered(discovered);