@threadbase-sh/streamer 1.38.0 → 1.39.1

package/dist/index.cjs

@@ -350,6 +350,10 @@ var DANGEROUS_PERMISSION_MODES = [
 function isDangerousPermissionMode(mode) {
   return DANGEROUS_PERMISSION_MODES.includes(mode);
 }
+var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+function isEffortLevel(value) {
+  return typeof value === "string" && EFFORT_LEVELS.includes(value);
+}
 var CLAUDE_FLAGS = [
   {
     id: "permissionMode",
@@ -361,9 +365,10 @@ var CLAUDE_FLAGS = [
   { id: "addDir", flag: "--add-dir", valueType: "list", risk: "elevated" },
   { id: "allowedTools", flag: "--allowedTools", valueType: "list", risk: "elevated" },
   { id: "disallowedTools", flag: "--disallowedTools", valueType: "list", risk: "low" },
-  { id: "maxBudgetUsd", flag: "--max-budget-usd", valueType: "string", risk: "low" },
-  { id: "fallbackModel", flag: "--fallback-model", valueType: "string", risk: "low" }
+  { id: "model", flag: "--model", valueType: "string", risk: "low" },
+  { id: "effort", flag: "--effort", valueType: "enum", enumValues: EFFORT_LEVELS, risk: "low" }
 ];
+var SPAWN_POSITIONAL_FLAG_IDS = /* @__PURE__ */ new Set(["permissionMode", "model", "effort"]);
 function findFlag(id) {
   return CLAUDE_FLAGS.find((f) => f.id === id);
 }
@@ -428,7 +433,7 @@ function buildFlagArgs(values, extraArgs) {
   const args = [];
   const safe = validateFlagValues(values ?? {});
   for (const def of CLAUDE_FLAGS) {
-    if (def.id === "permissionMode") continue;
+    if (SPAWN_POSITIONAL_FLAG_IDS.has(def.id)) continue;
     const value = safe[def.id];
     if (value === void 0) continue;
     if (def.valueType === "boolean") {
@@ -4710,6 +4715,14 @@ var createSessionRoutes = (deps) => {
     await deps.handleSetSessionName(c.req.param("id"), c.env.incoming, c.env.outgoing);
     return alreadyHandled6();
   });
+  app.patch("/:id/model", async (c) => {
+    await deps.handleSetSessionModel(c.req.param("id"), c.env.incoming, c.env.outgoing);
+    return alreadyHandled6();
+  });
+  app.patch("/:id/effort", async (c) => {
+    await deps.handleSetSessionEffort(c.req.param("id"), c.env.incoming, c.env.outgoing);
+    return alreadyHandled6();
+  });
   app.post("/:id/adopt", async (c) => {
     await deps.handleAdopt(c.req.param("id"), c.env.outgoing);
     return alreadyHandled6();
@@ -5045,6 +5058,7 @@ CREATE TABLE IF NOT EXISTS conversation_meta (
 );
 CREATE INDEX IF NOT EXISTS idx_meta_last_activity ON conversation_meta(last_activity DESC);
 CREATE INDEX IF NOT EXISTS idx_meta_project ON conversation_meta(project_path);
+CREATE INDEX IF NOT EXISTS idx_meta_file_path ON conversation_meta(file_path);
 
 CREATE TABLE IF NOT EXISTS conversation_tail (
   conversation_id TEXT PRIMARY KEY REFERENCES conversation_meta(id) ON DELETE CASCADE,
@@ -8702,6 +8716,24 @@ var WSHub = class {
       this.clients.delete(client);
     }
   }
+  // Scoped broadcast for high-frequency per-session messages (terminal_output,
+  // user_message). Sending to every connected client for every PTY output
+  // chunk made broadcast() cost scale with connections x active sessions;
+  // this bounds it to only that session's subscribers.
+  broadcastToClients(clients, message) {
+    const data = JSON.stringify(message);
+    for (const client of clients) {
+      try {
+        if (client.readyState === client.OPEN) {
+          client.send(data);
+        } else {
+          this.clients.delete(client);
+        }
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
   unicast(ws, message) {
     try {
       if (ws.readyState === ws.OPEN) {
@@ -8764,6 +8796,7 @@ var ADOPT_KILL_TIMEOUT_MS = 5e3;
 var ADOPT_KILL_POLL_MS = 100;
 var REFRESH_TTL_MS = 2e3;
 var START_READY_TIMEOUT_MS = 1e4;
+var MODEL_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 var EXTERNAL_TAIL_RECENCY_MS = RESUME_BUSY_WINDOW_MS;
 var EXTERNAL_TAIL_MAX = 32;
 var EXTERNAL_TAIL_IDLE_MS = 3e5;
@@ -8834,6 +8867,20 @@ var StreamerServer = class {
   // Set by onConversationChanged while a scan is in-flight; getScanner() does
   // a single rescan after the current one completes instead of restarting it.
   scannerStale = false;
+  // WHICH files scannerStale is about. A directory event names exactly one
+  // JSONL, and the only correct response is refreshFile() on that one file —
+  // but scannerStale alone carries no identity, so honoring it used to mean a
+  // full-tree rescan. On the non-persistent scanner this server actually runs
+  // (buildStatCache => persistent:false, see listen()), scan() opens by
+  // clearing metadataCache AND conversationLRU — so one live session appending
+  // to its own transcript threw away every OTHER conversation's parsed
+  // snapshot, and the next full fetch of an unrelated conversation re-parsed
+  // it from disk (745-2877ms on a 5MB/1112-message history) while the
+  // per-file paginated path stayed at ~20ms throughout. Populated alongside
+  // scannerStale and drained with it by takeStaleFiles(); an armed flag with
+  // an EMPTY set means "stale, source unknown" and still falls back to the
+  // full rescan.
+  staleFiles = /* @__PURE__ */ new Set();
   // Single-flight guard for the background disk reconcile: a burst of list
   // polls during active session writes shares one rescan instead of queueing
   // a full rescan per request.
@@ -8867,6 +8914,8 @@ var StreamerServer = class {
   dbPool = null;
   dbInstanceId = null;
   disableDb = false;
+  // Skip the startup warm-up scan (test hook; see ServerConfig.skipStartupWarmup).
+  skipStartupWarmup;
   browseRoot = null;
   publicUrl = null;
   browserCors;
@@ -8906,6 +8955,11 @@ var StreamerServer = class {
   // every provider; read only by the idle reaper. Entries are dropped when the
   // session leaves the runner (reap/exit/hold).
   lastAgentChunkAt = /* @__PURE__ */ new Map();
+  // sessionId → last terminal_output seq broadcast (starts at 1, per session).
+  // Stamped on every terminal_output/terminal_replay so a client can detect a
+  // stale chunk delivered after a reconnect race instead of trusting raw WS
+  // arrival order. Entries dropped alongside lastAgentChunkAt.
+  terminalSeq = /* @__PURE__ */ new Map();
   // Recently accepted input idempotency keys (C4). A retried POST replays its
   // original outcome instead of submitting the prompt to the agent twice.
   idempotency = new IdempotencyStore();
@@ -8973,6 +9027,7 @@ var StreamerServer = class {
     }
     this.verbose = config.verbose ?? false;
     this.disableDb = config.disableDb ?? false;
+    this.skipStartupWarmup = config.skipStartupWarmup ?? false;
     this.scannerPersistenceDisabled = config.scannerPersistent === false;
     this.scanProfiles = config.scanProfiles;
     this.codexRoots = config.codexRoots ?? [(0, import_path18.join)((0, import_os9.homedir)(), ".codex", "sessions")];
@@ -8994,7 +9049,10 @@ var StreamerServer = class {
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
     this.markScannerStaleDebounced = debounce(() => {
       if (this.scannerReady) this.scannerStale = true;
-      else this.scanner = null;
+      else {
+        this.scanner = null;
+        this.staleFiles.clear();
+      }
     }, this.directoryDebounceMs);
     this.includeAgents = parseIncludeAgentsEnv(process.env.THREADBASE_INCLUDE_AGENTS);
     this.agentEntrypoints = parseAgentEntrypointsEnv(process.env.THREADBASE_AGENT_ENTRYPOINTS);
@@ -9087,6 +9145,7 @@ var StreamerServer = class {
         if (!tailed) this.maybeAttachExternalTail(filePath);
         this.sweepIdleExternalTails();
         this.cache?.invalidateByFilePath(filePath, { skipIfTailed: true });
+        this.staleFiles.add(filePath);
         this.markScannerStaleDebounced();
         this.log.debug?.(`Scanner invalidated by directory event: ${filePath}`, {
           filePath,
@@ -9121,10 +9180,22 @@ var StreamerServer = class {
       logger: getLogger("pty"),
       onOutput: (sessionId, data) => {
         this.lastAgentChunkAt.set(sessionId, Date.now());
-        this.wsHub.broadcast({ type: "terminal_output", sessionId, data });
+        const seq = (this.terminalSeq.get(sessionId) ?? 0) + 1;
+        this.terminalSeq.set(sessionId, seq);
+        this.wsHub.broadcastToClients(this.sessionSubscribers.get(sessionId) ?? [], {
+          type: "terminal_output",
+          sessionId,
+          data,
+          seq
+        });
       },
       onUserMessage: (sessionId, text, ts) => {
-        this.wsHub.broadcast({ type: "user_message", sessionId, text, ts });
+        this.wsHub.broadcastToClients(this.sessionSubscribers.get(sessionId) ?? [], {
+          type: "user_message",
+          sessionId,
+          text,
+          ts
+        });
       },
       onPermissionChange: (sessionId, gate) => {
         this.handlePermissionChange(sessionId, gate);
@@ -9261,6 +9332,8 @@ var StreamerServer = class {
       handleCancel: (id, res) => this.handleCancel(id, res),
       handleStopSession: (id, res) => this.handleStopSession(id, res),
       handleSetSessionName: (id, req, res) => this.handleSetSessionName(id, req, res),
+      handleSetSessionModel: (id, req, res) => this.applyLiveSessionSetting(id, req, res, "model"),
+      handleSetSessionEffort: (id, req, res) => this.applyLiveSessionSetting(id, req, res, "effort"),
       handleUploadFile: (id, req, res) => this.handleUploadFile(id, req, res),
       handleAdopt: (id, res) => this.handleAdopt(id, res),
       handleResume: (req, res) => this.handleResume(req, res),
@@ -9307,7 +9380,8 @@ var StreamerServer = class {
                   type: "terminal_replay",
                   sessionId: msg.sessionId,
                   lines,
-                  userMessages
+                  userMessages,
+                  seq: this.terminalSeq.get(msg.sessionId)
                 })
               );
             }
@@ -9667,6 +9741,7 @@ var StreamerServer = class {
       );
       this.ptyManager.putOnHold(session.id);
       this.lastAgentChunkAt.delete(session.id);
+      this.terminalSeq.delete(session.id);
       this.idempotency.clear(session.id);
       this.sessionSubscribers.delete(session.id);
       reaped.push(session.id);
@@ -9841,6 +9916,14 @@ var StreamerServer = class {
           );
           this.scannerPersistenceDisabled = true;
         }
+        if (this.skipStartupWarmup) {
+          this.log.debug?.("startup warm-up scan skipped (skipStartupWarmup)", {
+            event: "cache.warmup_skipped"
+          });
+          this.finishWarmup(0);
+          resolveWarm();
+          return;
+        }
         const warmupStatCache = this.buildStatCache(null);
         const warmupScanner = this.newScanner(warmupStatCache ? { persistent: false } : void 0);
         this.allScanners.add(warmupScanner);
@@ -10032,6 +10115,7 @@ var StreamerServer = class {
       this.idleReaperTimer = null;
     }
     this.lastAgentChunkAt.clear();
+    this.terminalSeq.clear();
     this.recordShutdownState();
     this.markScannerStaleDebounced.cancel();
     await Promise.all([...this.inFlightCacheWrites]);
@@ -10213,6 +10297,30 @@ var StreamerServer = class {
       persisted: this.claudeFlagsPersistable
     };
   }
+  /**
+   * The three spawn options that a configured claude-flag can override, with
+   * the boot-time CLI/yaml default as the fallback. Spread into every
+   * start/resume/adopt call so all three paths agree.
+   *
+   * These ids are excluded from buildFlagArgs (SPAWN_POSITIONAL_FLAG_IDS)
+   * precisely because they arrive here instead — the PTY spawn paths pass them
+   * as explicit positionals, so emitting them from the allowlist too would
+   * duplicate the flag.
+   *
+   * Narrowed with the type guards rather than cast: ClaudeFlagValues is a loose
+   * Record by design, and while validateFlagValues already guarantees the shape
+   * on the way in, TypeScript cannot see that through the record.
+   */
+  spawnFlagOverrides() {
+    const mode = this.claudeFlags.permissionMode;
+    const model = this.claudeFlags.model;
+    const effort = this.claudeFlags.effort;
+    return {
+      permissionMode: isPermissionMode(mode) ? mode : this.defaultPermissionMode,
+      model: typeof model === "string" ? model : this.defaultModel,
+      effort: isEffortLevel(effort) ? effort : this.defaultEffort
+    };
+  }
   checkRateLimit(map, key, limit, windowMs) {
     const now = Date.now();
     const arr = (map.get(key) ?? []).filter((t) => now - t < windowMs);
@@ -10284,21 +10392,46 @@ var StreamerServer = class {
   // so a burst of list polls during active session writes shares one rescan
   // rather than queueing a full rescan each; tracked so close() awaits the
   // in-flight cache write before shutting the DB.
-  startBackgroundConversationReconcile() {
+  startBackgroundConversationReconcile(mode = "full") {
     if (this.conversationReconcileInFlight) return;
-    const task = this.reconcileConversationsCacheFromDisk().finally(() => {
+    const paths = mode === "files" ? this.takeStaleFiles() : [];
+    const task = (paths.length > 0 ? this.reconcileStaleFilesFromDisk(paths) : this.reconcileConversationsCacheFromDisk()).finally(() => {
       this.conversationReconcileInFlight = null;
     });
     this.conversationReconcileInFlight = task;
     this.trackCacheWrite(task);
   }
-  shouldAutoReconcileConversationList() {
-    if (!this.cache) return false;
-    if (this.scannerStale) return true;
-    if (!this.conversationsRepo || !this.cacheMetadataRepo) return false;
+  // "files": a directory event named specific JSONLs, so refresh only those.
+  // "full": disk drifted in ways a per-file refresh can't see (a project dir
+  // appeared, rows vanished), so walk the tree. Order matters — the staleness
+  // check short-circuits first so the HDD freshness probe stays off the hot
+  // poll path, exactly as it did when this returned a boolean.
+  conversationReconcileMode() {
+    if (!this.cache) return null;
+    if (this.scannerStale) return "files";
+    if (!this.conversationsRepo || !this.cacheMetadataRepo) return null;
     return shouldRefreshProjectsFromHdd(this.conversationsRepo, this.cacheMetadataRepo, {
       projectsDirs: this.projectsDirsForFreshnessCheck()
-    });
+    }) ? "full" : null;
+  }
+  // The per-file half of reconcileConversationsCacheFromDisk: re-index just the
+  // changed JSONLs and upsert their rows. No reconcileDeletions here — that
+  // needs the whole live-path set, and deletions already have their own path
+  // (onFileDeleted -> invalidateByFilePath). New projects still arrive via the
+  // HDD-freshness "full" mode.
+  async reconcileStaleFilesFromDisk(paths) {
+    if (!this.cache) return;
+    const scanner = await this.getScanner(true);
+    const metas = await this.refreshStaleFiles(scanner, paths);
+    if (metas.length === 0) return;
+    try {
+      this.cache.upsertFromScannerMeta(metas);
+    } catch (err) {
+      this.log.warn(
+        `stale-file reconcile failed: ${err instanceof Error ? err.message : String(err)}`,
+        { event: "conversations.reconcile_failed" }
+      );
+    }
   }
   async handleListConversations(url, res) {
     if (this.rejectIfWarmingUp(res)) return;
@@ -10308,10 +10441,11 @@ var StreamerServer = class {
     const project = url.searchParams.get("project") ?? void 0;
     const providerFilter = url.searchParams.get("provider") ?? void 0;
     const bustCache = url.searchParams.get("refresh") === "1";
-    if (this.cache && (bustCache || this.shouldAutoReconcileConversationList())) {
+    const reconcileMode = this.conversationReconcileMode();
+    if (this.cache && (bustCache || reconcileMode)) {
       const canServeStale = !bustCache && this.cache.listConversations({ limit: 0, offset: 0 }).total > 0;
       if (canServeStale) {
-        this.startBackgroundConversationReconcile();
+        this.startBackgroundConversationReconcile(reconcileMode ?? "full");
       } else {
         const shouldEmitProgress = createScanProgressThrottle();
         await this.withWarmup(
@@ -10511,21 +10645,54 @@ var StreamerServer = class {
       options ?? (this.scannerPersistenceDisabled ? { persistent: false } : void 0)
     );
   }
+  // Drain the stale set and disarm the flag together. The caller owns the
+  // returned paths: clearing before the refresh means events that land DURING
+  // it re-arm the flag and get their own pass instead of being swallowed.
+  takeStaleFiles() {
+    const paths = [...this.staleFiles];
+    this.staleFiles.clear();
+    this.scannerStale = false;
+    return paths;
+  }
+  // Reconcile exactly the JSONLs a directory event named. Failures are logged
+  // and swallowed per file: one unreadable transcript must not abort the
+  // others, and the file simply stays on its previous snapshot until the next
+  // event — the same outcome the full rescan gave on a parse failure.
+  async refreshStaleFiles(scanner, paths) {
+    const metas = await Promise.all(
+      paths.map(
+        (filePath) => scanner.refreshFile(filePath).catch((err) => {
+          this.log.warn("scanner.refreshFile: failed", {
+            event: "scanner.refresh_failed",
+            filePath,
+            trigger: "directory-event",
+            err
+          });
+          return null;
+        })
+      )
+    );
+    return metas.filter((m) => m !== null);
+  }
   async getScanner(skipStaleRescan = false) {
     if (this.scannerReady) {
       await this.scannerReady;
       if (this.scanner) {
         if (skipStaleRescan) return this.scanner;
         if (this.scannerStale) {
-          this.scannerStale = false;
-          this.scanner = null;
-          this.scannerReady = null;
-          return this.getScanner();
+          const paths = this.takeStaleFiles();
+          if (paths.length === 0) {
+            this.scanner = null;
+            this.scannerReady = null;
+            return this.getScanner();
+          }
+          await this.refreshStaleFiles(this.scanner, paths);
+          return this.scanner ?? this.getScanner();
         }
         return this.scanner;
       }
     }
-    this.scannerStale = false;
+    this.takeStaleFiles();
     const statCache = this.buildStatCache(this.scanner);
     this.scanner = this.newScanner(statCache ? { persistent: false } : void 0);
     this.allScanners.add(this.scanner);
@@ -10559,7 +10726,7 @@ var StreamerServer = class {
   // getScanner() anti-infinite-loop guard is preserved.
   async rescanForRefresh(onProgress) {
     if (this.scannerReady) await this.scannerReady;
-    this.scannerStale = false;
+    this.takeStaleFiles();
     if (!this.scanner) {
       this.scanner = new import_scanner3.ConversationScanner();
       this.allScanners.add(this.scanner);
@@ -11362,11 +11529,9 @@ var StreamerServer = class {
       projectPath,
       projectName: body.projectName,
       branch: body.branch,
-      permissionMode: this.defaultPermissionMode,
       claudeFlags: this.claudeFlags,
       claudeExtraArgs: this.claudeExtraArgs,
-      model: this.defaultModel,
-      effort: this.defaultEffort
+      ...this.spawnFlagOverrides()
     });
     this.sessionStore.addManaged(session);
     this.recordSessionSpawn(session);
@@ -11813,11 +11978,9 @@ var StreamerServer = class {
       projectPath,
       projectName,
       branch,
-      permissionMode: this.defaultPermissionMode,
       claudeFlags: this.claudeFlags,
       claudeExtraArgs: this.claudeExtraArgs,
-      model: this.defaultModel,
-      effort: this.defaultEffort
+      ...this.spawnFlagOverrides()
     });
     this.sessionStore.addManaged(session);
     this.recordSessionSpawn(session);
@@ -11890,11 +12053,9 @@ var StreamerServer = class {
         projectPath: resolvedPath,
         projectName: body.projectName,
         ...includeSystemPrompt && { systemPrompt: systemPromptParts.join("\n") },
-        permissionMode: this.defaultPermissionMode,
         claudeFlags: this.claudeFlags,
         claudeExtraArgs: this.claudeExtraArgs,
-        model: this.defaultModel,
-        effort: this.defaultEffort
+        ...this.spawnFlagOverrides()
       });
       this.sessionStore.addManaged(session);
       this.recordSessionSpawn(session);
@@ -12254,6 +12415,87 @@ var StreamerServer = class {
     this.cache.upsertSessionName(sessionId, name);
     json(res, 200, { ok: true });
   }
+  /**
+   * Retarget a LIVE session's model or effort by typing the corresponding
+   * Claude Code slash command into its PTY.
+   *
+   * There is no CLI or IPC channel for this — `--model`/`--effort` are spawn
+   * arguments — so the interactive `/model <x>` / `/effort <y>` commands are the
+   * only way to change a session already running. Both accept an argument and
+   * apply it without opening the picker (verified against Claude Code v2.1.220).
+   *
+   * Answers 202, not 200: the value is applied by the TUI on its next render, so
+   * there is nothing truthful to echo back synchronously. Clients confirm with
+   * `GET /api/sessions/:id`, which scrapes the applied value off the live status
+   * line.
+   */
+  async applyLiveSessionSetting(sessionId, req, res, setting) {
+    const session = this.ptyManager.getSession(sessionId);
+    if (!session) {
+      const known = this.sessionStore.getManaged(sessionId);
+      if (known) {
+        json(res, 409, {
+          error: "Session has no live PTY; resume it first",
+          code: "SESSION_IDLE"
+        });
+        return;
+      }
+      json(res, 404, { error: "Session not found" });
+      return;
+    }
+    if ((session.provider ?? CLAUDE_CODE_PROVIDER) !== CLAUDE_CODE_PROVIDER) {
+      json(res, 501, {
+        error: `Setting ${setting} on a ${session.provider} session is not supported`,
+        code: "UNSUPPORTED_PROVIDER"
+      });
+      return;
+    }
+    if (session.status === "running") {
+      json(res, 409, {
+        error: "Session is mid-turn; retry once it is waiting for input",
+        code: "SESSION_BUSY"
+      });
+      return;
+    }
+    let parsed;
+    try {
+      parsed = await readBody(req);
+    } catch {
+      json(res, 400, { error: "Invalid JSON" });
+      return;
+    }
+    let value;
+    if (setting === "effort") {
+      if (!isEffortLevel(parsed.effort)) {
+        json(res, 400, {
+          error: `effort must be one of ${EFFORT_LEVELS.join(", ")}`
+        });
+        return;
+      }
+      value = parsed.effort;
+    } else {
+      if (typeof parsed.model !== "string" || !MODEL_NAME_RE.test(parsed.model)) {
+        json(res, 400, {
+          error: "model must be an alias or full model name (letters, digits, dot, dash, underscore)"
+        });
+        return;
+      }
+      value = parsed.model;
+    }
+    try {
+      this.ptyManager.sendKeys(sessionId, `/${setting} ${value}\r`);
+    } catch (err) {
+      json(res, 400, { error: err instanceof Error ? err.message : "Failed to write to session" });
+      return;
+    }
+    this.log.info(`Live session ${setting} set to ${value}`, {
+      event: "session.setting_applied",
+      sessionId,
+      setting,
+      value
+    });
+    json(res, 202, { id: sessionId, [setting]: value });
+  }
   handleGetSessionNames(res) {
     if (!this.cache) {
       json(res, 200, {});