@jdi-code/claude-code 1.0.3 → 1.2.0

package/dist/{chunk-f1rrxxcf.js → chunk-hs9w0p45.js}

@@ -3,28 +3,21 @@ import {
   Cursor,
   getLastKill,
   init_Cursor,
+  init_useTerminalSize,
   pushToKillRing,
   recordYank,
   resetKillAccumulation,
   resetYankState,
   updateYankLength,
+  useTerminalSize,
   yankPop
-} from "./chunk-5frcqxsv.js";
-import {
-  init_useTerminalSize,
-  useTerminalSize
-} from "./chunk-g653q217.js";
+} from "./chunk-4m6k7588.js";
 import {
   KeyboardEvent,
-  ThemedBox_default,
-  ThemedText,
-  init_ink,
-  init_keyboard_event,
-  require_compiler_runtime,
+  init_src,
   use_input_default
-} from "./chunk-z72st5c8.js";
+} from "./chunk-cmsknj6n.js";
 import {
-  require_jsx_dev_runtime,
   require_react
 } from "./chunk-g338npwr.js";
 import {
@@ -286,8 +279,7 @@ function useSearchInput({
 }
 var import_react, UNHANDLED_SPECIAL_KEYS;
 var init_useSearchInput = __esm(() => {
-  init_keyboard_event();
-  init_ink();
+  init_src();
   init_Cursor();
   init_useTerminalSize();
   import_react = __toESM(require_react(), 1);
@@ -313,120 +305,4 @@ var init_useSearchInput = __esm(() => {
   ]);
 });
 
-// src/components/SearchBox.tsx
-function SearchBox(t0) {
-  const $ = import_compiler_runtime.c(17);
-  const {
-    query,
-    placeholder: t1,
-    isFocused,
-    isTerminalFocused,
-    prefix: t2,
-    width,
-    cursorOffset,
-    borderless: t3
-  } = t0;
-  const placeholder = t1 === undefined ? "Search\u2026" : t1;
-  const prefix = t2 === undefined ? "\u2315" : t2;
-  const borderless = t3 === undefined ? false : t3;
-  const offset = cursorOffset ?? query.length;
-  const t4 = borderless ? undefined : "round";
-  const t5 = isFocused ? "suggestion" : undefined;
-  const t6 = !isFocused;
-  const t7 = borderless ? 0 : 1;
-  const t8 = !isFocused;
-  let t9;
-  if ($[0] !== isFocused || $[1] !== isTerminalFocused || $[2] !== offset || $[3] !== placeholder || $[4] !== query) {
-    t9 = isFocused ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
-      children: query ? isTerminalFocused ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
-        children: [
-          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-            children: query.slice(0, offset)
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-            inverse: true,
-            children: offset < query.length ? query[offset] : " "
-          }, undefined, false, undefined, this),
-          offset < query.length && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-            children: query.slice(offset + 1)
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-        children: query
-      }, undefined, false, undefined, this) : isTerminalFocused ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
-        children: [
-          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-            inverse: true,
-            children: placeholder.charAt(0)
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-            dimColor: true,
-            children: placeholder.slice(1)
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-        dimColor: true,
-        children: placeholder
-      }, undefined, false, undefined, this)
-    }, undefined, false, undefined, this) : query ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-      children: query
-    }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-      children: placeholder
-    }, undefined, false, undefined, this);
-    $[0] = isFocused;
-    $[1] = isTerminalFocused;
-    $[2] = offset;
-    $[3] = placeholder;
-    $[4] = query;
-    $[5] = t9;
-  } else {
-    t9 = $[5];
-  }
-  let t10;
-  if ($[6] !== prefix || $[7] !== t8 || $[8] !== t9) {
-    t10 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
-      dimColor: t8,
-      children: [
-        prefix,
-        " ",
-        t9
-      ]
-    }, undefined, true, undefined, this);
-    $[6] = prefix;
-    $[7] = t8;
-    $[8] = t9;
-    $[9] = t10;
-  } else {
-    t10 = $[9];
-  }
-  let t11;
-  if ($[10] !== t10 || $[11] !== t4 || $[12] !== t5 || $[13] !== t6 || $[14] !== t7 || $[15] !== width) {
-    t11 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
-      flexShrink: 0,
-      borderStyle: t4,
-      borderColor: t5,
-      borderDimColor: t6,
-      paddingX: t7,
-      width,
-      children: t10
-    }, undefined, false, undefined, this);
-    $[10] = t10;
-    $[11] = t4;
-    $[12] = t5;
-    $[13] = t6;
-    $[14] = t7;
-    $[15] = width;
-    $[16] = t11;
-  } else {
-    t11 = $[16];
-  }
-  return t11;
-}
-var import_compiler_runtime, jsx_dev_runtime;
-var init_SearchBox = __esm(() => {
-  init_ink();
-  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
-  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
-});
-
-export { SearchBox, init_SearchBox, useSearchInput, init_useSearchInput };
+export { useSearchInput, init_useSearchInput };

