@threadbase-sh/streamer 1.24.7 → 1.26.0

package/dist/index.js

@@ -324,6 +324,15 @@ function loadPublicUrl() {
   }
   return void 0;
 }
+function loadBrowserCors() {
+  try {
+    const content = readFileSync(configFile(), "utf-8");
+    const match = content.match(/browser_cors:\s*(.+)/);
+    if (match?.[1]) return match[1].trim();
+  } catch {
+  }
+  return void 0;
+}
 function loadCacheDir() {
   try {
     const content = readFileSync(configFile(), "utf-8");
@@ -342,6 +351,16 @@ function loadTailSize() {
   }
   return void 0;
 }
+function loadDefaultPermissionMode() {
+  try {
+    const content = readFileSync(configFile(), "utf-8");
+    const match = content.match(/default_permission_mode:\s*(\S+)/);
+    const value = match?.[1]?.trim();
+    if (value === "acceptEdits" || value === "manual") return value;
+  } catch {
+  }
+  return void 0;
+}
 function validatePublicUrl(raw) {
   let parsed;
   try {
@@ -1301,6 +1320,37 @@ function detectShellPrompt(lines) {
   return null;
 }
 
+// src/utils/debounce.ts
+function debounce(fn, waitMs) {
+  let timer = null;
+  let lastArgs = null;
+  const run2 = () => {
+    timer = null;
+    if (lastArgs) {
+      const args = lastArgs;
+      lastArgs = null;
+      fn(...args);
+    }
+  };
+  const debounced = (...args) => {
+    lastArgs = args;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(run2, waitMs);
+  };
+  debounced.cancel = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    lastArgs = null;
+  };
+  debounced.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      run2();
+    }
+  };
+  return debounced;
+}
+
 // src/pty-manager.ts
 var OUTPUT_BUFFER_MAX2 = 65536;
 var PTY_COLS2 = 120;
@@ -1308,11 +1358,13 @@ var PTY_ROWS2 = 40;
 var SCREEN_SCROLLBACK2 = 1e3;
 var CLAUDE_PROMPT_MARKERS = ["\u256D", "\u276F"];
 var PROMPT_MARKER_FALLBACK_MS = 1e4;
+var QUIET_DETECT_MS = 500;
 function buildPasteBytes(input) {
   return `\x1B[200~${input}\x1B[201~`;
 }
 var SUBMIT_BYTES2 = "\r";
 var SUBMIT_DELAY_MS = 16;
+var SUBMIT_MAX_WAIT_MS = 500;
 function digestBytes2(s) {
   const escaped = s.replace(new RegExp(String.fromCharCode(27), "g"), "\\x1b").replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\t/g, "\\t");
   if (escaped.length <= 200) return escaped;
