@xortex/xcode 3.0.1 → 3.0.3

package/components/PromptInput/Notifications.tsx

@@ -0,0 +1,332 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import * as React from 'react';
+import { type ReactNode, useEffect, useMemo, useState } from 'react';
+import { type Notification, useNotifications } from 'src/context/notifications.js';
+import { logEvent } from 'src/services/analytics/index.js';
+import { useAppState } from 'src/state/AppState.js';
+import { useVoiceState } from '../../context/voice.js';
+import type { VerificationStatus } from '../../hooks/useApiKeyVerification.js';
+import { useIdeConnectionStatus } from '../../hooks/useIdeConnectionStatus.js';
+import type { IDESelection } from '../../hooks/useIdeSelection.js';
+import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
+import { useVoiceEnabled } from '../../hooks/useVoiceEnabled.js';
+import { Box, Text } from '../../ink.js';
+import { useClaudeAiLimits } from '../../services/claudeAiLimitsHook.js';
+import { calculateTokenWarningState } from '../../services/compact/autoCompact.js';
+import type { MCPServerConnection } from '../../services/mcp/types.js';
+import type { Message } from '../../types/message.js';
+import { getApiKeyHelperElapsedMs, getConfiguredApiKeyHelper, getSubscriptionType } from '../../utils/auth.js';
+import type { AutoUpdaterResult } from '../../utils/autoUpdater.js';
+import { getExternalEditor } from '../../utils/editor.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import { formatDuration } from '../../utils/format.js';
+import { setEnvHookNotifier } from '../../utils/hooks/fileChangedWatcher.js';
+import { toIDEDisplayName } from '../../utils/ide.js';
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js';
+import { tokenCountFromLastAPIResponse } from '../../utils/tokens.js';
+import { AutoUpdaterWrapper } from '../AutoUpdaterWrapper.js';
+import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js';
+import { IdeStatusIndicator } from '../IdeStatusIndicator.js';
+import { MemoryUsageIndicator } from '../MemoryUsageIndicator.js';
+import { SentryErrorBoundary } from '../SentryErrorBoundary.js';
+import { TokenWarning } from '../TokenWarning.js';
+import { SandboxPromptFooterHint } from './SandboxPromptFooterHint.js';
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const VoiceIndicator: typeof import('./VoiceIndicator.js').VoiceIndicator = feature('VOICE_MODE') ? require('./VoiceIndicator.js').VoiceIndicator : () => null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+export const FOOTER_TEMPORARY_STATUS_TIMEOUT = 5000;
+type Props = {
+  apiKeyStatus: VerificationStatus;
+  autoUpdaterResult: AutoUpdaterResult | null;
+  isAutoUpdating: boolean;
+  debug: boolean;
+  verbose: boolean;
+  messages: Message[];
+  onAutoUpdaterResult: (result: AutoUpdaterResult) => void;
+  onChangeIsUpdating: (isUpdating: boolean) => void;
+  ideSelection: IDESelection | undefined;
+  mcpClients?: MCPServerConnection[];
+  isInputWrapped?: boolean;
+  isNarrow?: boolean;
+};
+export function Notifications(t0) {
+  const $ = _c(34);
+  const {
+    apiKeyStatus,
+    autoUpdaterResult,
+    debug,
+    isAutoUpdating,
+    verbose,
+    messages,
+    onAutoUpdaterResult,
+    onChangeIsUpdating,
+    ideSelection,
+    mcpClients,
+    isInputWrapped: t1,
+    isNarrow: t2
+  } = t0;
+  const isInputWrapped = t1 === undefined ? false : t1;
+  const isNarrow = t2 === undefined ? false : t2;
+  let t3;
+  if ($[0] !== messages) {
+    const messagesForTokenCount = getMessagesAfterCompactBoundary(messages);
+    t3 = tokenCountFromLastAPIResponse(messagesForTokenCount);
+    $[0] = messages;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  const tokenUsage = t3;
+  const mainLoopModel = useMainLoopModel();
+  let t4;
+  if ($[2] !== mainLoopModel || $[3] !== tokenUsage) {
+    t4 = calculateTokenWarningState(tokenUsage, mainLoopModel);
+    $[2] = mainLoopModel;
+    $[3] = tokenUsage;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  const isShowingCompactMessage = t4.isAboveWarningThreshold;
+  const {
+    status: ideStatus
+  } = useIdeConnectionStatus(mcpClients);
+  const notifications = useAppState(_temp);
+  const {
+    addNotification,
+    removeNotification
+  } = useNotifications();
+  const claudeAiLimits = useClaudeAiLimits();
+  let t5;
+  let t6;
+  if ($[5] !== addNotification) {
+    t5 = () => {
+      setEnvHookNotifier((text, isError) => {
+        addNotification({
+          key: "env-hook",
+          text,
+          color: isError ? "error" : undefined,
+          priority: isError ? "medium" : "low",
+          timeoutMs: isError ? 8000 : 5000
+        });
+      });
+      return _temp2;
+    };
+    t6 = [addNotification];
+    $[5] = addNotification;
+    $[6] = t5;
+    $[7] = t6;
+  } else {
+    t5 = $[6];
+    t6 = $[7];
+  }
+  useEffect(t5, t6);
+  const shouldShowIdeSelection = ideStatus === "connected" && (ideSelection?.filePath || ideSelection?.text && ideSelection.lineCount > 0);
+  const shouldShowAutoUpdater = !shouldShowIdeSelection || isAutoUpdating || autoUpdaterResult?.status !== "success";
+  const isInOverageMode = claudeAiLimits.isUsingOverage;
+  let t7;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = getSubscriptionType();
+    $[8] = t7;
+  } else {
+    t7 = $[8];
+  }
+  const subscriptionType = t7;
+  const isTeamOrEnterprise = subscriptionType === "team" || subscriptionType === "enterprise";
+  let t8;
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = getExternalEditor();
+    $[9] = t8;
+  } else {
+    t8 = $[9];
+  }
+  const editor = t8;
+  const shouldShowExternalEditorHint = isInputWrapped && !isShowingCompactMessage && apiKeyStatus !== "invalid" && apiKeyStatus !== "missing" && editor !== undefined;
+  let t10;
+  let t9;
+  if ($[10] !== addNotification || $[11] !== removeNotification || $[12] !== shouldShowExternalEditorHint) {
+    t9 = () => {
+      if (shouldShowExternalEditorHint && editor) {
+        logEvent("tengu_external_editor_hint_shown", {});
+        addNotification({
+          key: "external-editor-hint",
+          jsx: <Text dimColor={true}><ConfigurableShortcutHint action="chat:externalEditor" context="Chat" fallback="ctrl+g" description={`edit in ${toIDEDisplayName(editor)}`} /></Text>,
+          priority: "immediate",
+          timeoutMs: 5000
+        });
+      } else {
+        removeNotification("external-editor-hint");
+      }
+    };
+    t10 = [shouldShowExternalEditorHint, editor, addNotification, removeNotification];
+    $[10] = addNotification;
+    $[11] = removeNotification;
+    $[12] = shouldShowExternalEditorHint;
+    $[13] = t10;
+    $[14] = t9;
+  } else {
+    t10 = $[13];
+    t9 = $[14];
+  }
+  useEffect(t9, t10);
+  const t11 = isNarrow ? "flex-start" : "flex-end";
+  const t12 = isInOverageMode ?? false;
+  let t13;
+  if ($[15] !== apiKeyStatus || $[16] !== autoUpdaterResult || $[17] !== debug || $[18] !== ideSelection || $[19] !== isAutoUpdating || $[20] !== isShowingCompactMessage || $[21] !== mainLoopModel || $[22] !== mcpClients || $[23] !== notifications || $[24] !== onAutoUpdaterResult || $[25] !== onChangeIsUpdating || $[26] !== shouldShowAutoUpdater || $[27] !== t12 || $[28] !== tokenUsage || $[29] !== verbose) {
+    t13 = <NotificationContent ideSelection={ideSelection} mcpClients={mcpClients} notifications={notifications} isInOverageMode={t12} isTeamOrEnterprise={isTeamOrEnterprise} apiKeyStatus={apiKeyStatus} debug={debug} verbose={verbose} tokenUsage={tokenUsage} mainLoopModel={mainLoopModel} shouldShowAutoUpdater={shouldShowAutoUpdater} autoUpdaterResult={autoUpdaterResult} isAutoUpdating={isAutoUpdating} isShowingCompactMessage={isShowingCompactMessage} onAutoUpdaterResult={onAutoUpdaterResult} onChangeIsUpdating={onChangeIsUpdating} />;
+    $[15] = apiKeyStatus;
+    $[16] = autoUpdaterResult;
+    $[17] = debug;
+    $[18] = ideSelection;
+    $[19] = isAutoUpdating;
+    $[20] = isShowingCompactMessage;
+    $[21] = mainLoopModel;
+    $[22] = mcpClients;
+    $[23] = notifications;
+    $[24] = onAutoUpdaterResult;
+    $[25] = onChangeIsUpdating;
+    $[26] = shouldShowAutoUpdater;
+    $[27] = t12;
+    $[28] = tokenUsage;
+    $[29] = verbose;
+    $[30] = t13;
+  } else {
+    t13 = $[30];
+  }
+  let t14;
+  if ($[31] !== t11 || $[32] !== t13) {
+    t14 = <SentryErrorBoundary><Box flexDirection="column" alignItems={t11} flexShrink={0} overflowX="hidden">{t13}</Box></SentryErrorBoundary>;
+    $[31] = t11;
+    $[32] = t13;
+    $[33] = t14;
+  } else {
+    t14 = $[33];
+  }
+  return t14;
+}
+function _temp2() {
+  return setEnvHookNotifier(null);
+}
+function _temp(s) {
+  return s.notifications;
+}
+function NotificationContent({
+  ideSelection,
+  mcpClients,
+  notifications,
+  isInOverageMode,
+  isTeamOrEnterprise,
+  apiKeyStatus,
+  debug,
+  verbose,
+  tokenUsage,
+  mainLoopModel,
+  shouldShowAutoUpdater,
+  autoUpdaterResult,
+  isAutoUpdating,
+  isShowingCompactMessage,
+  onAutoUpdaterResult,
+  onChangeIsUpdating
+}: {
+  ideSelection: IDESelection | undefined;
+  mcpClients?: MCPServerConnection[];
+  notifications: {
+    current: Notification | null;
+    queue: Notification[];
+  };
+  isInOverageMode: boolean;
+  isTeamOrEnterprise: boolean;
+  apiKeyStatus: VerificationStatus;
+  debug: boolean;
+  verbose: boolean;
+  tokenUsage: number;
+  mainLoopModel: string;
+  shouldShowAutoUpdater: boolean;
+  autoUpdaterResult: AutoUpdaterResult | null;
+  isAutoUpdating: boolean;
+  isShowingCompactMessage: boolean;
+  onAutoUpdaterResult: (result: AutoUpdaterResult) => void;
+  onChangeIsUpdating: (isUpdating: boolean) => void;
+}): ReactNode {
+  // Poll apiKeyHelper inflight state to show slow-helper notice.
+  // Gated on configuration — most users never set apiKeyHelper, so the
+  // effect is a no-op for them (no interval allocated).
+  const [apiKeyHelperSlow, setApiKeyHelperSlow] = useState<string | null>(null);
+  useEffect(() => {
+    if (!getConfiguredApiKeyHelper()) return;
+    const interval = setInterval((setSlow: React.Dispatch<React.SetStateAction<string | null>>) => {
+      const ms = getApiKeyHelperElapsedMs();
+      const next = ms >= 10_000 ? formatDuration(ms) : null;
+      setSlow(prev => next === prev ? prev : next);
+    }, 1000, setApiKeyHelperSlow);
+    return () => clearInterval(interval);
+  }, []);
+
+  // Voice state (VOICE_MODE builds only, runtime-gated by GrowthBook)
+  const voiceState = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useVoiceState(s => s.voiceState) : 'idle' as const;
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false;
+  const voiceError = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useVoiceState(s_0 => s_0.voiceError) : null;
+  const isBriefOnly = feature('KAIROS') || feature('KAIROS_BRIEF') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useAppState(s_1 => s_1.isBriefOnly) : false;
+
+  // When voice is actively recording or processing, replace all
+  // notifications with just the voice indicator.
+  if (feature('VOICE_MODE') && voiceEnabled && (voiceState === 'recording' || voiceState === 'processing')) {
+    return <VoiceIndicator voiceState={voiceState} />;
+  }
+  return <>
+      <IdeStatusIndicator ideSelection={ideSelection} mcpClients={mcpClients} />
+      {notifications.current && ('jsx' in notifications.current ? <Text wrap="truncate" key={notifications.current.key}>
+            {notifications.current.jsx}
+          </Text> : <Text color={notifications.current.color} dimColor={!notifications.current.color} wrap="truncate">
+            {notifications.current.text}
+          </Text>)}
+      {isInOverageMode && !isTeamOrEnterprise && <Box>
+          <Text dimColor wrap="truncate">
+            Now using extra usage
+          </Text>
+        </Box>}
+      {apiKeyHelperSlow && <Box>
+          <Text color="warning" wrap="truncate">
+            apiKeyHelper is taking a while{' '}
+          </Text>
+          <Text dimColor wrap="truncate">
+            ({apiKeyHelperSlow})
+          </Text>
+        </Box>}
+      {(apiKeyStatus === 'invalid' || apiKeyStatus === 'missing') && <Box>
+          <Text color="error" wrap="truncate">
+            {isEnvTruthy(process.env.CLAUDE_CODE_REMOTE) ? 'Authentication error · Try again' : 'Not logged in · Run /login'}
+          </Text>
+        </Box>}
+      {debug && <Box>
+          <Text color="warning" wrap="truncate">
+            Debug mode
+          </Text>
+        </Box>}
+      {apiKeyStatus !== 'invalid' && apiKeyStatus !== 'missing' && verbose && <Box>
+          <Text dimColor wrap="truncate">
+            {tokenUsage} tokens
+          </Text>
+        </Box>}
+      {!isBriefOnly && <TokenWarning tokenUsage={tokenUsage} model={mainLoopModel} />}
+      {shouldShowAutoUpdater && <AutoUpdaterWrapper verbose={verbose} onAutoUpdaterResult={onAutoUpdaterResult} autoUpdaterResult={autoUpdaterResult} isUpdating={isAutoUpdating} onChangeIsUpdating={onChangeIsUpdating} showSuccessMessage={!isShowingCompactMessage} />}
+      {feature('VOICE_MODE') ? voiceEnabled && voiceError && <Box>
+              <Text color="error" wrap="truncate">
+                {voiceError}
+              </Text>
+            </Box> : null}
+      <MemoryUsageIndicator />
+      <SandboxPromptFooterHint />
+    </>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","ReactNode","useEffect","useMemo","useState","Notification","useNotifications","logEvent","useAppState","useVoiceState","VerificationStatus","useIdeConnectionStatus","IDESelection","useMainLoopModel","useVoiceEnabled","Box","Text","useClaudeAiLimits","calculateTokenWarningState","MCPServerConnection","Message","getApiKeyHelperElapsedMs","getConfiguredApiKeyHelper","getSubscriptionType","AutoUpdaterResult","getExternalEditor","isEnvTruthy","formatDuration","setEnvHookNotifier","toIDEDisplayName","getMessagesAfterCompactBoundary","tokenCountFromLastAPIResponse","AutoUpdaterWrapper","ConfigurableShortcutHint","IdeStatusIndicator","MemoryUsageIndicator","SentryErrorBoundary","TokenWarning","SandboxPromptFooterHint","VoiceIndicator","require","FOOTER_TEMPORARY_STATUS_TIMEOUT","Props","apiKeyStatus","autoUpdaterResult","isAutoUpdating","debug","verbose","messages","onAutoUpdaterResult","result","onChangeIsUpdating","isUpdating","ideSelection","mcpClients","isInputWrapped","isNarrow","Notifications","t0","$","_c","t1","t2","undefined","t3","messagesForTokenCount","tokenUsage","mainLoopModel","t4","isShowingCompactMessage","isAboveWarningThreshold","status","ideStatus","notifications","_temp","addNotification","removeNotification","claudeAiLimits","t5","t6","text","isError","key","color","priority","timeoutMs","_temp2","shouldShowIdeSelection","filePath","lineCount","shouldShowAutoUpdater","isInOverageMode","isUsingOverage","t7","Symbol","for","subscriptionType","isTeamOrEnterprise","t8","editor","shouldShowExternalEditorHint","t10","t9","jsx","t11","t12","t13","t14","s","NotificationContent","current","queue","apiKeyHelperSlow","setApiKeyHelperSlow","interval","setInterval","setSlow","Dispatch","SetStateAction","ms","next","prev","clearInterval","voiceState","const","voiceEnabled","voiceError","isBriefOnly","process","env","CLAUDE_CODE_REMOTE"],"sources":["Notifications.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport { type ReactNode, useEffect, useMemo, useState } from 'react'\nimport {\n  type Notification,\n  useNotifications,\n} from 'src/context/notifications.js'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport { useAppState } from 'src/state/AppState.js'\nimport { useVoiceState } from '../../context/voice.js'\nimport type { VerificationStatus } from '../../hooks/useApiKeyVerification.js'\nimport { useIdeConnectionStatus } from '../../hooks/useIdeConnectionStatus.js'\nimport type { IDESelection } from '../../hooks/useIdeSelection.js'\nimport { useMainLoopModel } from '../../hooks/useMainLoopModel.js'\nimport { useVoiceEnabled } from '../../hooks/useVoiceEnabled.js'\nimport { Box, Text } from '../../ink.js'\nimport { useClaudeAiLimits } from '../../services/claudeAiLimitsHook.js'\nimport { calculateTokenWarningState } from '../../services/compact/autoCompact.js'\nimport type { MCPServerConnection } from '../../services/mcp/types.js'\nimport type { Message } from '../../types/message.js'\nimport {\n  getApiKeyHelperElapsedMs,\n  getConfiguredApiKeyHelper,\n  getSubscriptionType,\n} from '../../utils/auth.js'\nimport type { AutoUpdaterResult } from '../../utils/autoUpdater.js'\nimport { getExternalEditor } from '../../utils/editor.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport { formatDuration } from '../../utils/format.js'\nimport { setEnvHookNotifier } from '../../utils/hooks/fileChangedWatcher.js'\nimport { toIDEDisplayName } from '../../utils/ide.js'\nimport { getMessagesAfterCompactBoundary } from '../../utils/messages.js'\nimport { tokenCountFromLastAPIResponse } from '../../utils/tokens.js'\nimport { AutoUpdaterWrapper } from '../AutoUpdaterWrapper.js'\nimport { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'\nimport { IdeStatusIndicator } from '../IdeStatusIndicator.js'\nimport { MemoryUsageIndicator } from '../MemoryUsageIndicator.js'\nimport { SentryErrorBoundary } from '../SentryErrorBoundary.js'\nimport { TokenWarning } from '../TokenWarning.js'\nimport { SandboxPromptFooterHint } from './SandboxPromptFooterHint.js'\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst VoiceIndicator: typeof import('./VoiceIndicator.js').VoiceIndicator =\n  feature('VOICE_MODE')\n    ? require('./VoiceIndicator.js').VoiceIndicator\n    : () => null\n/* eslint-enable @typescript-eslint/no-require-imports */\n\nexport const FOOTER_TEMPORARY_STATUS_TIMEOUT = 5000\n\ntype Props = {\n  apiKeyStatus: VerificationStatus\n  autoUpdaterResult: AutoUpdaterResult | null\n  isAutoUpdating: boolean\n  debug: boolean\n  verbose: boolean\n  messages: Message[]\n  onAutoUpdaterResult: (result: AutoUpdaterResult) => void\n  onChangeIsUpdating: (isUpdating: boolean) => void\n  ideSelection: IDESelection | undefined\n  mcpClients?: MCPServerConnection[]\n  isInputWrapped?: boolean\n  isNarrow?: boolean\n}\n\nexport function Notifications({\n  apiKeyStatus,\n  autoUpdaterResult,\n  debug,\n  isAutoUpdating,\n  verbose,\n  messages,\n  onAutoUpdaterResult,\n  onChangeIsUpdating,\n  ideSelection,\n  mcpClients,\n  isInputWrapped = false,\n  isNarrow = false,\n}: Props): ReactNode {\n  const tokenUsage = useMemo(() => {\n    const messagesForTokenCount = getMessagesAfterCompactBoundary(messages)\n    return tokenCountFromLastAPIResponse(messagesForTokenCount)\n  }, [messages])\n\n  // AppState-sourced model — same source as API requests. getMainLoopModel()\n  // re-reads settings.json on every call, so another session's /model write\n  // would leak into this session's display (anthropics/claude-code#37596).\n  const mainLoopModel = useMainLoopModel()\n  const isShowingCompactMessage = calculateTokenWarningState(\n    tokenUsage,\n    mainLoopModel,\n  ).isAboveWarningThreshold\n  const { status: ideStatus } = useIdeConnectionStatus(mcpClients)\n  const notifications = useAppState(s => s.notifications)\n  const { addNotification, removeNotification } = useNotifications()\n  const claudeAiLimits = useClaudeAiLimits()\n\n  // Register env hook notifier for CwdChanged/FileChanged feedback\n  useEffect(() => {\n    setEnvHookNotifier((text, isError) => {\n      addNotification({\n        key: 'env-hook',\n        text,\n        color: isError ? 'error' : undefined,\n        priority: isError ? 'medium' : 'low',\n        timeoutMs: isError ? 8000 : 5000,\n      })\n    })\n    return () => setEnvHookNotifier(null)\n  }, [addNotification])\n\n  // Check if we should show the IDE selection indicator\n  const shouldShowIdeSelection =\n    ideStatus === 'connected' &&\n    (ideSelection?.filePath ||\n      (ideSelection?.text && ideSelection.lineCount > 0))\n\n  // Hide update installed message when showing IDE selection\n  const shouldShowAutoUpdater =\n    !shouldShowIdeSelection ||\n    isAutoUpdating ||\n    autoUpdaterResult?.status !== 'success'\n\n  // Check if we're in overage mode for UI indicators\n  const isInOverageMode = claudeAiLimits.isUsingOverage\n  const subscriptionType = getSubscriptionType()\n  const isTeamOrEnterprise =\n    subscriptionType === 'team' || subscriptionType === 'enterprise'\n\n  // Check if the external editor hint should be shown\n  const editor = getExternalEditor()\n  const shouldShowExternalEditorHint =\n    isInputWrapped &&\n    !isShowingCompactMessage &&\n    apiKeyStatus !== 'invalid' &&\n    apiKeyStatus !== 'missing' &&\n    editor !== undefined\n\n  // Show external editor hint as notification when input is wrapped\n  useEffect(() => {\n    if (shouldShowExternalEditorHint && editor) {\n      logEvent('tengu_external_editor_hint_shown', {})\n      addNotification({\n        key: 'external-editor-hint',\n        jsx: (\n          <Text dimColor>\n            <ConfigurableShortcutHint\n              action=\"chat:externalEditor\"\n              context=\"Chat\"\n              fallback=\"ctrl+g\"\n              description={`edit in ${toIDEDisplayName(editor)}`}\n            />\n          </Text>\n        ),\n        priority: 'immediate',\n        timeoutMs: 5000,\n      })\n    } else {\n      removeNotification('external-editor-hint')\n    }\n  }, [\n    shouldShowExternalEditorHint,\n    editor,\n    addNotification,\n    removeNotification,\n  ])\n\n  return (\n    <SentryErrorBoundary>\n      <Box\n        flexDirection=\"column\"\n        alignItems={isNarrow ? 'flex-start' : 'flex-end'}\n        flexShrink={0}\n        overflowX=\"hidden\"\n      >\n        <NotificationContent\n          ideSelection={ideSelection}\n          mcpClients={mcpClients}\n          notifications={notifications}\n          isInOverageMode={isInOverageMode ?? false}\n          isTeamOrEnterprise={isTeamOrEnterprise}\n          apiKeyStatus={apiKeyStatus}\n          debug={debug}\n          verbose={verbose}\n          tokenUsage={tokenUsage}\n          mainLoopModel={mainLoopModel}\n          shouldShowAutoUpdater={shouldShowAutoUpdater}\n          autoUpdaterResult={autoUpdaterResult}\n          isAutoUpdating={isAutoUpdating}\n          isShowingCompactMessage={isShowingCompactMessage}\n          onAutoUpdaterResult={onAutoUpdaterResult}\n          onChangeIsUpdating={onChangeIsUpdating}\n        />\n      </Box>\n    </SentryErrorBoundary>\n  )\n}\n\nfunction NotificationContent({\n  ideSelection,\n  mcpClients,\n  notifications,\n  isInOverageMode,\n  isTeamOrEnterprise,\n  apiKeyStatus,\n  debug,\n  verbose,\n  tokenUsage,\n  mainLoopModel,\n  shouldShowAutoUpdater,\n  autoUpdaterResult,\n  isAutoUpdating,\n  isShowingCompactMessage,\n  onAutoUpdaterResult,\n  onChangeIsUpdating,\n}: {\n  ideSelection: IDESelection | undefined\n  mcpClients?: MCPServerConnection[]\n  notifications: {\n    current: Notification | null\n    queue: Notification[]\n  }\n  isInOverageMode: boolean\n  isTeamOrEnterprise: boolean\n  apiKeyStatus: VerificationStatus\n  debug: boolean\n  verbose: boolean\n  tokenUsage: number\n  mainLoopModel: string\n  shouldShowAutoUpdater: boolean\n  autoUpdaterResult: AutoUpdaterResult | null\n  isAutoUpdating: boolean\n  isShowingCompactMessage: boolean\n  onAutoUpdaterResult: (result: AutoUpdaterResult) => void\n  onChangeIsUpdating: (isUpdating: boolean) => void\n}): ReactNode {\n  // Poll apiKeyHelper inflight state to show slow-helper notice.\n  // Gated on configuration — most users never set apiKeyHelper, so the\n  // effect is a no-op for them (no interval allocated).\n  const [apiKeyHelperSlow, setApiKeyHelperSlow] = useState<string | null>(null)\n  useEffect(() => {\n    if (!getConfiguredApiKeyHelper()) return\n    const interval = setInterval(\n      (setSlow: React.Dispatch<React.SetStateAction<string | null>>) => {\n        const ms = getApiKeyHelperElapsedMs()\n        const next = ms >= 10_000 ? formatDuration(ms) : null\n        setSlow(prev => (next === prev ? prev : next))\n      },\n      1000,\n      setApiKeyHelperSlow,\n    )\n    return () => clearInterval(interval)\n  }, [])\n\n  // Voice state (VOICE_MODE builds only, runtime-gated by GrowthBook)\n  const voiceState = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceState)\n    : ('idle' as const)\n  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n  const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false\n  const voiceError = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceError)\n    : null\n  const isBriefOnly =\n    feature('KAIROS') || feature('KAIROS_BRIEF')\n      ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n        useAppState(s => s.isBriefOnly)\n      : false\n\n  // When voice is actively recording or processing, replace all\n  // notifications with just the voice indicator.\n  if (\n    feature('VOICE_MODE') &&\n    voiceEnabled &&\n    (voiceState === 'recording' || voiceState === 'processing')\n  ) {\n    return <VoiceIndicator voiceState={voiceState} />\n  }\n\n  return (\n    <>\n      <IdeStatusIndicator ideSelection={ideSelection} mcpClients={mcpClients} />\n      {notifications.current &&\n        ('jsx' in notifications.current ? (\n          <Text wrap=\"truncate\" key={notifications.current.key}>\n            {notifications.current.jsx}\n          </Text>\n        ) : (\n          <Text\n            color={notifications.current.color}\n            dimColor={!notifications.current.color}\n            wrap=\"truncate\"\n          >\n            {notifications.current.text}\n          </Text>\n        ))}\n      {isInOverageMode && !isTeamOrEnterprise && (\n        <Box>\n          <Text dimColor wrap=\"truncate\">\n            Now using extra usage\n          </Text>\n        </Box>\n      )}\n      {apiKeyHelperSlow && (\n        <Box>\n          <Text color=\"warning\" wrap=\"truncate\">\n            apiKeyHelper is taking a while{' '}\n          </Text>\n          <Text dimColor wrap=\"truncate\">\n            ({apiKeyHelperSlow})\n          </Text>\n        </Box>\n      )}\n      {(apiKeyStatus === 'invalid' || apiKeyStatus === 'missing') && (\n        <Box>\n          <Text color=\"error\" wrap=\"truncate\">\n            {isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)\n              ? 'Authentication error · Try again'\n              : 'Not logged in · Run /login'}\n          </Text>\n        </Box>\n      )}\n      {debug && (\n        <Box>\n          <Text color=\"warning\" wrap=\"truncate\">\n            Debug mode\n          </Text>\n        </Box>\n      )}\n      {apiKeyStatus !== 'invalid' && apiKeyStatus !== 'missing' && verbose && (\n        <Box>\n          <Text dimColor wrap=\"truncate\">\n            {tokenUsage} tokens\n          </Text>\n        </Box>\n      )}\n      {!isBriefOnly && (\n        <TokenWarning tokenUsage={tokenUsage} model={mainLoopModel} />\n      )}\n      {shouldShowAutoUpdater && (\n        <AutoUpdaterWrapper\n          verbose={verbose}\n          onAutoUpdaterResult={onAutoUpdaterResult}\n          autoUpdaterResult={autoUpdaterResult}\n          isUpdating={isAutoUpdating}\n          onChangeIsUpdating={onChangeIsUpdating}\n          showSuccessMessage={!isShowingCompactMessage}\n        />\n      )}\n      {feature('VOICE_MODE')\n        ? voiceEnabled &&\n          voiceError && (\n            <Box>\n              <Text color=\"error\" wrap=\"truncate\">\n                {voiceError}\n              </Text>\n            </Box>\n          )\n        : null}\n      <MemoryUsageIndicator />\n      <SandboxPromptFooterHint />\n    </>\n  )\n}\n"],"mappings":"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","ignoreList":[]}