package/dist/{chunk-9f7xza5r.js → chunk-htaan7k0.js}

@@ -1,11 +1,11 @@
 // @bun
 import {
   detectAndUninstallDelistedPlugins
-} from "./chunk-3vzs2gbq.js";
+} from "./chunk-8gxztyqd.js";
 import {
   getFlaggedPlugins,
   init_pluginFlagging
-} from "./chunk-czkshaff.js";
+} from "./chunk-107p04a0.js";
 import {
   getPluginCommands,
   init_AppState,
@@ -26,32 +26,32 @@ import {
   useAppState,
   useNotifications,
   useSetAppState
-} from "./chunk-5frcqxsv.js";
-import {
-  require_react
-} from "./chunk-g338npwr.js";
+} from "./chunk-4m6k7588.js";
 import {
   count,
   init_array
-} from "./chunk-0e1xsncc.js";
+} from "./chunk-1cwdhk7a.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
 import {
   init_analytics,
   logEvent
-} from "./chunk-f2mhrmww.js";
+} from "./chunk-h0rbjg6x.js";
 import {
   init_diagLogs,
   logForDiagnosticsNoPII
-} from "./chunk-hrzerbfw.js";
+} from "./chunk-36b2q5fg.js";
 import {
   init_log,
   logError
-} from "./chunk-p7g7pf3f.js";
+} from "./chunk-y3r7v9pq.js";
 import {
   init_debug,
   init_errors,
   logForDebugging,
   toError
-} from "./chunk-nxsh6de2.js";
+} from "./chunk-404qm8xt.js";
 import {
   __toESM
 } from "./chunk-qp2qdcda.js";

package/dist/chunk-htg84hvs.js

