claude-code-best 1.1.0 → 1.2.1

package/dist/chunk-fbest4vx.js

@@ -0,0 +1,109 @@
+// @bun
+import {
+  Select,
+  init_CustomSelect
+} from "./chunk-gs5eeqmc.js";
+import {
+  init_settings1 as init_settings,
+  updateSettingsForSource
+} from "./chunk-a2aj2mtb.js";
+import {
+  Dialog,
+  Link,
+  ThemedBox_default,
+  ThemedText,
+  init_src
+} from "./chunk-rvkvehat.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/AutoModeOptInDialog.tsx
+init_analytics();
+init_src();
+init_settings();
+init_CustomSelect();
+var import_react = __toESM(require_react(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+var AUTO_MODE_DESCRIPTION = "Auto mode lets Claude handle permission prompts automatically \u2014 Claude checks each tool call for risky actions and prompt injection before executing. Actions Claude identifies as safe are executed, while actions Claude identifies as risky are blocked and Claude may try a different approach. Ideal for long-running tasks. Sessions are slightly more expensive. Claude can make mistakes that allow harmful commands to run, it's recommended to only use in isolated environments. Shift+Tab to change mode.";
+function AutoModeOptInDialog({
+  onAccept,
+  onDecline,
+  declineExits
+}) {
+  import_react.default.useEffect(() => {
+    logEvent("tengu_auto_mode_opt_in_dialog_shown", {});
+  }, []);
+  function onChange(value) {
+    switch (value) {
+      case "accept": {
+        logEvent("tengu_auto_mode_opt_in_dialog_accept", {});
+        updateSettingsForSource("userSettings", {
+          skipAutoPermissionPrompt: true
+        });
+        onAccept();
+        break;
+      }
+      case "accept-default": {
+        logEvent("tengu_auto_mode_opt_in_dialog_accept_default", {});
+        updateSettingsForSource("userSettings", {
+          skipAutoPermissionPrompt: true,
+          permissions: { defaultMode: "auto" }
+        });
+        onAccept();
+        break;
+      }
+      case "decline": {
+        logEvent("tengu_auto_mode_opt_in_dialog_decline", {});
+        onDecline();
+        break;
+      }
+    }
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+    title: "Enable auto mode?",
+    color: "warning",
+    onCancel: onDecline,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            children: AUTO_MODE_DESCRIPTION
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Link, {
+            url: "https://code.claude.com/docs/en/security"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+        options: [
+          ...[
+            {
+              label: "Yes, and make it my default mode",
+              value: "accept-default"
+            }
+          ],
+          { label: "Yes, enable auto mode", value: "accept" },
+          {
+            label: declineExits ? "No, exit" : "No, go back",
+            value: "decline"
+          }
+        ],
+        onChange: (value) => onChange(value),
+        onCancel: onDecline
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+export { AUTO_MODE_DESCRIPTION, AutoModeOptInDialog };

package/dist/{chunk-v0wa5ref.js → chunk-fdtcb8qr.js}

@@ -1,4 +1,7 @@
 // @bun
+import {
+  decodeJwtExpiry
+} from "./chunk-71sf47by.js";
 import {
   getSessionIngressAuthHeaders,
   getSessionIngressAuthToken,
@@ -6,174 +9,34 @@ import {
   init_sessionIngressAuth,
   registerSessionActivityCallback,
   unregisterSessionActivityCallback
-} from "./chunk-ye18m1zb.js";
+} from "./chunk-rqvqqrpg.js";
 import {
   getClaudeCodeUserAgent,
   init_userAgent
-} from "./chunk-mvss16tj.js";
+} from "./chunk-a2aj2mtb.js";
 import {
   createAxiosInstance,
   init_proxy
-} from "./chunk-5hva0tsg.js";
+} from "./chunk-p2yv7m0g.js";
 import {
   init_sleep,
   sleep
 } from "./chunk-8g5pe1gr.js";
-import {
-  init_analytics,
-  logEvent
-} from "./chunk-h0rbjg6x.js";
 import {
   init_diagLogs,
   logForDiagnosticsNoPII
-} from "./chunk-dr4qq42x.js";
+} from "./chunk-rgbbtszq.js";
 import {
-  errorMessage,
-  getErrnoCode,
   init_debug,
-  init_errors,
   init_slowOperations,
-  jsonParse,
   jsonStringify,
   logForDebugging
-} from "./chunk-nxsh6de2.js";
+} from "./chunk-hcgkak1j.js";
 import {
-  axios_default,
-  init_axios
-} from "./chunk-xszk7n10.js";
-
-// src/bridge/jwtUtils.ts
-init_analytics();
-init_debug();
-init_diagLogs();
-init_errors();
-init_slowOperations();
-function formatDuration(ms) {
-  if (ms < 60000)
-    return `${Math.round(ms / 1000)}s`;
-  const m = Math.floor(ms / 60000);
-  const s = Math.round(ms % 60000 / 1000);
-  return s > 0 ? `${m}m ${s}s` : `${m}m`;
-}
-function decodeJwtPayload(token) {
-  const jwt = token.startsWith("sk-ant-si-") ? token.slice("sk-ant-si-".length) : token;
-  const parts = jwt.split(".");
-  if (parts.length !== 3 || !parts[1])
-    return null;
-  try {
-    return jsonParse(Buffer.from(parts[1], "base64url").toString("utf8"));
-  } catch {
-    return null;
-  }
-}
-function decodeJwtExpiry(token) {
-  const payload = decodeJwtPayload(token);
-  if (payload !== null && typeof payload === "object" && "exp" in payload && typeof payload.exp === "number") {
-    return payload.exp;
-  }
-  return null;
-}
-var TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000;
-var FALLBACK_REFRESH_INTERVAL_MS = 30 * 60 * 1000;
-var MAX_REFRESH_FAILURES = 3;
-var REFRESH_RETRY_DELAY_MS = 60000;
-function createTokenRefreshScheduler({
-  getAccessToken,
-  onRefresh,
-  label,
-  refreshBufferMs = TOKEN_REFRESH_BUFFER_MS
-}) {
-  const timers = new Map;
-  const failureCounts = new Map;
-  const generations = new Map;
-  function nextGeneration(sessionId) {
-    const gen = (generations.get(sessionId) ?? 0) + 1;
-    generations.set(sessionId, gen);
-    return gen;
-  }
-  function schedule(sessionId, token) {
-    const expiry = decodeJwtExpiry(token);
-    if (!expiry) {
-      logForDebugging(`[${label}:token] Could not decode JWT expiry for sessionId=${sessionId}, token prefix=${token.slice(0, 15)}\u2026, keeping existing timer`);
-      return;
-    }
-    const existing = timers.get(sessionId);
-    if (existing) {
-      clearTimeout(existing);
-    }
-    const gen = nextGeneration(sessionId);
-    const expiryDate = new Date(expiry * 1000).toISOString();
-    const delayMs = expiry * 1000 - Date.now() - refreshBufferMs;
-    if (delayMs <= 0) {
-      logForDebugging(`[${label}:token] Token for sessionId=${sessionId} expires=${expiryDate} (past or within buffer), refreshing immediately`);
-      doRefresh(sessionId, gen);
-      return;
-    }
-    logForDebugging(`[${label}:token] Scheduled token refresh for sessionId=${sessionId} in ${formatDuration(delayMs)} (expires=${expiryDate}, buffer=${refreshBufferMs / 1000}s)`);
-    const timer = setTimeout(doRefresh, delayMs, sessionId, gen);
-    timers.set(sessionId, timer);
-  }
-  function scheduleFromExpiresIn(sessionId, expiresInSeconds) {
-    const existing = timers.get(sessionId);
-    if (existing)
-      clearTimeout(existing);
-    const gen = nextGeneration(sessionId);
-    const delayMs = Math.max(expiresInSeconds * 1000 - refreshBufferMs, 30000);
-    logForDebugging(`[${label}:token] Scheduled token refresh for sessionId=${sessionId} in ${formatDuration(delayMs)} (expires_in=${expiresInSeconds}s, buffer=${refreshBufferMs / 1000}s)`);
-    const timer = setTimeout(doRefresh, delayMs, sessionId, gen);
-    timers.set(sessionId, timer);
-  }
-  async function doRefresh(sessionId, gen) {
-    let oauthToken;
-    try {
-      oauthToken = await getAccessToken();
-    } catch (err) {
-      logForDebugging(`[${label}:token] getAccessToken threw for sessionId=${sessionId}: ${errorMessage(err)}`, { level: "error" });
-    }
-    if (generations.get(sessionId) !== gen) {
-      logForDebugging(`[${label}:token] doRefresh for sessionId=${sessionId} stale (gen ${gen} vs ${generations.get(sessionId)}), skipping`);
-      return;
-    }
-    if (!oauthToken) {
-      const failures = (failureCounts.get(sessionId) ?? 0) + 1;
-      failureCounts.set(sessionId, failures);
-      logForDebugging(`[${label}:token] No OAuth token available for refresh, sessionId=${sessionId} (failure ${failures}/${MAX_REFRESH_FAILURES})`, { level: "error" });
-      logForDiagnosticsNoPII("error", "bridge_token_refresh_no_oauth");
-      if (failures < MAX_REFRESH_FAILURES) {
-        const retryTimer = setTimeout(doRefresh, REFRESH_RETRY_DELAY_MS, sessionId, gen);
-        timers.set(sessionId, retryTimer);
-      }
-      return;
-    }
-    failureCounts.delete(sessionId);
-    logForDebugging(`[${label}:token] Refreshing token for sessionId=${sessionId}: new token prefix=${oauthToken.slice(0, 15)}\u2026`);
-    logEvent("tengu_bridge_token_refreshed", {});
-    onRefresh(sessionId, oauthToken);
-    const timer = setTimeout(doRefresh, FALLBACK_REFRESH_INTERVAL_MS, sessionId, gen);
-    timers.set(sessionId, timer);
-    logForDebugging(`[${label}:token] Scheduled follow-up refresh for sessionId=${sessionId} in ${formatDuration(FALLBACK_REFRESH_INTERVAL_MS)}`);
-  }
-  function cancel(sessionId) {
-    nextGeneration(sessionId);
-    const timer = timers.get(sessionId);
-    if (timer) {
-      clearTimeout(timer);
-      timers.delete(sessionId);
-    }
-    failureCounts.delete(sessionId);
-  }
-  function cancelAll() {
-    for (const sessionId of generations.keys()) {
-      nextGeneration(sessionId);
-    }
-    for (const timer of timers.values()) {
-      clearTimeout(timer);
-    }
-    timers.clear();
-    failureCounts.clear();
-  }
-  return { schedule, scheduleFromExpiresIn, cancel, cancelAll };
-}
+  errorMessage,
+  getErrnoCode,
+  init_errors
+} from "./chunk-z6e5jp2w.js";
 
 // src/cli/transports/ccrClient.ts
 import { randomUUID } from "crypto";
