@redscope-ai/redscope 1.0.0

package/dist/chunk-yt3nfhcc.js

@@ -0,0 +1,152 @@
+// @bun
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-j1mep9ck.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-10k5jfc5.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonParse,
+  logForDebugging
+} from "./chunk-s3hafnk3.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 };
+}
+
+export { decodeJwtExpiry, createTokenRefreshScheduler };

package/dist/chunk-yy8q0n8s.js

@@ -0,0 +1,120 @@
+// @bun
+import {
+  call,
+  init_thinkback,
+  playAnimation
+} from "./chunk-5dmn1865.js";
+import"./chunk-bxa6tw4m.js";
+import"./chunk-aw4s3a99.js";
+import"./chunk-gmdy2w3z.js";
+import"./chunk-q0e485mg.js";
+import"./chunk-2kcgxnvp.js";
+import"./chunk-14p6wvsq.js";
+import"./chunk-6s0q1s5r.js";
+import"./chunk-3w9sye8h.js";
+import"./chunk-nzxfj0gq.js";
+import"./chunk-vr0n9pv9.js";
+import"./chunk-9a9g5hbj.js";
+import"./chunk-ptxteaeh.js";
+import"./chunk-w4p5t920.js";
+import"./chunk-rgyzsbs3.js";
+import"./chunk-q3b4n194.js";
+import"./chunk-kywtr3jg.js";
+import"./chunk-eewg66y1.js";
+import"./chunk-71sdcaq6.js";
+import"./chunk-9hn8e6h1.js";
+import"./chunk-7qey87th.js";
+import"./chunk-zw62m6n3.js";
+import"./chunk-1w20m7gw.js";
+import"./chunk-zzf074w3.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-24kv69g3.js";
+import"./chunk-hzxzvzw8.js";
+import"./chunk-30wnahyg.js";
+import"./chunk-ztmb7geg.js";
+import"./chunk-tbdkekz3.js";
+import"./chunk-65zbgg1n.js";
+import"./chunk-4spgkgr3.js";
+import"./chunk-60fkafk2.js";
+import"./chunk-50m3a23z.js";
+import"./chunk-6hygvrhn.js";
+import"./chunk-7tfdhkpy.js";
+import"./chunk-8gv2pjby.js";
+import"./chunk-g06pm4n9.js";
+import"./chunk-2p369q9z.js";
+import"./chunk-z0jgeax8.js";
+import"./chunk-w68wc625.js";
+import"./chunk-6hr7742d.js";
+import"./chunk-xyg1sk2w.js";
+import"./chunk-935nrvdb.js";
+import"./chunk-8zz4z1q3.js";
+import"./chunk-fncpkzs5.js";
+import"./chunk-hqxp6b72.js";
+import"./chunk-m2c3bjv1.js";
+import"./chunk-jhtccjc9.js";
+import"./chunk-7nvday0n.js";
+import"./chunk-vxbjzggp.js";
+import"./chunk-yc1stfve.js";
+import"./chunk-8yvsnrkr.js";
+import"./chunk-5mmhfbxb.js";
+import"./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import"./chunk-8kct9arg.js";
+import"./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import"./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-7qx3xhv3.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-dbts5q5p.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-q44zc68f.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import"./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-92bjkrf2.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import"./chunk-hhsxm2yr.js";
+init_thinkback();
+
+export {
+  playAnimation,
+  call
+};

package/dist/chunk-yzb92zxv.js

@@ -0,0 +1,8 @@
+// @bun
+import"./chunk-hhsxm2yr.js";
+
+// src/utils/sdkHeapDumpMonitor.ts
+var startSdkMemoryMonitor = () => {};
+export {
+  startSdkMemoryMonitor
+};

package/dist/chunk-yzet6xyr.js