@@ -0,0 +1,300 @@
+// @bun
+import {
+  checkAndRefreshOAuthTokenIfNeeded,
+  getClaudeAIOAuthTokens,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getUserAgent,
+  init_auth,
+  init_growthbook,
+  init_http,
+  isAnthropicAuthEnabled
+} from "./chunk-zhtrjznv.js";
+import {
+  getWebSocketProxyAgent,
+  getWebSocketProxyUrl,
+  getWebSocketTLSOptions,
+  init_mtls,
+  init_proxy
+} from "./chunk-cztjpxq4.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-q82r31er.js";
+import {
+  init_log,
+  logError
+} from "./chunk-y3r7v9pq.js";
+import {
+  init_debug,
+  init_slowOperations,
+  jsonParse,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-404qm8xt.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/voiceStreamSTT.ts
+import WebSocket from "ws";
+function isVoiceStreamAvailable() {
+  if (!isAnthropicAuthEnabled()) {
+    return false;
+  }
+  const tokens = getClaudeAIOAuthTokens();
+  return tokens !== null && tokens.accessToken !== null;
+}
+async function connectVoiceStream(callbacks, options) {
+  await checkAndRefreshOAuthTokenIfNeeded();
+  const tokens = getClaudeAIOAuthTokens();
+  if (!tokens?.accessToken) {
+    logForDebugging("[voice_stream] No OAuth token available");
+    return null;
+  }
+  const wsBaseUrl = process.env.VOICE_STREAM_BASE_URL || getOauthConfig().BASE_API_URL.replace("https://", "wss://").replace("http://", "ws://");
+  if (process.env.VOICE_STREAM_BASE_URL) {
+    logForDebugging(`[voice_stream] Using VOICE_STREAM_BASE_URL override: ${process.env.VOICE_STREAM_BASE_URL}`);
+  }
+  const params = new URLSearchParams({
+    encoding: "linear16",
+    sample_rate: "16000",
+    channels: "1",
+    endpointing_ms: "300",
+    utterance_end_ms: "1000",
+    language: options?.language ?? "en"
+  });
+  const isNova3 = getFeatureValue_CACHED_MAY_BE_STALE("tengu_cobalt_frost", false);
+  if (isNova3) {
+    params.set("use_conversation_engine", "true");
+    params.set("stt_provider", "deepgram-nova3");
+    logForDebugging("[voice_stream] Nova 3 gate enabled (tengu_cobalt_frost)");
+  }
+  if (options?.keyterms?.length) {
+    for (const term of options.keyterms) {
+      params.append("keyterms", term);
+    }
+  }
+  const url = `${wsBaseUrl}${VOICE_STREAM_PATH}?${params.toString()}`;
+  logForDebugging(`[voice_stream] Connecting to ${url}`);
+  const headers = {
+    Authorization: `Bearer ${tokens.accessToken}`,
+    "User-Agent": getUserAgent(),
+    "x-app": "cli"
+  };
+  const tlsOptions = getWebSocketTLSOptions();
+  const wsOptions = typeof Bun !== "undefined" ? {
+    headers,
+    proxy: getWebSocketProxyUrl(url),
+    tls: tlsOptions || undefined
+  } : { headers, agent: getWebSocketProxyAgent(url), ...tlsOptions };
+  const ws = new WebSocket(url, wsOptions);
+  let keepaliveTimer = null;
+  let connected = false;
+  let finalized = false;
+  let finalizing = false;
+  let upgradeRejected = false;
+  let resolveFinalize = null;
+  let cancelNoDataTimer = null;
+  const connection = {
+    send(audioChunk) {
+      if (ws.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      if (finalized) {
+        logForDebugging(`[voice_stream] Dropping audio chunk after CloseStream: ${String(audioChunk.length)} bytes`);
+        return;
+      }
+      logForDebugging(`[voice_stream] Sending audio chunk: ${String(audioChunk.length)} bytes`);
+      ws.send(Buffer.from(audioChunk));
+    },
+    finalize() {
+      if (finalizing || finalized) {
+        return Promise.resolve("ws_already_closed");
+      }
+      finalizing = true;
+      return new Promise((resolve) => {
+        const safetyTimer = setTimeout(() => resolveFinalize?.("safety_timeout"), FINALIZE_TIMEOUTS_MS.safety);
+        const noDataTimer = setTimeout(() => resolveFinalize?.("no_data_timeout"), FINALIZE_TIMEOUTS_MS.noData);
+        cancelNoDataTimer = () => {
+          clearTimeout(noDataTimer);
+          cancelNoDataTimer = null;
+        };
+        resolveFinalize = (source) => {
+          clearTimeout(safetyTimer);
+          clearTimeout(noDataTimer);
+          resolveFinalize = null;
+          cancelNoDataTimer = null;
+          if (lastTranscriptText) {
+            logForDebugging(`[voice_stream] Promoting unreported interim before ${source} resolve`);
+            const t = lastTranscriptText;
+            lastTranscriptText = "";
+            callbacks.onTranscript(t, true);
+          }
+          logForDebugging(`[voice_stream] Finalize resolved via ${source}`);
+          resolve(source);
+        };
+        if (ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
+          resolveFinalize("ws_already_closed");
+          return;
+        }
+        setTimeout(() => {
+          finalized = true;
+          if (ws.readyState === WebSocket.OPEN) {
+            logForDebugging("[voice_stream] Sending CloseStream (finalize)");
+            ws.send(CLOSE_STREAM_MSG);
+          }
+        }, 0);
+      });
+    },
+    close() {
+      finalized = true;
+      if (keepaliveTimer) {
+        clearInterval(keepaliveTimer);
+        keepaliveTimer = null;
+      }
+      connected = false;
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.close();
+      }
+    },
+    isConnected() {
+      return connected && ws.readyState === WebSocket.OPEN;
+    }
+  };
+  ws.on("open", () => {
+    logForDebugging("[voice_stream] WebSocket connected");
+    connected = true;
+    logForDebugging("[voice_stream] Sending initial KeepAlive");
+    ws.send(KEEPALIVE_MSG);
+    keepaliveTimer = setInterval((ws2) => {
+      if (ws2.readyState === WebSocket.OPEN) {
+        logForDebugging("[voice_stream] Sending periodic KeepAlive");
+        ws2.send(KEEPALIVE_MSG);
+      }
+    }, KEEPALIVE_INTERVAL_MS, ws);
+    callbacks.onReady(connection);
+  });
+  let lastTranscriptText = "";
+  ws.on("message", (raw) => {
+    const text = raw.toString();
+    logForDebugging(`[voice_stream] Message received (${String(text.length)} chars): ${text.slice(0, 200)}`);
+    let msg;
+    try {
+      msg = jsonParse(text);
+    } catch {
+      return;
+    }
+    switch (msg.type) {
+      case "TranscriptText": {
+        const transcript = msg.data;
+        logForDebugging(`[voice_stream] TranscriptText: "${transcript ?? ""}"`);
+        if (finalized) {
+          cancelNoDataTimer?.();
+        }
+        if (transcript) {
+          if (!isNova3 && lastTranscriptText) {
+            const prev = lastTranscriptText.trimStart();
+            const next = transcript.trimStart();
+            if (prev && next && !next.startsWith(prev) && !prev.startsWith(next)) {
+              logForDebugging(`[voice_stream] Auto-finalizing previous segment (new segment detected): "${lastTranscriptText}"`);
+              callbacks.onTranscript(lastTranscriptText, true);
+            }
+          }
+          lastTranscriptText = transcript;
+          callbacks.onTranscript(transcript, false);
+        }
+        break;
+      }
+      case "TranscriptEndpoint": {
+        logForDebugging(`[voice_stream] TranscriptEndpoint received, lastTranscriptText="${lastTranscriptText}"`);
+        const finalText = lastTranscriptText;
+        lastTranscriptText = "";
+        if (finalText) {
+          callbacks.onTranscript(finalText, true);
+        }
+        if (finalized) {
+          resolveFinalize?.("post_closestream_endpoint");
+        }
+        break;
+      }
+      case "TranscriptError": {
+        const desc = msg.description ?? msg.error_code ?? "unknown transcription error";
+        logForDebugging(`[voice_stream] TranscriptError: ${desc}`);
+        if (!finalizing) {
+          callbacks.onError(desc);
+        }
+        break;
+      }
+      case "error": {
+        const errorDetail = msg.message ?? jsonStringify(msg);
+        logForDebugging(`[voice_stream] Server error: ${errorDetail}`);
+        if (!finalizing) {
+          callbacks.onError(errorDetail);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  });
+  ws.on("close", (code, reason) => {
+    const reasonStr = reason?.toString() ?? "";
+    logForDebugging(`[voice_stream] WebSocket closed: code=${String(code)} reason="${reasonStr}"`);
+    connected = false;
+    if (keepaliveTimer) {
+      clearInterval(keepaliveTimer);
+      keepaliveTimer = null;
+    }
+    if (lastTranscriptText) {
+      logForDebugging("[voice_stream] Promoting unreported interim transcript to final on close");
+      const finalText = lastTranscriptText;
+      lastTranscriptText = "";
+      callbacks.onTranscript(finalText, true);
+    }
+    resolveFinalize?.("ws_close");
+    if (!finalizing && !upgradeRejected && code !== 1000 && code !== 1005) {
+      callbacks.onError(`Connection closed: code ${String(code)}${reasonStr ? ` \u2014 ${reasonStr}` : ""}`);
+    }
+    callbacks.onClose();
+  });
+  ws.on("unexpected-response", (req, res) => {
+    const status = res.statusCode ?? 0;
+    if (status === 101) {
+      logForDebugging("[voice_stream] unexpected-response fired with 101; ignoring");
+      return;
+    }
+    logForDebugging(`[voice_stream] Upgrade rejected: status=${String(status)} cf-mitigated=${String(res.headers["cf-mitigated"])} cf-ray=${String(res.headers["cf-ray"])}`);
+    upgradeRejected = true;
+    res.resume();
+    req.destroy();
+    if (finalizing)
+      return;
+    callbacks.onError(`WebSocket upgrade rejected with HTTP ${String(status)}`, { fatal: status >= 400 && status < 500 });
+  });
+  ws.on("error", (err) => {
+    logError(err);
+    logForDebugging(`[voice_stream] WebSocket error: ${err.message}`);
+    if (!finalizing) {
+      callbacks.onError(`Voice stream connection error: ${err.message}`);
+    }
+  });
+  return connection;
+}
+var KEEPALIVE_MSG = '{"type":"KeepAlive"}', CLOSE_STREAM_MSG = '{"type":"CloseStream"}', VOICE_STREAM_PATH = "/api/ws/speech_to_text/voice_stream", KEEPALIVE_INTERVAL_MS = 8000, FINALIZE_TIMEOUTS_MS;
+var init_voiceStreamSTT = __esm(() => {
+  init_oauth();
+  init_auth();
+  init_debug();
+  init_http();
+  init_log();
+  init_mtls();
+  init_proxy();
+  init_slowOperations();
+  init_growthbook();
+  FINALIZE_TIMEOUTS_MS = {
+    safety: 5000,
+    noData: 1500
+  };
+});
+
+export { FINALIZE_TIMEOUTS_MS, isVoiceStreamAvailable, connectVoiceStream, init_voiceStreamSTT };