@@ -1389,6 +1441,10 @@ var PTYManager = class {
   // to a given input or fell silent. Reset on dispose().
   chunkIndex = /* @__PURE__ */ new Map();
   lastChunkAt = /* @__PURE__ */ new Map();
+  // Per-session debounced "went quiet" checker, re-armed on every chunk. Fires
+  // QUIET_DETECT_MS after the last chunk so ready/prompt detection doesn't
+  // wait for another chunk that may never arrive (Claude blocked on input).
+  quietCheckers = /* @__PURE__ */ new Map();
   // In-flight start()/startFresh() calls keyed by sessionId. A second
   // concurrent resume for the same session (double-tap, client retry) awaits
   // the first call's promise instead of spawning a duplicate PTY (CRITICAL #3).
@@ -1404,16 +1460,19 @@ var PTYManager = class {
   }
   // Resume an existing Claude conversation. sessionId is the JSONL UUID.
   //
-  // We use `--permission-mode acceptEdits` rather than `--dangerously-skip-permissions`.
-  // Both suppress file-edit prompts, but in an interactive (TUI) launch the
-  // skip-permissions flag renders a blocking "Bypass Permissions mode" warning
-  // menu on every boot that no known ~/.claude.json flag suppressed (as of
-  // Claude CLI v2.1.x) — the session never reaches a usable prompt, so the
-  // mobile app shows an empty/stuck screen. `acceptEdits` auto-approves file edits
+  // options.permissionMode defaults to `acceptEdits` rather than
+  // `--dangerously-skip-permissions`/`bypassPermissions`. Both suppress
+  // file-edit prompts, but in an interactive (TUI) launch the skip-permissions
+  // flag renders a blocking "Bypass Permissions mode" warning menu on every
+  // boot that no known ~/.claude.json flag suppressed (as of Claude CLI
+  // v2.1.x) — the session never reaches a usable prompt, so the mobile app
+  // shows an empty/stuck screen. `acceptEdits` auto-approves file edits
   // without that warning gate, while still prompting for shell commands.
+  // `manual` (prompt for everything) is the only other mode callers may pass;
+  // `bypassPermissions`/`plan`/`dontAsk`/`auto` are not supported here.
   // (The other first-run gates — onboarding/theme, workspace trust,
   // custom-API-key — are cleared by the seeded ~/.claude.json in
-  // docker/entrypoint.sh.) startFresh() uses the same flag for the same reason.
+  // docker/entrypoint.sh.) startFresh() uses the same default for the same reason.
   async start(sessionId, options) {
     const existing = this.sessions.get(sessionId);
     if (existing) return toPublicSession2(existing);
@@ -1432,7 +1491,7 @@ var PTYManager = class {
       resolveClaudeExe(),
       [
         "--permission-mode",
-        "acceptEdits",
+        options.permissionMode ?? "acceptEdits",
         "--settings",
         '{"spinnerTipsEnabled":false}',
         "--resume",
@@ -1481,7 +1540,7 @@ var PTYManager = class {
     const projectName = options.projectName ?? basename2(options.projectPath);
     const args = [
       "--permission-mode",
-      "acceptEdits",
+      options.permissionMode ?? "acceptEdits",
       "--settings",
       '{"spinnerTipsEnabled":false}',
       "--session-id",
@@ -1575,9 +1634,20 @@ var PTYManager = class {
     session.promptCount++;
     return session.promptCount;
   }
-  // Two-step paste-then-submit. Writes the bracketed-paste body, yields the
-  // event loop for SUBMIT_DELAY_MS, then writes \r. See buildPasteBytes() for
-  // why the split matters.
+  // Two-step paste-then-submit. Writes the bracketed-paste body, then waits
+  // for the PTY to go quiet before writing \r. See buildPasteBytes() for why
+  // the split matters.
+  //
+  // The wait is quiescence-based, not a flat delay: a fixed SUBMIT_DELAY_MS
+  // timer (the original fix) still races a TUI that's mid-redraw of its own
+  // output (e.g. re-painting right after posting a question) when the paste
+  // lands — the timer can elapse and fire \r while the TUI is still busy,
+  // and that \r gets absorbed by the redraw instead of submitting (see
+  // 2026-07 session 14dda340: a "Yes" reply was accepted into the input line
+  // but never landed as a submitted JSONL turn). Polling in SUBMIT_DELAY_MS
+  // steps and only submitting once lastChunkAt hasn't advanced for a full
+  // step gives the TUI as many extra ticks as it needs, capped at
+  // SUBMIT_MAX_WAIT_MS so a silent/wedged PTY still gets its \r eventually.
   writeSubmit(sessionId, session, input, path, promptCount) {
     const pasteBytes = buildPasteBytes(input);
     this.log.info(
@@ -1592,12 +1662,21 @@ var PTYManager = class {
         phase: "paste"
       }
     );
+    const pasteAt = Date.now();
     session.process.write(pasteBytes);
-    setTimeout(() => {
+    const trySubmit = () => {
       const current = this.sessions.get(sessionId);
       if (!current || current !== session) return;
+      const now = Date.now();
+      const lastChunk = this.lastChunkAt.get(sessionId) ?? pasteAt;
+      const quiet = now - lastChunk >= SUBMIT_DELAY_MS;
+      const timedOut = now - pasteAt >= SUBMIT_MAX_WAIT_MS;
+      if (!quiet && !timedOut) {
+        setTimeout(trySubmit, SUBMIT_DELAY_MS);
+        return;
+      }
       this.log.info(
-        `[pty.input.submit] ${sessionId.slice(0, 8)} promptCount=${promptCount} digest=\\r`,
+        `[pty.input.submit] ${sessionId.slice(0, 8)} promptCount=${promptCount} digest=\\r waitedMs=${now - pasteAt} timedOut=${timedOut}`,
         {
           event: "pty.input_write",
           sessionId,
@@ -1605,11 +1684,14 @@ var PTYManager = class {
           byteLen: SUBMIT_BYTES2.length,
           digest: "\\r",
           path,
-          phase: "submit"
+          phase: "submit",
+          waitedMs: now - pasteAt,
+          timedOut
         }
       );
       current.process.write(SUBMIT_BYTES2);
-    }, SUBMIT_DELAY_MS);
+    };
+    setTimeout(trySubmit, SUBMIT_DELAY_MS);
   }
   // Drain any inputs that were sent while the session was still pendingReady,
   // writing them in arrival order now that Claude is at its prompt.
@@ -1658,6 +1740,8 @@ var PTYManager = class {
     this.permissionOpen.delete(sessionId);
     this.lastScreenQuestionKey.delete(sessionId);
     this.shellPromptOpen.delete(sessionId);
+    this.quietCheckers.get(sessionId)?.cancel();
+    this.quietCheckers.delete(sessionId);
     try {
       session.process.kill("SIGINT");
     } catch {
@@ -1717,6 +1801,8 @@ var PTYManager = class {
     this.firstChunkAt.clear();
     this.chunkIndex.clear();
     this.lastChunkAt.clear();
+    for (const quiet of this.quietCheckers.values()) quiet.cancel();
+    this.quietCheckers.clear();
     this.permissionOpen.clear();
     this.lastScreenQuestionKey.clear();
     this.shellPromptOpen.clear();
@@ -1770,6 +1856,12 @@ var PTYManager = class {
         err
       });
     });
+    let quiet = this.quietCheckers.get(sessionId);
+    if (!quiet) {
+      quiet = debounce(() => this.handleQuiet(sessionId), QUIET_DETECT_MS);
+      this.quietCheckers.set(sessionId, quiet);
+    }
+    quiet();
   }
   // Detect permission gates (OSC 777 + scraped options) and AskUserQuestion
   // menus from the rendered screen, firing the additive callbacks. Async because
@@ -1845,6 +1937,24 @@ var PTYManager = class {
       }
     }
   }
+  // Fired QUIET_DETECT_MS after the last PTY chunk. Re-runs the same
+  // ready/prompt detection handleOutput() runs per-chunk, using the last
+  // rendered output — a session blocked on a prompt (or an unmarked boot
+  // screen) may never produce another chunk to trigger detection otherwise.
+  handleQuiet(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session?.status !== "running") return;
+    if (this.pendingReady.has(sessionId)) {
+      this.markReady(sessionId, session, "quiet:timeout");
+    }
+    this.detectLivePrompts(sessionId, "", session.lastOutput).catch((err) => {
+      this.log.warn("[pty.prompt_detect] failed", {
+        event: "pty.prompt_detect_failed",
+        sessionId,
+        err
+      });
+    });
+  }
   // Transition a session from "running" to "waiting_input", clear pendingReady,
   // and flush any queued input. Idempotent: callers can invoke at any chunk.
   markReady(sessionId, session, reason) {
@@ -1885,6 +1995,8 @@ var PTYManager = class {
     this.permissionOpen.delete(sessionId);
     this.lastScreenQuestionKey.delete(sessionId);
     this.shellPromptOpen.delete(sessionId);
+    this.quietCheckers.get(sessionId)?.cancel();
+    this.quietCheckers.delete(sessionId);
   }
 };
 function toPublicSession2(s) {
@@ -2471,25 +2583,55 @@ var authMiddleware = (deps) => async (c, next) => {
 };
 
 // src/api/middleware/cors.middleware.ts
-var ALLOWED_ORIGINS = /* @__PURE__ */ new Set([
+var DEFAULT_DEV_ORIGINS = [
   "http://localhost:8081",
   "http://localhost:19006",
   "http://localhost:3000"
-]);
-var corsMiddleware = () => async (c, next) => {
-  const origin = c.req.header("origin");
-  const allowedOrigin = origin && ALLOWED_ORIGINS.has(origin) ? origin : null;
-  if (allowedOrigin) {
-    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-Headers", "Authorization, Content-Type, If-None-Match");
-    c.res.headers.set("Access-Control-Expose-Headers", "ETag");
-  }
-  if (c.req.method === "OPTIONS") {
-    return c.newResponse(null, allowedOrigin ? 204 : 403);
-  }
-  await next();
+];
+function resolveAllowedOrigins(raw) {
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  const lower = trimmed.toLowerCase();
+  if (lower === "0" || lower === "false" || lower === "no" || lower === "off" || trimmed === "") {
+    return null;
+  }
+  const origins = new Set(DEFAULT_DEV_ORIGINS);
+  if (!["1", "true", "yes", "on"].includes(lower)) {
+    for (const o of trimmed.split(",")) {
+      const origin = o.trim();
+      if (origin) origins.add(origin);
+    }
+  }
+  return origins;
+}
+var corsMiddleware = (configValue) => {
+  const allowedOrigins = resolveAllowedOrigins(
+    process.env.THREADBASE_ALLOW_BROWSER_CORS ?? configValue
+  );
+  return async (c, next) => {
+    const origin = c.req.header("origin");
+    const allowedOrigin = allowedOrigins && origin && allowedOrigins.has(origin) ? origin : null;
+    if (allowedOrigin) {
+      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-Headers", "Authorization, Content-Type, If-None-Match");
+      raw.setHeader("Access-Control-Expose-Headers", "ETag");
+      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-Headers",
+        "Authorization, Content-Type, If-None-Match"
+      );
+      c.res.headers.set("Access-Control-Expose-Headers", "ETag");
+    }
+    if (c.req.method === "OPTIONS") {
+      return c.newResponse(null, allowedOrigin ? 204 : 403);
+    }
+    await next();
+  };
 };
 
 // src/api/middleware/error.middleware.ts
@@ -2904,7 +3046,7 @@ var createHonoApp = (deps, upgradeWebSocket) => {
       event: "http.request"
     });
   });
-  app.use("*", corsMiddleware());
+  app.use("*", corsMiddleware(deps.browserCors));
   app.use("*", authMiddleware(deps));
   app.onError(errorMiddleware);
   app.route("/healthz", createHealthRoutes());
@@ -3186,11 +3328,11 @@ var ConversationCache = class _ConversationCache {
         INSERT INTO conversation_meta
           (id, file_path, project_path, project_name, title, model, account, branch,
            message_count, last_activity, first_message, last_message, preview, updated_at,
-           mtime_ms, file_size, provider)
+           mtime_ms, file_size, provider, scanner_meta_json)
         VALUES
           (@id, @file_path, @project_path, @project_name, @title, @model, @account, @branch,
            @message_count, @last_activity, @first_message, @last_message, @preview, @updated_at,
-           @mtime_ms, @file_size, @provider)
+           @mtime_ms, @file_size, @provider, @scanner_meta_json)
         ON CONFLICT(id) DO UPDATE SET
           file_path     = excluded.file_path,
           project_path  = excluded.project_path,