@@ -0,0 +1,119 @@
+// @bun
+import {
+  checkAndDisableAutoModeIfNeeded,
+  init_bypassPermissionsKillswitch,
+  resetAutoModeGateCheck
+} from "./chunk-754qdxs5.js";
+import {
+  init_useMainLoopModel,
+  useMainLoopModel
+} from "./chunk-g9vg5d7t.js";
+import {
+  ConfigurableShortcutHint,
+  ConsoleOAuthFlow,
+  init_ConfigurableShortcutHint,
+  init_ConsoleOAuthFlow,
+  init_messages1 as init_messages,
+  init_policyLimits,
+  init_remoteManagedSettings,
+  refreshPolicyLimits,
+  refreshRemoteManagedSettings,
+  stripSignatureBlocks
+} from "./chunk-gmdy2w3z.js";
+import {
+  clearTrustedDeviceToken,
+  enrollTrustedDevice,
+  init_trustedDevice
+} from "./chunk-vr0n9pv9.js";
+import {
+  init_growthbook,
+  init_user,
+  refreshGrowthBookAfterAuthChange,
+  resetUserCache
+} from "./chunk-eemjb825.js";
+import {
+  Dialog,
+  ThemedText,
+  init_src
+} from "./chunk-2g0ytd9d.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-de0qnnf7.js";
+import {
+  init_state,
+  resetCostState
+} from "./chunk-9h9k5vz3.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/login/login.tsx
+async function call(onDone, context) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Login, {
+    onDone: async (success) => {
+      context.onChangeAPIKey();
+      context.setMessages(stripSignatureBlocks);
+      if (success) {
+        resetCostState();
+        refreshRemoteManagedSettings();
+        refreshPolicyLimits();
+        resetUserCache();
+        refreshGrowthBookAfterAuthChange();
+        clearTrustedDeviceToken();
+        enrollTrustedDevice();
+        resetAutoModeGateCheck();
+        const appState = context.getAppState();
+        checkAndDisableAutoModeIfNeeded(appState.toolPermissionContext, context.setAppState, appState.fastMode);
+        context.setAppState((prev) => ({
+          ...prev,
+          authVersion: prev.authVersion + 1
+        }));
+      }
+      onDone(success ? "Login successful" : "Login interrupted");
+    }
+  }, undefined, false, undefined, this);
+}
+function Login(props) {
+  const mainLoopModel = useMainLoopModel();
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+    title: "Login",
+    onCancel: () => props.onDone(false, mainLoopModel),
+    color: "permission",
+    inputGuide: (exitState) => exitState.pending ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: [
+        "Press ",
+        exitState.keyName,
+        " again to exit"
+      ]
+    }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ConfigurableShortcutHint, {
+      action: "confirm:no",
+      context: "Confirmation",
+      fallback: "Esc",
+      description: "cancel"
+    }, undefined, false, undefined, this),
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ConsoleOAuthFlow, {
+      onDone: () => props.onDone(true, mainLoopModel),
+      startingMessage: props.startingMessage
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+var jsx_dev_runtime;
+var init_login = __esm(() => {
+  init_state();
+  init_trustedDevice();
+  init_ConfigurableShortcutHint();
+  init_ConsoleOAuthFlow();
+  init_src();
+  init_useMainLoopModel();
+  init_src();
+  init_growthbook();
+  init_policyLimits();
+  init_remoteManagedSettings();
+  init_messages();
+  init_bypassPermissionsKillswitch();
+  init_user();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { call, Login, init_login };

package/dist/chunk-yzm97qp1.js

@@ -0,0 +1,226 @@
+// @bun
+import {
+  init_store,
+  setProviderBalance
+} from "./chunk-rgyzsbs3.js";
+import"./chunk-hhsxm2yr.js";
+
+// src/services/providerUsage/balance/poller.ts
+init_store();
+
+// src/services/providerUsage/balance/deepseek.ts
+function getBaseUrl() {
+  const url = process.env.OPENAI_BASE_URL;
+  if (url && /\bapi\.deepseek\.com\b/i.test(url))
+    return url.replace(/\/+$/, "");
+  if (process.env.DEEPSEEK_API_KEY)
+    return "https://api.deepseek.com";
+  return null;
+}
+function getApiKey() {
+  return process.env.DEEPSEEK_API_KEY || process.env.OPENAI_API_KEY || null;
+}
+var deepseekBalanceProvider = {
+  providerId: "deepseek",
+  isEnabled() {
+    return getBaseUrl() !== null && getApiKey() !== null;
+  },
+  async fetchBalance(signal) {
+    const base = getBaseUrl();
+    const key = getApiKey();
+    if (!base || !key)
+      return null;
+    let res;
+    try {
+      res = await fetch(`${base}/user/balance`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${key}`,
+          Accept: "application/json"
+        },
+        signal
+      });
+    } catch {
+      return null;
+    }
+    if (!res.ok)
+      return null;
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      return null;
+    }
+    const infos = data?.balance_infos;
+    if (!Array.isArray(infos))
+      return null;
+    const usd = infos.find((e) => typeof e === "object" && e !== null && e.currency === "USD");
+    const pick = usd ?? infos[0] ?? null;
+    if (!pick)
+      return null;
+    const currency = typeof pick.currency === "string" ? pick.currency : "USD";
+    const remainingRaw = pick.total_balance;
+    const remaining = typeof remainingRaw === "number" ? remainingRaw : Number(remainingRaw);
+    if (!Number.isFinite(remaining))
+      return null;
+    return {
+      currency,
+      remaining,
+      updatedAt: Math.floor(Date.now() / 1000)
+    };
+  }
+};
+
+// src/services/providerUsage/balance/generic.ts
+function pickAtPath(obj, path) {
+  if (!path)
+    return obj;
+  const parts = path.split(".").filter(Boolean);
+  let cur = obj;
+  for (const part of parts) {
+    if (cur === null || cur === undefined)
+      return;
+    if (Array.isArray(cur)) {
+      const idx = Number(part);
+      if (!Number.isFinite(idx))
+        return;
+      cur = cur[idx];
+    } else if (typeof cur === "object") {
+      cur = cur[part];
+    } else {
+      return;
+    }
+  }
+  return cur;
+}
+var PRIVATE_IP_RE = /^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|169\.254\.|127\.|0\.0\.0\.0|fc|fd|\[::1\]|\[fe80:)/;
+function assertSafeBalanceUrl(raw) {
+  const parsed = new URL(raw);
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new Error(`unsupported protocol: ${parsed.protocol}`);
+  }
+  if (parsed.protocol === "http:" && !["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname)) {
+    throw new Error(`http only allowed for localhost, got ${parsed.hostname}`);
+  }
+  if (PRIVATE_IP_RE.test(parsed.hostname)) {
+    throw new Error(`private/reserved IP not allowed: ${parsed.hostname}`);
+  }
+  return parsed;
+}
+var genericBalanceProvider = {
+  providerId: "generic",
+  isEnabled() {
+    return Boolean(process.env.CLAUDE_CODE_BALANCE_URL);
+  },
+  async fetchBalance(signal) {
+    const rawUrl = process.env.CLAUDE_CODE_BALANCE_URL;
+    if (!rawUrl)
+      return null;
+    let url;
+    try {
+      url = assertSafeBalanceUrl(rawUrl);
+    } catch {
+      return null;
+    }
+    const key = process.env.CLAUDE_CODE_BALANCE_KEY || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || "";
+    const path = process.env.CLAUDE_CODE_BALANCE_JSON_PATH || "balance";
+    const currency = process.env.CLAUDE_CODE_BALANCE_CURRENCY || "USD";
+    let res;
+    try {
+      res = await fetch(url.href, {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          ...key ? { Authorization: `Bearer ${key}` } : {}
+        },
+        signal
+      });
+    } catch {
+      return null;
+    }
+    if (!res.ok)
+      return null;
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      return null;
+    }
+    const raw = pickAtPath(data, path);
+    const remaining = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(remaining))
+      return null;
+    return {
+      currency,
+      remaining,
+      updatedAt: Math.floor(Date.now() / 1000)
+    };
+  }
+};
+
+// src/services/providerUsage/balance/poller.ts
+var DEFAULT_INTERVAL_MIN = 10;
+var PROVIDERS = [
+  genericBalanceProvider,
+  deepseekBalanceProvider
+];
+function selectProvider() {
+  if (process.env.CLAUDE_CODE_BALANCE_PROVIDER === "none")
+    return null;
+  return PROVIDERS.find((p) => p.isEnabled()) ?? null;
+}
+function intervalMs() {
+  const raw = process.env.CLAUDE_CODE_BALANCE_POLL_INTERVAL_MINUTES;
+  const n = raw ? Number(raw) : DEFAULT_INTERVAL_MIN;
+  if (!Number.isFinite(n) || n <= 0)
+    return DEFAULT_INTERVAL_MIN * 60000;
+  return Math.floor(n * 60000);
+}
+var timer = null;
+var inflight = null;
+var active = null;
+var FETCH_TIMEOUT_MS = 1e4;
+async function tick() {
+  if (!active)
+    return;
+  inflight?.abort();
+  inflight = new AbortController;
+  const timeout = setTimeout(() => inflight?.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const balance = await active.fetchBalance(inflight.signal);
+    setProviderBalance(active.providerId, balance);
+  } catch {} finally {
+    clearTimeout(timeout);
+  }
+}
+function startBalancePolling() {
+  if (timer !== null)
+    return;
+  active = selectProvider();
+  if (!active)
+    return;
+  tick();
+  timer = setInterval(() => {
+    tick();
+  }, intervalMs());
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+}
+function stopBalancePolling() {
+  if (timer !== null) {
+    clearInterval(timer);
+    timer = null;
+  }
+  inflight?.abort();
+  inflight = null;
+  active = null;
+}
+function getActiveBalanceProviderId() {
+  return active?.providerId ?? null;
+}
+export {
+  stopBalancePolling,
+  startBalancePolling,
+  getActiveBalanceProviderId
+};

package/dist/chunk-z0jgeax8.js

@@ -0,0 +1,35 @@
+// @bun
+import {
+  getClaudeAIOAuthTokens,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  init_auth,
+  init_growthbook,
+  isAnthropicAuthEnabled
+} from "./chunk-eemjb825.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/voice/voiceModeEnabled.ts
+function isVoiceGrowthBookEnabled() {
+  return !getFeatureValue_CACHED_MAY_BE_STALE("tengu_amber_quartz_disabled", false);
+}
+function hasVoiceAuth() {
+  if (!isAnthropicAuthEnabled()) {
+    return false;
+  }
+  const tokens = getClaudeAIOAuthTokens();
+  return Boolean(tokens?.accessToken);
+}
+function isVoiceModeEnabled() {
+  return hasVoiceAuth() && isVoiceGrowthBookEnabled();
+}
+function isVoiceAvailable() {
+  return isVoiceGrowthBookEnabled();
+}
+var init_voiceModeEnabled = __esm(() => {
+  init_growthbook();
+  init_auth();
+});
+
+export { isVoiceGrowthBookEnabled, hasVoiceAuth, isVoiceModeEnabled, isVoiceAvailable, init_voiceModeEnabled };

package/dist/chunk-z1r3z6w6.js

@@ -0,0 +1,29 @@
+// @bun
+import {
+  init_completionCache,
+  regenerateCompletionCache,
+  setupShellCompletion
+} from "./chunk-ztmb7geg.js";
+import"./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-3nk9q8dr.js";
+import"./chunk-hhsxm2yr.js";
+init_completionCache();
+
+export {
+  setupShellCompletion,
+  regenerateCompletionCache
+};