@threadbase-sh/streamer 1.29.0 → 1.29.2

package/dist/index.d.cts

@@ -321,6 +321,7 @@ interface ServerConfig {
     codexRoots?: string[];
     scannerPersistent?: boolean;
     ptyGracePeriodMs?: number;
+    wsAuthTimeoutMs?: number;
     cacheDir?: string;
     tailSize?: number;
     directoryScanDebounceMs?: number;
@@ -859,7 +860,7 @@ type ApiDeps = {
     handlePairExchange: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
     handleBrowse: (url: URL, res: ServerResponse) => Promise<void>;
     handleMkdir: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleWsOpen: (ws: WebSocket) => void;
+    handleWsOpen: (ws: WebSocket, preAuthed: boolean) => void;
     handleWsMessage: (ws: WebSocket, raw: unknown) => void;
     handleWsClose: (ws: WebSocket) => void;
     agentClient: AgentClient | null;
@@ -1015,6 +1016,9 @@ declare class StreamerServer {
     private sessionSubscribers;
     private clientIdToWs;
     private wsToClientId;
+    private wsAuthed;
+    private wsAuthPending;
+    private wsAuthTimeoutMs;
     private cache;
     private projectsRepo;
     private conversationsRepo;
@@ -1043,6 +1047,7 @@ declare class StreamerServer {
      * a full broadcast if no match exists (old clients, or no WS registered yet).
      */
     private broadcastOrUnicastSessionList;
+    private completeWsAuth;
     private addSessionSubscriber;
     private startGraceTimer;
     get port(): number;
@@ -1076,6 +1081,23 @@ declare class StreamerServer {
     private rescanForRefresh;
     private findJsonlPath;
     private readCwdFromJsonl;
+    /**
+     * Live Codex sessions keep `SessionResponse.conversationId === managed.id`
+     * (stable deep-link / PTY key) and store the rollout UUID separately as
+     * `boundConversationId`. REST history is indexed under the rollout UUID, so
+     * resolve the placeholder → bound id before looking up the scanner.
+     */
+    private resolveConversationLookupId;
+    /** File path for a live managed session (placeholder id or bound Codex id). */
+    private findLiveSessionFilePath;
+    /** True when a conversation UUID is the bound rollout of a live PTY session. */
+    private isBoundConversationLive;
+    /**
+     * Broadcast conversation JSONL lines to WS clients. Codex rollout lines are
+     * normalized to the Claude `type:user|assistant` shape mobile understands;
+     * Claude lines pass through unchanged so seq alignment stays intact.
+     */
+    private broadcastConversationLines;
     private findConversationByUuid;
     private isConversationSnapshotStale;
     private handleGetConversation;

package/dist/index.d.ts

@@ -321,6 +321,7 @@ interface ServerConfig {
     codexRoots?: string[];
     scannerPersistent?: boolean;
     ptyGracePeriodMs?: number;
+    wsAuthTimeoutMs?: number;
     cacheDir?: string;
     tailSize?: number;
     directoryScanDebounceMs?: number;
@@ -859,7 +860,7 @@ type ApiDeps = {
     handlePairExchange: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
     handleBrowse: (url: URL, res: ServerResponse) => Promise<void>;
     handleMkdir: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleWsOpen: (ws: WebSocket) => void;
+    handleWsOpen: (ws: WebSocket, preAuthed: boolean) => void;
     handleWsMessage: (ws: WebSocket, raw: unknown) => void;
     handleWsClose: (ws: WebSocket) => void;
     agentClient: AgentClient | null;
@@ -1015,6 +1016,9 @@ declare class StreamerServer {
     private sessionSubscribers;
     private clientIdToWs;
     private wsToClientId;
+    private wsAuthed;
+    private wsAuthPending;
+    private wsAuthTimeoutMs;
     private cache;
     private projectsRepo;
     private conversationsRepo;
@@ -1043,6 +1047,7 @@ declare class StreamerServer {
      * a full broadcast if no match exists (old clients, or no WS registered yet).
      */
     private broadcastOrUnicastSessionList;
+    private completeWsAuth;
     private addSessionSubscriber;
     private startGraceTimer;
     get port(): number;
@@ -1076,6 +1081,23 @@ declare class StreamerServer {
     private rescanForRefresh;
     private findJsonlPath;
     private readCwdFromJsonl;
+    /**
+     * Live Codex sessions keep `SessionResponse.conversationId === managed.id`
+     * (stable deep-link / PTY key) and store the rollout UUID separately as
+     * `boundConversationId`. REST history is indexed under the rollout UUID, so
+     * resolve the placeholder → bound id before looking up the scanner.
+     */
+    private resolveConversationLookupId;
+    /** File path for a live managed session (placeholder id or bound Codex id). */
+    private findLiveSessionFilePath;
+    /** True when a conversation UUID is the bound rollout of a live PTY session. */
+    private isBoundConversationLive;
+    /**
+     * Broadcast conversation JSONL lines to WS clients. Codex rollout lines are
+     * normalized to the Claude `type:user|assistant` shape mobile understands;
+     * Claude lines pass through unchanged so seq alignment stays intact.
+     */
+    private broadcastConversationLines;
     private findConversationByUuid;
     private isConversationSnapshotStale;
     private handleGetConversation;

package/dist/index.js

@@ -164,7 +164,7 @@ function verifySignature(rawBody, signature, secret) {
   }
 }
 function isWithinSkew(timestampHeader, skewSeconds) {
-  if (!timestampHeader) return true;
+  if (!timestampHeader) return false;
   const t = Number(timestampHeader);
   if (!Number.isFinite(t)) return false;
   const now = Math.floor(Date.now() / 1e3);
@@ -2551,7 +2551,7 @@ function isLocalRequest(remoteAddr) {
   const addr = remoteAddr ?? "";
   return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
 }
-var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/healthz"]);
+var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/healthz", "/ws"]);
 var PUBLIC_POST_PATHS = /* @__PURE__ */ new Set(["/api/pair/exchange", "/api/__update"]);
 var PUBLIC_POST_PREFIXES = ["/internal/sessions/"];
 var authMiddleware = (deps) => async (c, next) => {
@@ -3014,14 +3014,16 @@ var createWsRoutes = (deps, upgradeWebSocket) => {
   const app = new Hono10();
   app.get(
     "/ws",
-    upgradeWebSocket(() => {
+    upgradeWebSocket((c) => {
+      const key = c.req.query("key");
+      const preAuthed = typeof key === "string" && validateApiKey(key, deps.apiKey);
       let openWs = null;
       return {
         onOpen(_evt, ws) {
           const raw = ws.raw;
           if (!raw) return;
           openWs = raw;
-          deps.handleWsOpen(raw);
+          deps.handleWsOpen(raw, preAuthed);
         },
         onMessage(evt, _ws) {
           if (openWs) deps.handleWsMessage(openWs, evt.data);
@@ -4928,6 +4930,13 @@ function deriveProjectChatTitle(input) {
   return `Untitled \xB7 ${input.id.slice(0, 8)}`;
 }
 
+// src/services/questions/permissionAnswerKeys.ts
+var ANSWER_KEYS_ALLOWLIST = /^(?:\r|[yn]\r|\x03|\d+\r)$/;
+function sanitizeAnswerKeys(keys) {
+  if (keys === void 0) return void 0;
+  return ANSWER_KEYS_ALLOWLIST.test(keys) ? keys : void 0;
+}
+
 // src/services/questions/detectAskUserQuestion.ts
 function normalizeContent2(raw) {
   if (Array.isArray(raw)) return raw;
@@ -5292,6 +5301,89 @@ function sanitizeFilename(name) {
   return cleaned;
 }
 
+// src/utils/codexConversationLine.ts
+function extractCodexText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.map((item) => {
+    if (typeof item === "string") return item;
+    const block = item;
+    const t = block?.type;
+    if ((t === "input_text" || t === "output_text" || t === "text") && typeof block.text === "string") {
+      return block.text;
+    }
+    return "";
+  }).filter(Boolean).join("").trim();
+}
+function normalizeCodexLineToClaudeShape(line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (entry.type !== "response_item") return null;
+  const payload = entry.payload;
+  if (payload?.type !== "message") return null;
+  const role = payload.role;
+  if (role !== "user" && role !== "assistant") return null;
+  const text = extractCodexText(payload.content);
+  if (!text) return null;
+  if (role === "user" && isCodexInjectedContext(text)) return null;
+  const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+  const uuid = typeof payload.id === "string" && payload.id.length > 0 ? payload.id : `codex-${role}-${timestamp}-${hashPrefix(text)}`;
+  return JSON.stringify({
+    type: role,
+    uuid,
+    timestamp,
+    message: {
+      role,
+      content: [{ type: "text", text }]
+    }
+  });
+}
+function isCodexRolloutLine(line) {
+  try {
+    const entry = JSON.parse(line);
+    return entry.type === "response_item" || entry.type === "event_msg" || entry.type === "session_meta" || entry.type === "turn_context";
+  } catch {
+    return false;
+  }
+}
+function toClientConversationLines(lines) {
+  if (lines.length === 0) return lines;
+  const codex = lines.some(isCodexRolloutLine);
+  if (!codex) return lines;
+  const out = [];
+  for (const line of lines) {
+    const normalized = normalizeCodexLineToClaudeShape(line);
+    if (normalized) out.push(normalized);
+  }
+  return out;
+}
+function isCodexInjectedContext(text) {
+  if (text.startsWith("# AGENTS.md") || text.includes("<INSTRUCTIONS>")) return true;
+  if (text.startsWith("<permissions instructions>") || text.includes("Filesystem sandboxing defines")) {
+    return true;
+  }
+  if (text.includes("limit the options to at most 3")) return true;
+  if (text.includes("You are working within the project boundary:")) return true;
+  if (text.includes(
+    "Do not read, write, or execute commands that access files or directories outside this boundary"
+  )) {
+    return true;
+  }
+  return false;
+}
+function hashPrefix(text) {
+  let h = 0;
+  const sample = text.slice(0, 64);
+  for (let i = 0; i < sample.length; i++) {
+    h = h * 31 + sample.charCodeAt(i) | 0;
+  }
+  return Math.abs(h).toString(36);
+}
+
 // src/utils/conversationEtag.ts
 import { createHash as createHash2 } from "crypto";
 function computeConversationEtag({
@@ -5449,6 +5541,8 @@ 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 DEFAULT_WS_AUTH_TIMEOUT_MS = 5e3;
+var WS_CLOSE_UNAUTHORIZED = 4401;
 var REFRESH_TTL_MS = 2e3;
 var START_READY_TIMEOUT_MS = 15e3;
 function parseIncludeAgentsEnv(raw) {
@@ -5539,6 +5633,14 @@ var StreamerServer = class {
   clientIdToWs = /* @__PURE__ */ new Map();
   // Reverse map for cleanup on close
   wsToClientId = /* @__PURE__ */ new Map();
+  // M1 — WS auth. Sockets that have authenticated (via ?key= at upgrade OR a
+  // { type: "auth", token } first message). Only authed sockets are added to
+  // the hub and receive broadcasts.
+  // Plan: https://github.com/RonenMars/threadbase-streamer/blob/a251353bfa417bd48ce3f15086bc336a2c622629/docs/plans/2026-06-24-security-hardening.md#L40
+  wsAuthed = /* @__PURE__ */ new Set();
+  // Keyless sockets awaiting their first-message auth handshake → close timer.
+  wsAuthPending = /* @__PURE__ */ new Map();
+  wsAuthTimeoutMs;
   cache = null;
   projectsRepo = null;
   conversationsRepo = null;
@@ -5578,6 +5680,7 @@ var StreamerServer = class {
     this.scanProfiles = config.scanProfiles;
     this.codexRoots = config.codexRoots ?? [join12(homedir5(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
+    this.wsAuthTimeoutMs = config.wsAuthTimeoutMs ?? DEFAULT_WS_AUTH_TIMEOUT_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.defaultPermissionMode = config.defaultPermissionMode ?? loadDefaultPermissionMode() ?? "acceptEdits";
     this.cacheDir = config.cacheDir ?? loadCacheDir() ?? join12(homedir5(), ".threadbase", "cache");
@@ -5676,15 +5779,7 @@ var StreamerServer = class {
               if (broadcast) this.wsHub.broadcast(m);
             }
             const seqs = this.pendingLineSeqs.get(filePath);
-            this.wsHub.broadcast({
-              type: "conversation_events",
-              sessionId,
-              lines,
-              ...seqs && seqs.length === lines.length ? { seqs } : {}
-            });
-            for (const line of lines) {
-              this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
-            }
+            this.broadcastConversationLines(sessionId, lines, seqs);
             break;
           }
         }
@@ -5843,17 +5938,39 @@ var StreamerServer = class {
       handlePairExchange: (req, res) => this.handlePairExchange(req, res),
       handleBrowse: (url, res) => this.handleBrowse(url, res),
       handleMkdir: (req, res) => this.handleMkdir(req, res),
-      handleWsOpen: (ws) => {
-        this.wsHub.addClient(ws);
-        const sessions = this.sessionStore.list(this.ptyAttachedIds());
-        ws.send(JSON.stringify({ type: "session_list", sessions }));
-        if (this.cacheReady) {
-          ws.send(JSON.stringify({ type: "cache_ready" }));
+      handleWsOpen: (ws, preAuthed) => {
+        if (preAuthed) {
+          this.completeWsAuth(ws);
+          return;
         }
+        const timer = setTimeout(() => {
+          this.wsAuthPending.delete(ws);
+          try {
+            ws.close(WS_CLOSE_UNAUTHORIZED, "auth timeout");
+          } catch {
+          }
+        }, this.wsAuthTimeoutMs);
+        this.wsAuthPending.set(ws, timer);
       },
       handleWsMessage: async (ws, raw) => {
         try {
           const msg = JSON.parse(String(raw));
+          if (!this.wsAuthed.has(ws)) {
+            if (msg.type === "auth" && typeof msg.token === "string") {
+              const t = this.wsAuthPending.get(ws);
+              if (t) clearTimeout(t);
+              this.wsAuthPending.delete(ws);
+              if (validateApiKey(msg.token, this.apiKey)) {
+                this.completeWsAuth(ws);
+              } else {
+                try {
+                  ws.close(WS_CLOSE_UNAUTHORIZED, "unauthorized");
+                } catch {
+                }
+              }
+            }
+            return;
+          }
           if (msg.type === "register" && typeof msg.clientId === "string") {
             const oldClientId = this.wsToClientId.get(ws);
             if (oldClientId) this.clientIdToWs.delete(oldClientId);
@@ -5868,12 +5985,20 @@ var StreamerServer = class {
             }
           }
           if (msg.type === "hold_session" && typeof msg.sessionId === "string") {
-            this.startGraceTimer(msg.sessionId, 0);
+            if (this.sessionSubscribers.get(msg.sessionId)?.has(ws)) {
+              this.startGraceTimer(msg.sessionId, 0);
+            }
           }
         } catch {
         }
       },
       handleWsClose: (ws) => {
+        const pendingTimer = this.wsAuthPending.get(ws);
+        if (pendingTimer) {
+          clearTimeout(pendingTimer);
+          this.wsAuthPending.delete(ws);
+        }
+        this.wsAuthed.delete(ws);
         const clientId = this.wsToClientId.get(ws);
         if (clientId) {
           this.clientIdToWs.delete(clientId);
@@ -5943,6 +6068,20 @@ var StreamerServer = class {
       this.wsHub.broadcast(payload);
     }
   }
+  // M1: finalize a WebSocket auth (via ?key= at upgrade or a first-message
+  // handshake) — register it with the hub and send the initial snapshot. Only
+  // authed sockets reach this, so no unauthenticated client ever receives a
+  // broadcast.
+  // Plan: https://github.com/RonenMars/threadbase-streamer/blob/a251353bfa417bd48ce3f15086bc336a2c622629/docs/plans/2026-06-24-security-hardening.md#L40
+  completeWsAuth(ws) {
+    this.wsAuthed.add(ws);
+    this.wsHub.addClient(ws);
+    const sessions = this.sessionStore.list(this.ptyAttachedIds());
+    ws.send(JSON.stringify({ type: "session_list", sessions }));
+    if (this.cacheReady) {
+      ws.send(JSON.stringify({ type: "cache_ready" }));
+    }
+  }
   addSessionSubscriber(sessionId, ws) {
     let subs = this.sessionSubscribers.get(sessionId);
     if (!subs) {
@@ -6229,6 +6368,9 @@ var StreamerServer = class {
     this.ptyManager.dispose();
     this.fileWatcher.dispose();
     this.wsHub.dispose();
+    for (const timer of this.wsAuthPending.values()) clearTimeout(timer);
+    this.wsAuthPending.clear();
+    this.wsAuthed.clear();
     this.pairTokens.dispose();
     if (this.dbPool) {
       await this.dbPool.end();
@@ -6665,11 +6807,62 @@ var StreamerServer = class {
       rl.on("error", () => resolve2(null));
     });
   }
+  /**
+   * Live Codex sessions keep `SessionResponse.conversationId === managed.id`
+   * (stable deep-link / PTY key) and store the rollout UUID separately as
+   * `boundConversationId`. REST history is indexed under the rollout UUID, so
+   * resolve the placeholder → bound id before looking up the scanner.
+   */
+  resolveConversationLookupId(uuid) {
+    const managed = this.sessionStore.getManaged(uuid);
+    if (managed?.boundConversationId) return managed.boundConversationId;
+    return uuid;
+  }
+  /** File path for a live managed session (placeholder id or bound Codex id). */
+  findLiveSessionFilePath(uuid) {
+    const direct = this.sessionFileMap.get(uuid);
+    if (direct) return direct;
+    for (const s of this.sessionStore.listManaged()) {
+      if (s.boundConversationId === uuid) {
+        return this.sessionFileMap.get(s.id) ?? null;
+      }
+    }
+    return null;
+  }
+  /** True when a conversation UUID is the bound rollout of a live PTY session. */
+  isBoundConversationLive(boundId) {
+    for (const s of this.sessionStore.listManaged()) {
+      if (s.boundConversationId === boundId && this.ptyManager.hasSession(s.id)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Broadcast conversation JSONL lines to WS clients. Codex rollout lines are
+   * normalized to the Claude `type:user|assistant` shape mobile understands;
+   * Claude lines pass through unchanged so seq alignment stays intact.
+   */
+  broadcastConversationLines(sessionId, lines, seqs) {
+    const clientLines = toClientConversationLines(lines);
+    if (clientLines.length === 0) return;
+    const seqsOk = !!seqs && seqs.length === lines.length && clientLines.length === lines.length;
+    this.wsHub.broadcast({
+      type: "conversation_events",
+      sessionId,
+      lines: clientLines,
+      ...seqsOk ? { seqs } : {}
+    });
+    for (const line of clientLines) {
+      this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
+    }
+  }
   async findConversationByUuid(uuid) {
+    const lookupId = this.resolveConversationLookupId(uuid);
     if (!this.scannerReady && !this.scanProfiles) {
-      const filePath2 = this.findJsonlPath(uuid);
+      const filePath2 = this.findJsonlPath(lookupId) ?? this.findLiveSessionFilePath(uuid) ?? this.findLiveSessionFilePath(lookupId);
       if (filePath2) {
-        const account = this.cache?.getMetaById(uuid)?.account ?? void 0;
+        const account = this.cache?.getMetaById(lookupId)?.account ?? void 0;
         const coldScanner = this.scanner ?? this.newScanner();
         const page = await coldScanner.parseSingleFilePage(filePath2, account, {
           limit: Number.MAX_SAFE_INTEGER
@@ -6679,9 +6872,27 @@ var StreamerServer = class {
       return null;
     }
     const scanner = await this.getScanner(true);
-    const fromIndex = await scanner.getConversation(uuid);
+    const fromIndex = await scanner.getConversation(lookupId);
     if (fromIndex) {
-      if (this.ptyManager.hasSession(uuid)) {
+      if (this.ptyManager.hasSession(uuid) || this.ptyManager.hasSession(lookupId) || this.isBoundConversationLive(lookupId)) {
+        const livePath = this.findLiveSessionFilePath(uuid) ?? this.findLiveSessionFilePath(lookupId) ?? fromIndex.filePath ?? null;
+        const isCodexLive = this.isBoundConversationLive(lookupId) || this.sessionStore.getManaged(uuid)?.provider === CODEX_CLI_PROVIDER;
+        if (isCodexLive && livePath) {
+          try {
+            const account = this.cache?.getMetaById(lookupId)?.account ?? fromIndex.account ?? void 0;
+            const page = await scanner.parseSingleFilePage(livePath, account, {
+              limit: Number.MAX_SAFE_INTEGER
+            });
+            if (page?.conversation) return page.conversation;
+          } catch (err) {
+            this.log.warn("codex.live_reparse_failed", {
+              event: "codex.live_reparse_failed",
+              conversationId: lookupId,
+              filePath: livePath,
+              err
+            });
+          }
+        }
         return fromIndex;
       }
       if (fromIndex.filePath && this.isConversationSnapshotStale(fromIndex)) {
@@ -6701,12 +6912,12 @@ var StreamerServer = class {
       return fromIndex;
     }
     if (this.scanProfiles) return null;
-    const filePath = this.findJsonlPath(uuid);
+    const filePath = this.findJsonlPath(lookupId) ?? this.findLiveSessionFilePath(uuid) ?? this.findLiveSessionFilePath(lookupId);
     if (!filePath) return null;
     this.scanner = null;
     this.scannerReady = null;
     const freshScanner = await this.getScanner();
-    return freshScanner.getConversation(uuid);
+    return freshScanner.getConversation(lookupId);
   }
   // True when the JSONL on disk is meaningfully newer than the scanned
   // snapshot's last-activity timestamp — i.e. the file grew after the scan.
@@ -6787,7 +6998,9 @@ var StreamerServer = class {
       res.end();
       return;
     }
-    const filtered = conversation.messages;
+    const filtered = conversation.messages.filter(
+      (m) => !(m.role === "user" && typeof m.text === "string" && isCodexInjectedContext(m.text))
+    );
     const total = filtered.length;
     const hasAnchor = url.searchParams.has("anchor_index");
     const hasAfter = url.searchParams.has("after_index");
@@ -6845,8 +7058,7 @@ var StreamerServer = class {
           })
         );
       }
-      const pagedScanner = !indexWindow && this.scannerReady ? await this.getScanner(true) : null;
-      const page = indexWindow ?? (scanLimit > 0 && pagedScanner && typeof pagedScanner.getConversationPage === "function" ? await pagedScanner.getConversationPage(id, { beforeIndex, limit: scanLimit }) : null);
+      const page = indexWindow;
       if (indexWindow) indexTotal = indexWindow.total;
       const start = page?.fromIndex ?? windowStart;
       slice = page?.messages ?? filtered.slice(start, beforeIndex);
@@ -7285,12 +7497,16 @@ var StreamerServer = class {
       return;
     }
     this.pendingPermission.set(sessionId, gate);
+    const safeOptions = gate.options.map((o) => {
+      const answerKeys = sanitizeAnswerKeys(o.answerKeys);
+      return answerKeys === void 0 ? { index: o.index, label: o.label } : { ...o, answerKeys };
+    });
     this.wsHub.broadcast({
       type: "permission",
       sessionId,
       ...gate.prompt ? { prompt: gate.prompt } : {},
       ...gate.detail ? { detail: gate.detail } : {},
-      options: gate.options,
+      options: safeOptions,
       ...gate.cursor !== void 0 ? { cursor: gate.cursor } : {}
     });
   }
@@ -7654,10 +7870,7 @@ var StreamerServer = class {
       try {
         const existing = readFileSync6(resolvedFilePath, "utf8").split("\n").filter(Boolean);
         if (existing.length > 0) {
-          this.wsHub.broadcast({ type: "conversation_events", sessionId, lines: existing });
-          for (const line of existing) {
-            this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
-          }
+          this.broadcastConversationLines(sessionId, existing);
         }
       } catch {
       }
@@ -7758,10 +7971,7 @@ var StreamerServer = class {
           try {
             const existing = readFileSync6(candidatePath, "utf8").split("\n").filter(Boolean);
             if (existing.length > 0) {
-              this.wsHub.broadcast({ type: "conversation_events", sessionId, lines: existing });
-              for (const line of existing) {
-                this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
-              }
+              this.broadcastConversationLines(sessionId, existing);
             }
           } catch {
           }