@@ -916,409 +779,4 @@ class CCRClient {
   }
 }
 
-// src/cli/transports/SSETransport.ts
-init_axios();
-init_debug();
-init_diagLogs();
-init_errors();
-init_sessionIngressAuth();
-init_sleep();
-init_slowOperations();
-init_userAgent();
-var RECONNECT_BASE_DELAY_MS = 1000;
-var RECONNECT_MAX_DELAY_MS = 30000;
-var RECONNECT_GIVE_UP_MS = 600000;
-var LIVENESS_TIMEOUT_MS = 45000;
-var PERMANENT_HTTP_CODES = new Set([401, 403, 404]);
-var POST_MAX_RETRIES = 10;
-var POST_BASE_DELAY_MS = 500;
-var POST_MAX_DELAY_MS = 8000;
-var STREAM_DECODE_OPTS = { stream: true };
-function alwaysValidStatus2() {
-  return true;
-}
-function parseSSEFrames(buffer) {
-  const frames = [];
-  let pos = 0;
-  let idx;
-  while ((idx = buffer.indexOf(`
-
-`, pos)) !== -1) {
-    const rawFrame = buffer.slice(pos, idx);
-    pos = idx + 2;
-    if (!rawFrame.trim())
-      continue;
-    const frame = {};
-    let isComment = false;
-    for (const line of rawFrame.split(`
-`)) {
-      if (line.startsWith(":")) {
-        isComment = true;
-        continue;
-      }
-      const colonIdx = line.indexOf(":");
-      if (colonIdx === -1)
-        continue;
-      const field = line.slice(0, colonIdx);
-      const value = line[colonIdx + 1] === " " ? line.slice(colonIdx + 2) : line.slice(colonIdx + 1);
-      switch (field) {
-        case "event":
-          frame.event = value;
-          break;
-        case "id":
-          frame.id = value;
-          break;
-        case "data":
-          frame.data = frame.data ? frame.data + `
-` + value : value;
-          break;
-      }
-    }
-    if (frame.data || isComment) {
-      frames.push(frame);
-    }
-  }
-  return { frames, remaining: buffer.slice(pos) };
-}
-
-class SSETransport {
-  url;
-  state = "idle";
-  onData;
-  onCloseCallback;
-  onEventCallback;
-  headers;
-  sessionId;
-  refreshHeaders;
-  getAuthHeaders;
-  abortController = null;
-  lastSequenceNum = 0;
-  seenSequenceNums = new Set;
-  reconnectAttempts = 0;
-  reconnectStartTime = null;
-  reconnectTimer = null;
-  livenessTimer = null;
-  postUrl;
-  constructor(url, headers = {}, sessionId, refreshHeaders, initialSequenceNum, getAuthHeaders) {
-    this.url = url;
-    this.headers = headers;
-    this.sessionId = sessionId;
-    this.refreshHeaders = refreshHeaders;
-    this.getAuthHeaders = getAuthHeaders ?? getSessionIngressAuthHeaders;
-    this.postUrl = convertSSEUrlToPostUrl(url);
-    if (initialSequenceNum !== undefined && initialSequenceNum > 0) {
-      this.lastSequenceNum = initialSequenceNum;
-    }
-    logForDebugging(`SSETransport: SSE URL = ${url.href}`);
-    logForDebugging(`SSETransport: POST URL = ${this.postUrl}`);
-    logForDiagnosticsNoPII("info", "cli_sse_transport_initialized");
-  }
-  getLastSequenceNum() {
-    return this.lastSequenceNum;
-  }
-  async connect() {
-    if (this.state !== "idle" && this.state !== "reconnecting") {
-      logForDebugging(`SSETransport: Cannot connect, current state is ${this.state}`, { level: "error" });
-      logForDiagnosticsNoPII("error", "cli_sse_connect_failed");
-      return;
-    }
-    this.state = "reconnecting";
-    const connectStartTime = Date.now();
-    const sseUrl = new URL(this.url.href);
-    if (this.lastSequenceNum > 0) {
-      sseUrl.searchParams.set("from_sequence_num", String(this.lastSequenceNum));
-    }
-    const authHeaders = this.getAuthHeaders();
-    const headers = {
-      ...this.headers,
-      ...authHeaders,
-      Accept: "text/event-stream",
-      "anthropic-version": "2023-06-01",
-      "User-Agent": getClaudeCodeUserAgent()
-    };
-    if (authHeaders["Cookie"]) {
-      delete headers["Authorization"];
-    }
-    if (this.lastSequenceNum > 0) {
-      headers["Last-Event-ID"] = String(this.lastSequenceNum);
-    }
-    logForDebugging(`SSETransport: Opening ${sseUrl.href}`);
-    logForDiagnosticsNoPII("info", "cli_sse_connect_opening");
-    this.abortController = new AbortController;
-    try {
-      const response = await fetch(sseUrl.href, {
-        headers,
-        signal: this.abortController.signal
-      });
-      if (!response.ok) {
-        const isPermanent = PERMANENT_HTTP_CODES.has(response.status);
-        logForDebugging(`SSETransport: HTTP ${response.status}${isPermanent ? " (permanent)" : ""}`, { level: "error" });
-        logForDiagnosticsNoPII("error", "cli_sse_connect_http_error", {
-          status: response.status
-        });
-        if (isPermanent) {
-          this.state = "closed";
-          this.onCloseCallback?.(response.status);
-          return;
-        }
-        this.handleConnectionError();
-        return;
-      }
-      if (!response.body) {
-        logForDebugging("SSETransport: No response body");
-        this.handleConnectionError();
-        return;
-      }
-      const connectDuration = Date.now() - connectStartTime;
-      logForDebugging("SSETransport: Connected");
-      logForDiagnosticsNoPII("info", "cli_sse_connect_connected", {
-        duration_ms: connectDuration
-      });
-      this.state = "connected";
-      this.reconnectAttempts = 0;
-      this.reconnectStartTime = null;
-      this.resetLivenessTimer();
-      await this.readStream(response.body);
-    } catch (error) {
-      if (this.abortController?.signal.aborted) {
-        return;
-      }
-      logForDebugging(`SSETransport: Connection error: ${errorMessage(error)}`, { level: "error" });
-      logForDiagnosticsNoPII("error", "cli_sse_connect_error");
-      this.handleConnectionError();
-    }
-  }
-  async readStream(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder;
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        buffer += decoder.decode(value, STREAM_DECODE_OPTS);
-        const { frames, remaining } = parseSSEFrames(buffer);
-        buffer = remaining;
-        for (const frame of frames) {
-          this.resetLivenessTimer();
-          if (frame.id) {
-            const seqNum = parseInt(frame.id, 10);
-            if (!isNaN(seqNum)) {
-              if (this.seenSequenceNums.has(seqNum)) {
-                logForDebugging(`SSETransport: DUPLICATE frame seq=${seqNum} (lastSequenceNum=${this.lastSequenceNum}, seenCount=${this.seenSequenceNums.size})`, { level: "warn" });
-                logForDiagnosticsNoPII("warn", "cli_sse_duplicate_sequence");
-              } else {
-                this.seenSequenceNums.add(seqNum);
-                if (this.seenSequenceNums.size > 1000) {
-                  const threshold = this.lastSequenceNum - 200;
-                  for (const s of this.seenSequenceNums) {
-                    if (s < threshold) {
-                      this.seenSequenceNums.delete(s);
-                    }
-                  }
-                }
-              }
-              if (seqNum > this.lastSequenceNum) {
-                this.lastSequenceNum = seqNum;
-              }
-            }
-          }
-          if (frame.event && frame.data) {
-            this.handleSSEFrame(frame.event, frame.data);
-          } else if (frame.data) {
-            logForDebugging("SSETransport: Frame has data: but no event: field \u2014 dropped", { level: "warn" });
-            logForDiagnosticsNoPII("warn", "cli_sse_frame_missing_event_field");
-          }
-        }
-      }
-    } catch (error) {
-      if (this.abortController?.signal.aborted)
-        return;
-      logForDebugging(`SSETransport: Stream read error: ${errorMessage(error)}`, { level: "error" });
-      logForDiagnosticsNoPII("error", "cli_sse_stream_read_error");
-    } finally {
-      reader.releaseLock();
-    }
-    if (this.state !== "closing" && this.state !== "closed") {
-      logForDebugging("SSETransport: Stream ended, reconnecting");
-      this.handleConnectionError();
-    }
-  }
-  handleSSEFrame(eventType, data) {
-    if (eventType !== "client_event") {
-      logForDebugging(`SSETransport: Unexpected SSE event type '${eventType}' on worker stream`, { level: "warn" });
-      logForDiagnosticsNoPII("warn", "cli_sse_unexpected_event_type", {
-        event_type: eventType
-      });
-      return;
-    }
-    let ev;
-    try {
-      ev = jsonParse(data);
-    } catch (error) {
-      logForDebugging(`SSETransport: Failed to parse client_event data: ${errorMessage(error)}`, { level: "error" });
-      return;
-    }
-    const payload = ev.payload;
-    if (payload && typeof payload === "object" && "type" in payload) {
-      const sessionLabel = this.sessionId ? ` session=${this.sessionId}` : "";
-      logForDebugging(`SSETransport: Event seq=${ev.sequence_num} event_id=${ev.event_id} event_type=${ev.event_type} payload_type=${String(payload.type)}${sessionLabel}`);
-      logForDiagnosticsNoPII("info", "cli_sse_message_received");
-      this.onData?.(jsonStringify(payload) + `
-`);
-    } else {
-      logForDebugging(`SSETransport: Ignoring client_event with no type in payload: event_id=${ev.event_id}`);
-    }
-    this.onEventCallback?.(ev);
-  }
-  handleConnectionError() {
-    this.clearLivenessTimer();
-    if (this.state === "closing" || this.state === "closed")
-      return;
-    this.abortController?.abort();
-    this.abortController = null;
-    const now = Date.now();
-    if (!this.reconnectStartTime) {
-      this.reconnectStartTime = now;
-    }
-    const elapsed = now - this.reconnectStartTime;
-    if (elapsed < RECONNECT_GIVE_UP_MS) {
-      if (this.reconnectTimer) {
-        clearTimeout(this.reconnectTimer);
-        this.reconnectTimer = null;
-      }
-      if (this.refreshHeaders) {
-        const freshHeaders = this.refreshHeaders();
-        Object.assign(this.headers, freshHeaders);
-        logForDebugging("SSETransport: Refreshed headers for reconnect");
-      }
-      this.state = "reconnecting";
-      this.reconnectAttempts++;
-      const baseDelay = Math.min(RECONNECT_BASE_DELAY_MS * Math.pow(2, this.reconnectAttempts - 1), RECONNECT_MAX_DELAY_MS);
-      const delay = Math.max(0, baseDelay + baseDelay * 0.25 * (2 * Math.random() - 1));
-      logForDebugging(`SSETransport: Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts}, ${Math.round(elapsed / 1000)}s elapsed)`);
-      logForDiagnosticsNoPII("error", "cli_sse_reconnect_attempt", {
-        reconnectAttempts: this.reconnectAttempts
-      });
-      this.reconnectTimer = setTimeout(() => {
-        this.reconnectTimer = null;
-        this.connect();
-      }, delay);
-    } else {
-      logForDebugging(`SSETransport: Reconnection time budget exhausted after ${Math.round(elapsed / 1000)}s`, { level: "error" });
-      logForDiagnosticsNoPII("error", "cli_sse_reconnect_exhausted", {
-        reconnectAttempts: this.reconnectAttempts,
-        elapsedMs: elapsed
-      });
-      this.state = "closed";
-      this.onCloseCallback?.();
-    }
-  }
-  onLivenessTimeout = () => {
-    this.livenessTimer = null;
-    logForDebugging("SSETransport: Liveness timeout, reconnecting", {
-      level: "error"
-    });
-    logForDiagnosticsNoPII("error", "cli_sse_liveness_timeout");
-    this.abortController?.abort();
-    this.handleConnectionError();
-  };
-  resetLivenessTimer() {
-    this.clearLivenessTimer();
-    this.livenessTimer = setTimeout(this.onLivenessTimeout, LIVENESS_TIMEOUT_MS);
-  }
-  clearLivenessTimer() {
-    if (this.livenessTimer) {
-      clearTimeout(this.livenessTimer);
-      this.livenessTimer = null;
-    }
-  }
-  async write(message) {
-    const authHeaders = this.getAuthHeaders();
-    if (Object.keys(authHeaders).length === 0) {
-      logForDebugging("SSETransport: No session token available for POST");
-      logForDiagnosticsNoPII("warn", "cli_sse_post_no_token");
-      return;
-    }
-    const headers = {
-      ...authHeaders,
-      "Content-Type": "application/json",
-      "anthropic-version": "2023-06-01",
-      "User-Agent": getClaudeCodeUserAgent()
-    };
-    logForDebugging(`SSETransport: POST body keys=${Object.keys(message).join(",")}`);
-    for (let attempt = 1;attempt <= POST_MAX_RETRIES; attempt++) {
-      try {
-        const response = await axios_default.post(this.postUrl, message, {
-          headers,
-          validateStatus: alwaysValidStatus2
-        });
-        if (response.status === 200 || response.status === 201) {
-          logForDebugging(`SSETransport: POST success type=${message.type}`);
-          return;
-        }
-        logForDebugging(`SSETransport: POST ${response.status} body=${jsonStringify(response.data).slice(0, 200)}`);
-        if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-          logForDebugging(`SSETransport: POST returned ${response.status} (client error), not retrying`);
-          logForDiagnosticsNoPII("warn", "cli_sse_post_client_error", {
-            status: response.status
-          });
-          return;
-        }
-        logForDebugging(`SSETransport: POST returned ${response.status}, attempt ${attempt}/${POST_MAX_RETRIES}`);
-        logForDiagnosticsNoPII("warn", "cli_sse_post_retryable_error", {
-          status: response.status,
-          attempt
-        });
-      } catch (error) {
-        const axiosError = error;
-        logForDebugging(`SSETransport: POST error: ${axiosError.message}, attempt ${attempt}/${POST_MAX_RETRIES}`);
-        logForDiagnosticsNoPII("warn", "cli_sse_post_network_error", {
-          attempt
-        });
-      }
-      if (attempt === POST_MAX_RETRIES) {
-        logForDebugging(`SSETransport: POST failed after ${POST_MAX_RETRIES} attempts, continuing`);
-        logForDiagnosticsNoPII("warn", "cli_sse_post_retries_exhausted");
-        return;
-      }
-      const delayMs = Math.min(POST_BASE_DELAY_MS * Math.pow(2, attempt - 1), POST_MAX_DELAY_MS);
-      await sleep(delayMs);
-    }
-  }
-  isConnectedStatus() {
-    return this.state === "connected";
-  }
-  isClosedStatus() {
-    return this.state === "closed";
-  }
-  setOnData(callback) {
-    this.onData = callback;
-  }
-  setOnClose(callback) {
-    this.onCloseCallback = callback;
-  }
-  setOnEvent(callback) {
-    this.onEventCallback = callback;
-  }
-  close() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.clearLivenessTimer();
-    this.state = "closing";
-    this.abortController?.abort();
-    this.abortController = null;
-  }
-}
-function convertSSEUrlToPostUrl(sseUrl) {
-  let pathname = sseUrl.pathname;
-  if (pathname.endsWith("/stream")) {
-    pathname = pathname.slice(0, -"/stream".length);
-  }
-  return `${sseUrl.protocol}//${sseUrl.host}${pathname}`;
-}
-
-export { createTokenRefreshScheduler, SerialBatchEventUploader, CCRInitError, CCRClient, SSETransport };
+export { SerialBatchEventUploader, CCRInitError, CCRClient };