@@ -3210,7 +3352,8 @@ var ConversationCache = class _ConversationCache {
           updated_at    = excluded.updated_at,
           mtime_ms      = excluded.mtime_ms,
           file_size     = excluded.file_size,
-          provider      = excluded.provider
+          provider      = excluded.provider,
+          scanner_meta_json = excluded.scanner_meta_json
         WHERE conversation_meta.updated_at < excluded.updated_at
       `),
       getTail: db.prepare("SELECT * FROM conversation_tail WHERE conversation_id = ?"),
@@ -3247,6 +3390,27 @@ var ConversationCache = class _ConversationCache {
       allFileStats: db.prepare(
         "SELECT file_path, mtime_ms, file_size FROM conversation_meta WHERE mtime_ms IS NOT NULL AND file_size IS NOT NULL"
       ),
+      allScannerStatCacheRows: db.prepare(
+        "SELECT file_path, mtime_ms, file_size, scanner_meta_json FROM conversation_meta WHERE mtime_ms IS NOT NULL AND file_size IS NOT NULL AND scanner_meta_json IS NOT NULL"
+      ),
+      updateScannerCache: db.prepare(
+        "UPDATE conversation_meta SET mtime_ms = ?, file_size = ?, scanner_meta_json = ? WHERE id = ?"
+      ),
+      getFileMetadata: db.prepare(
+        "SELECT mtime_ms, file_size, is_agent, agent_entrypoints_key FROM conversation_file_metadata WHERE file_path = ?"
+      ),
+      upsertFileMetadata: db.prepare(`
+        INSERT INTO conversation_file_metadata
+          (file_path, mtime_ms, file_size, is_agent, agent_entrypoints_key, updated_at)
+        VALUES
+          (@file_path, @mtime_ms, @file_size, @is_agent, @agent_entrypoints_key, @updated_at)
+        ON CONFLICT(file_path) DO UPDATE SET
+          mtime_ms = excluded.mtime_ms,
+          file_size = excluded.file_size,
+          is_agent = excluded.is_agent,
+          agent_entrypoints_key = excluded.agent_entrypoints_key,
+          updated_at = excluded.updated_at
+      `),
       upsertSessionName: db.prepare(`
         INSERT INTO session_names (session_id, name, updated_at)
         VALUES (?, ?, ?)
@@ -3287,8 +3451,35 @@ var ConversationCache = class _ConversationCache {
   getDatabase() {
     return this.db;
   }
-  getAgentEntrypoints() {
-    return this.agentEntrypoints;
+  agentEntrypointsKey() {
+    return [...this.agentEntrypoints].sort().join(",");
+  }
+  classifyAgentFile(filePath, mtimeMs, fileSize) {
+    if (this.agentEntrypoints.size === 0) return false;
+    const entrypointsKey = this.agentEntrypointsKey();
+    const cached2 = this.stmts.getFileMetadata.get(filePath);
+    if (cached2 && cached2.mtime_ms === mtimeMs && cached2.file_size === fileSize && cached2.agent_entrypoints_key === entrypointsKey) {
+      return cached2.is_agent === 1;
+    }
+    const isAgent = isAgentFile(filePath, this.agentEntrypoints);
+    this.stmts.upsertFileMetadata.run({
+      file_path: filePath,
+      mtime_ms: mtimeMs,
+      file_size: fileSize,
+      is_agent: isAgent ? 1 : 0,
+      agent_entrypoints_key: entrypointsKey,
+      updated_at: Date.now()
+    });
+    return isAgent;
+  }
+  isAgentFileCached(filePath) {
+    let s;
+    try {
+      s = statSync2(filePath);
+    } catch {
+      return false;
+    }
+    return this.classifyAgentFile(filePath, s.mtimeMs, s.size);
   }
   static open(dbPath, tailSize = 10, migrationsDir, options) {
     mkdirSync2(dirname6(dbPath), { recursive: true });
@@ -3464,11 +3655,9 @@ var ConversationCache = class _ConversationCache {
   // in conversation-cache.test.ts).
   upsertFromScannerMeta(metas) {
     const filter = this.filterAgentConversations;
-    const entrypoints = this.agentEntrypoints;
     const upsertedIds = [];
     const run2 = this.db.transaction((items) => {
       for (const m of items) {
-        if (filter && isAgentFile(m.filePath, entrypoints)) continue;
         const id = m.sessionId || m.id.split("/").pop()?.replace(/\.jsonl$/, "") || m.id;
         const lastActivityMs = m.timestamp ? new Date(m.timestamp).getTime() : null;
         let mtimeMs = null;
@@ -3480,6 +3669,10 @@ var ConversationCache = class _ConversationCache {
         } catch {
         }
         const seq = ++this.tailSeq;
+        if (filter && mtimeMs !== null && fileSize !== null && this.classifyAgentFile(m.filePath, mtimeMs, fileSize)) {
+          continue;
+        }
+        const scannerMetaJson = JSON.stringify(m);
         this.stmts.upsertFull.run({
           id,
           file_path: m.filePath,
@@ -3497,8 +3690,10 @@ var ConversationCache = class _ConversationCache {
           updated_at: seq,
           mtime_ms: mtimeMs,
           file_size: fileSize,
-          provider: m.provider ?? CLAUDE_CODE_PROVIDER
+          provider: m.provider ?? CLAUDE_CODE_PROVIDER,
+          scanner_meta_json: scannerMetaJson
         });
+        this.stmts.updateScannerCache.run(mtimeMs, fileSize, scannerMetaJson, id);
         if (this.fileIndexLoaded) this.fileIndex.set(m.filePath, id);
         upsertedIds.push(id);
       }
@@ -3622,6 +3817,21 @@ var ConversationCache = class _ConversationCache {
     }
     return map;
   }
+  getScannerStatCache() {
+    const rows = this.stmts.allScannerStatCacheRows.all();
+    const map = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      try {
+        const meta = JSON.parse(r.scanner_meta_json);
+        map.set(r.file_path, {
+          stat: { mtimeMs: r.mtime_ms, size: r.file_size },
+          meta
+        });
+      } catch {
+      }
+    }
+    return map;
+  }
   getMetaById(id) {
     const row = this.stmts.getFullById.get(id);
     if (!row) return null;
@@ -4288,7 +4498,7 @@ function pruneAgentConversations(cache) {
       missing += 1;
       continue;
     }
-    if (isAgentFile(row.file_path, cache.getAgentEntrypoints())) {
+    if (cache.isAgentFileCached(row.file_path)) {
       cache.deleteByFilePath(row.file_path);
       pruned += 1;
     }
@@ -4682,37 +4892,6 @@ function computeConversationEtag({
   return `"${digest}"`;
 }
 
-// src/utils/debounce.ts
-function debounce(fn, waitMs) {
-  let timer = null;
-  let lastArgs = null;
-  const run2 = () => {
-    timer = null;
-    if (lastArgs) {
-      const args = lastArgs;
-      lastArgs = null;
-      fn(...args);
-    }
-  };
-  const debounced = (...args) => {
-    lastArgs = args;
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(run2, waitMs);
-  };
-  debounced.cancel = () => {
-    if (timer) clearTimeout(timer);
-    timer = null;
-    lastArgs = null;
-  };
-  debounced.flush = () => {
-    if (timer) {
-      clearTimeout(timer);
-      run2();
-    }
-  };
-  return debounced;
-}
-
 // src/utils/dates.ts
 import { compareDesc, isValid, parseISO } from "date-fns";
 function parseIsoDateOrNull(value) {
@@ -4859,6 +5038,7 @@ var WSHub = class {
 var BROWSE_SYSTEM_PROMPT = (browseRoot) => `You are working within the project boundary: ${browseRoot}. Do not read, write, or execute commands that access files or directories outside this boundary.`;
 var DEFAULT_SYSTEM_PROMPT = "When presenting options or choices to the user, limit the options to at most 3.";
 var DEFAULT_PTY_GRACE_PERIOD_MS = 27e4;
+var START_READY_TIMEOUT_MS = 15e3;
 function parseIncludeAgentsEnv(raw) {
   if (raw === void 0) return false;
   const v = raw.trim().toLowerCase();
@@ -4921,12 +5101,14 @@ var StreamerServer = class {
   disableDb = false;
   browseRoot = null;
   publicUrl = null;
+  browserCors;
   pairTokens = new PairTokenStore();
   exchangeAttempts = /* @__PURE__ */ new Map();
   sessionStartAttempts = /* @__PURE__ */ new Map();
   sessionInputAttempts = /* @__PURE__ */ new Map();
   ptyGracePeriodMs;
   defaultSystemPrompt;
+  defaultPermissionMode;
   // Map of sessionId → grace timer; fires to kill PTY after WS disconnect
   ptyGraceTimers = /* @__PURE__ */ new Map();
   // Map of sessionId → set of subscribed WS clients
@@ -4975,6 +5157,7 @@ var StreamerServer = class {
     this.codexRoots = config.codexRoots ?? [join12(homedir5(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.defaultPermissionMode = config.defaultPermissionMode ?? loadDefaultPermissionMode() ?? "acceptEdits";
     this.cacheDir = config.cacheDir ?? loadCacheDir() ?? join12(homedir5(), ".threadbase", "cache");
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
@@ -5004,6 +5187,7 @@ var StreamerServer = class {
         this.log.warn(`Warning: ${result.error}`, { error: result.error });
       }
     }
+    this.browserCors = config.browserCors ?? loadBrowserCors();
     this.sessionStore = new SessionStore();
     this.wsHub = new WSHub();
     this.fileWatcher = new ConversationWatcher({
@@ -5158,6 +5342,7 @@ var StreamerServer = class {
       rotateApiKey: () => this.rotateApiKey(),
       publicUrl: this.publicUrl,
       browseRoot: this.browseRoot,
+      browserCors: this.browserCors,
       ptyManager: this.ptyManager,
       sessionStore: this.sessionStore,
       wsHub: this.wsHub,
@@ -5404,9 +5589,9 @@ var StreamerServer = class {
           );
           this.scannerPersistenceDisabled = true;
         }
-        const warmupScanner = this.newScanner();
-        this.allScanners.add(warmupScanner);
         const warmupStatCache = this.buildStatCache(null);
+        const warmupScanner = this.newScanner(warmupStatCache ? { persistent: false } : void 0);
+        this.allScanners.add(warmupScanner);
         const shouldEmitProgress = createScanProgressThrottle();
         const scanOpts = {
           ...this.scanProfiles ? { profiles: this.scanProfiles } : {},
@@ -5846,6 +6031,10 @@ var StreamerServer = class {
   }
   buildStatCache(previousScanner) {
     if (!this.cache) return void 0;
+    if (!previousScanner) {
+      const persisted = this.cache.getScannerStatCache();
+      return persisted.size > 0 ? persisted : void 0;
+    }
     const dbStats = this.cache.getFileStats();
     if (dbStats.size === 0) return void 0;
     const metaByPath = /* @__PURE__ */ new Map();
@@ -5875,9 +6064,9 @@ var StreamerServer = class {
   // this — its per-file refreshFile (in findConversationByUuid) already
   // reconciles the one conversation being requested, so paying a full-tree
   // rescan just because some OTHER file changed is the stall this avoids.
-  newScanner() {
+  newScanner(options) {
     return new ConversationScanner(
-      this.scannerPersistenceDisabled ? { persistent: false } : void 0
+      options ?? (this.scannerPersistenceDisabled ? { persistent: false } : void 0)
     );
   }
   async getScanner(skipStaleRescan = false) {
@@ -5896,7 +6085,7 @@ var StreamerServer = class {
     }
     this.scannerStale = false;
     const statCache = this.buildStatCache(this.scanner);
-    this.scanner = this.newScanner();
+    this.scanner = this.newScanner(statCache ? { persistent: false } : void 0);
     this.allScanners.add(this.scanner);
     this.scannerReady = this.scanner.scan({
       ...this.scanProfiles ? { profiles: this.scanProfiles } : {},
@@ -5919,9 +6108,8 @@ var StreamerServer = class {
     this.scannerReady = null;
     return this.getScanner();
   }
-  // refresh=1's scan: reuse the WARM persistent scanner (its index.db + cursors
-  // survive, so classify() still skips unchanged files) and re-run its scan
-  // with fullRescan:true — the escape hatch that bypasses the scanner's
+  // refresh=1's scan: reuse the WARM scanner and re-run its scan with
+  // fullRescan:true — the escape hatch that bypasses the scanner's
   // dir-mtime discovery gate, since an explicit user pull-to-refresh is exactly
   // the "don't trust the gate, check disk for real" signal. Unlike
   // getFreshScanner() this does NOT discard the warm scanner. scannerReady is
@@ -6309,7 +6497,8 @@ var StreamerServer = class {
       provider,
       projectPath,
       projectName: body.projectName,
-      branch: body.branch
+      branch: body.branch,
+      permissionMode: this.defaultPermissionMode
     });
     this.sessionStore.addManaged(session);
     void this.watchConversationFile(sessionId);
@@ -6633,7 +6822,8 @@ var StreamerServer = class {
     const session = await this.ptyManager.start(convId, {
       projectPath,
       projectName,
-      branch
+      branch,
+      permissionMode: this.defaultPermissionMode
     });
     this.sessionStore.addManaged(session);
     void this.watchConversationFile(session.id);
@@ -6703,10 +6893,35 @@ var StreamerServer = class {
         provider,
         projectPath: resolvedPath,
         projectName: body.projectName,
-        systemPrompt: systemPromptParts.join("\n")
+        systemPrompt: systemPromptParts.join("\n"),
+        permissionMode: this.defaultPermissionMode
       });
       this.sessionStore.addManaged(session);
-      json(res, 202, { id: session.id, status: "pending" });
+      const readyOrFailed = new Promise((resolve2) => {
+        const handler = (status) => {
+          if (status === "waiting_input" || status === "idle") {
+            this.sessionStatusBus.off(`status:${session.id}`, handler);
+            resolve2(status === "waiting_input" ? "ready" : "failed");
+          }
+        };
+        this.sessionStatusBus.on(`status:${session.id}`, handler);
+      });
+      const timeoutPromise = new Promise(
+        (resolve2) => setTimeout(() => resolve2("timeout"), START_READY_TIMEOUT_MS)
+      );
+      const outcome = await Promise.race([readyOrFailed, timeoutPromise]);
+      const current = this.sessionStore.get(session.id, this.ptyAttachedIds());
+      if (outcome === "ready" && current) {
+        json(res, 200, { session: current });
+      } else if (outcome === "failed" && current) {
+        json(res, 502, {
+          id: session.id,
+          status: "idle",
+          error: current.failureReason ?? "Session exited before becoming ready"
+        });
+      } else {
+        json(res, 202, { id: session.id, status: "pending" });
+      }
       if (provider === CODEX_CLI_PROVIDER) {
         this.watchForCodexRollout(session.id, resolvedPath);
       } else {