@xortex/xcode 3.0.0 → 3.0.2

package/components/CustomSelect/use-select-state.ts

@@ -0,0 +1,157 @@
+import { useCallback, useState } from 'react'
+import type { OptionWithDescription } from './select.js'
+import { useSelectNavigation } from './use-select-navigation.js'
+
+export type UseSelectStateProps<T> = {
+  /**
+   * Number of items to display.
+   *
+   * @default 5
+   */
+  visibleOptionCount?: number
+
+  /**
+   * Options.
+   */
+  options: OptionWithDescription<T>[]
+
+  /**
+   * Initially selected option's value.
+   */
+  defaultValue?: T
+
+  /**
+   * Callback for selecting an option.
+   */
+  onChange?: (value: T) => void
+
+  /**
+   * Callback for canceling the select.
+   */
+  onCancel?: () => void
+
+  /**
+   * Callback for focusing an option.
+   */
+  onFocus?: (value: T) => void
+
+  /**
+   * Value to focus
+   */
+  focusValue?: T
+}
+
+export type SelectState<T> = {
+  /**
+   * Value of the currently focused option.
+   */
+  focusedValue: T | undefined
+
+  /**
+   * 1-based index of the focused option in the full list.
+   * Returns 0 if no option is focused.
+   */
+  focusedIndex: number
+
+  /**
+   * Index of the first visible option.
+   */
+  visibleFromIndex: number
+
+  /**
+   * Index of the last visible option.
+   */
+  visibleToIndex: number
+
+  /**
+   * Value of the selected option.
+   */
+  value: T | undefined
+
+  /**
+   * All options.
+   */
+  options: OptionWithDescription<T>[]
+
+  /**
+   * Visible options.
+   */
+  visibleOptions: Array<OptionWithDescription<T> & { index: number }>
+
+  /**
+   * Whether the focused option is an input type.
+   */
+  isInInput: boolean
+
+  /**
+   * Focus next option and scroll the list down, if needed.
+   */
+  focusNextOption: () => void
+
+  /**
+   * Focus previous option and scroll the list up, if needed.
+   */
+  focusPreviousOption: () => void
+
+  /**
+   * Focus next page and scroll the list down by a page.
+   */
+  focusNextPage: () => void
+
+  /**
+   * Focus previous page and scroll the list up by a page.
+   */
+  focusPreviousPage: () => void
+
+  /**
+   * Focus a specific option by value.
+   */
+  focusOption: (value: T | undefined) => void
+
+  /**
+   * Select currently focused option.
+   */
+  selectFocusedOption: () => void
+
+  /**
+   * Callback for selecting an option.
+   */
+  onChange?: (value: T) => void
+
+  /**
+   * Callback for canceling the select.
+   */
+  onCancel?: () => void
+}
+
+export function useSelectState<T>({
+  visibleOptionCount = 5,
+  options,
+  defaultValue,
+  onChange,
+  onCancel,
+  onFocus,
+  focusValue,
+}: UseSelectStateProps<T>): SelectState<T> {
+  const [value, setValue] = useState<T | undefined>(defaultValue)
+
+  const navigation = useSelectNavigation<T>({
+    visibleOptionCount,
+    options,
+    initialFocusValue: undefined,
+    onFocus,
+    focusValue,
+  })
+
+  const selectFocusedOption = useCallback(() => {
+    setValue(navigation.focusedValue)
+  }, [navigation.focusedValue])
+
+  return {
+    ...navigation,
+    value,
+    selectFocusedOption,
+    onChange,
+    onCancel,
+  }
+}

package/components/DesktopHandoff.tsx

@@ -0,0 +1,193 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useEffect, useState } from 'react';
+import type { CommandResultDisplay } from '../commands.js';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw input for "any key" dismiss and y/n prompt
+import { Box, Text, useInput } from '../ink.js';
+import { openBrowser } from '../utils/browser.js';
+import { getDesktopInstallStatus, openCurrentSessionInDesktop } from '../utils/desktopDeepLink.js';
+import { errorMessage } from '../utils/errors.js';
+import { gracefulShutdown } from '../utils/gracefulShutdown.js';
+import { flushSessionStorage } from '../utils/sessionStorage.js';
+import { LoadingState } from './design-system/LoadingState.js';
+const DESKTOP_DOCS_URL = 'https://clau.de/desktop';
+export function getDownloadUrl(): string {
+  switch (process.platform) {
+    case 'win32':
+      return 'https://claude.ai/api/desktop/win32/x64/exe/latest/redirect';
+    default:
+      return 'https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect';
+  }
+}
+type DesktopHandoffState = 'checking' | 'prompt-download' | 'flushing' | 'opening' | 'success' | 'error';
+type Props = {
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+};
+export function DesktopHandoff(t0) {
+  const $ = _c(20);
+  const {
+    onDone
+  } = t0;
+  const [state, setState] = useState("checking");
+  const [error, setError] = useState(null);
+  const [downloadMessage, setDownloadMessage] = useState("");
+  let t1;
+  if ($[0] !== error || $[1] !== onDone || $[2] !== state) {
+    t1 = input => {
+      if (state === "error") {
+        onDone(error ?? "Unknown error", {
+          display: "system"
+        });
+        return;
+      }
+      if (state === "prompt-download") {
+        if (input === "y" || input === "Y") {
+          openBrowser(getDownloadUrl()).catch(_temp);
+          onDone(`Starting download. Re-run /desktop once you\u2019ve installed the app.\nLearn more at ${DESKTOP_DOCS_URL}`, {
+            display: "system"
+          });
+        } else {
+          if (input === "n" || input === "N") {
+            onDone(`The desktop app is required for /desktop. Learn more at ${DESKTOP_DOCS_URL}`, {
+              display: "system"
+            });
+          }
+        }
+      }
+    };
+    $[0] = error;
+    $[1] = onDone;
+    $[2] = state;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  useInput(t1);
+  let t2;
+  let t3;
+  if ($[4] !== onDone) {
+    t2 = () => {
+      const performHandoff = async function performHandoff() {
+        setState("checking");
+        const installStatus = await getDesktopInstallStatus();
+        if (installStatus.status === "not-installed") {
+          setDownloadMessage("Claude Desktop is not installed.");
+          setState("prompt-download");
+          return;
+        }
+        if (installStatus.status === "version-too-old") {
+          setDownloadMessage(`Claude Desktop needs to be updated (found v${installStatus.version}, need v1.1.2396+).`);
+          setState("prompt-download");
+          return;
+        }
+        setState("flushing");
+        await flushSessionStorage();
+        setState("opening");
+        const result = await openCurrentSessionInDesktop();
+        if (!result.success) {
+          setError(result.error ?? "Failed to open Claude Desktop");
+          setState("error");
+          return;
+        }
+        setState("success");
+        setTimeout(_temp2, 500, onDone);
+      };
+      performHandoff().catch(err => {
+        setError(errorMessage(err));
+        setState("error");
+      });
+    };
+    t3 = [onDone];
+    $[4] = onDone;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t2 = $[5];
+    t3 = $[6];
+  }
+  useEffect(t2, t3);
+  if (state === "error") {
+    let t4;
+    if ($[7] !== error) {
+      t4 = <Text color="error">Error: {error}</Text>;
+      $[7] = error;
+      $[8] = t4;
+    } else {
+      t4 = $[8];
+    }
+    let t5;
+    if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+      t5 = <Text dimColor={true}>Press any key to continue…</Text>;
+      $[9] = t5;
+    } else {
+      t5 = $[9];
+    }
+    let t6;
+    if ($[10] !== t4) {
+      t6 = <Box flexDirection="column" paddingX={2}>{t4}{t5}</Box>;
+      $[10] = t4;
+      $[11] = t6;
+    } else {
+      t6 = $[11];
+    }
+    return t6;
+  }
+  if (state === "prompt-download") {
+    let t4;
+    if ($[12] !== downloadMessage) {
+      t4 = <Text>{downloadMessage}</Text>;
+      $[12] = downloadMessage;
+      $[13] = t4;
+    } else {
+      t4 = $[13];
+    }
+    let t5;
+    if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+      t5 = <Text>Download now? (y/n)</Text>;
+      $[14] = t5;
+    } else {
+      t5 = $[14];
+    }
+    let t6;
+    if ($[15] !== t4) {
+      t6 = <Box flexDirection="column" paddingX={2}>{t4}{t5}</Box>;
+      $[15] = t4;
+      $[16] = t6;
+    } else {
+      t6 = $[16];
+    }
+    return t6;
+  }
+  let t4;
+  if ($[17] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = {
+      checking: "Checking for Claude Desktop\u2026",
+      flushing: "Saving session\u2026",
+      opening: "Opening Claude Desktop\u2026",
+      success: "Opening in Claude Desktop\u2026"
+    };
+    $[17] = t4;
+  } else {
+    t4 = $[17];
+  }
+  const messages = t4;
+  const t5 = messages[state];
+  let t6;
+  if ($[18] !== t5) {
+    t6 = <LoadingState message={t5} />;
+    $[18] = t5;
+    $[19] = t6;
+  } else {
+    t6 = $[19];
+  }
+  return t6;
+}
+async function _temp2(onDone_0) {
+  onDone_0("Session transferred to Claude Desktop", {
+    display: "system"
+  });
+  await gracefulShutdown(0, "other");
+}
+function _temp() {}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useState","CommandResultDisplay","Box","Text","useInput","openBrowser","getDesktopInstallStatus","openCurrentSessionInDesktop","errorMessage","gracefulShutdown","flushSessionStorage","LoadingState","DESKTOP_DOCS_URL","getDownloadUrl","process","platform","DesktopHandoffState","Props","onDone","result","options","display","DesktopHandoff","t0","$","_c","state","setState","error","setError","downloadMessage","setDownloadMessage","t1","input","catch","_temp","t2","t3","performHandoff","installStatus","status","version","success","setTimeout","_temp2","err","t4","t5","Symbol","for","t6","checking","flushing","opening","messages","onDone_0"],"sources":["DesktopHandoff.tsx"],"sourcesContent":["import React, { useEffect, useState } from 'react'\nimport type { CommandResultDisplay } from '../commands.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw input for \"any key\" dismiss and y/n prompt\nimport { Box, Text, useInput } from '../ink.js'\nimport { openBrowser } from '../utils/browser.js'\nimport {\n  getDesktopInstallStatus,\n  openCurrentSessionInDesktop,\n} from '../utils/desktopDeepLink.js'\nimport { errorMessage } from '../utils/errors.js'\nimport { gracefulShutdown } from '../utils/gracefulShutdown.js'\nimport { flushSessionStorage } from '../utils/sessionStorage.js'\nimport { LoadingState } from './design-system/LoadingState.js'\n\nconst DESKTOP_DOCS_URL = 'https://clau.de/desktop'\n\nexport function getDownloadUrl(): string {\n  switch (process.platform) {\n    case 'win32':\n      return 'https://claude.ai/api/desktop/win32/x64/exe/latest/redirect'\n    default:\n      return 'https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect'\n  }\n}\n\ntype DesktopHandoffState =\n  | 'checking'\n  | 'prompt-download'\n  | 'flushing'\n  | 'opening'\n  | 'success'\n  | 'error'\n\ntype Props = {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}\n\nexport function DesktopHandoff({ onDone }: Props): React.ReactNode {\n  const [state, setState] = useState<DesktopHandoffState>('checking')\n  const [error, setError] = useState<string | null>(null)\n  const [downloadMessage, setDownloadMessage] = useState<string>('')\n\n  // Handle keyboard input for error and prompt-download states\n  useInput(input => {\n    if (state === 'error') {\n      onDone(error ?? 'Unknown error', { display: 'system' })\n      return\n    }\n    if (state === 'prompt-download') {\n      if (input === 'y' || input === 'Y') {\n        openBrowser(getDownloadUrl()).catch(() => {})\n        onDone(\n          `Starting download. Re-run /desktop once you\\u2019ve installed the app.\\nLearn more at ${DESKTOP_DOCS_URL}`,\n          { display: 'system' },\n        )\n      } else if (input === 'n' || input === 'N') {\n        onDone(\n          `The desktop app is required for /desktop. Learn more at ${DESKTOP_DOCS_URL}`,\n          { display: 'system' },\n        )\n      }\n    }\n  })\n\n  useEffect(() => {\n    async function performHandoff(): Promise<void> {\n      // Check Desktop install status\n      setState('checking')\n      const installStatus = await getDesktopInstallStatus()\n\n      if (installStatus.status === 'not-installed') {\n        setDownloadMessage('Claude Desktop is not installed.')\n        setState('prompt-download')\n        return\n      }\n\n      if (installStatus.status === 'version-too-old') {\n        setDownloadMessage(\n          `Claude Desktop needs to be updated (found v${installStatus.version}, need v1.1.2396+).`,\n        )\n        setState('prompt-download')\n        return\n      }\n\n      // Flush session storage to ensure transcript is fully written\n      setState('flushing')\n      await flushSessionStorage()\n\n      // Open the deep link (uses claude-dev:// in dev mode)\n      setState('opening')\n      const result = await openCurrentSessionInDesktop()\n\n      if (!result.success) {\n        setError(result.error ?? 'Failed to open Claude Desktop')\n        setState('error')\n        return\n      }\n\n      // Success - exit the CLI\n      setState('success')\n\n      // Give the user a moment to see the success message\n      setTimeout(\n        async (onDone: Props['onDone']) => {\n          onDone('Session transferred to Claude Desktop', { display: 'system' })\n          await gracefulShutdown(0, 'other')\n        },\n        500,\n        onDone,\n      )\n    }\n\n    performHandoff().catch(err => {\n      setError(errorMessage(err))\n      setState('error')\n    })\n  }, [onDone])\n\n  if (state === 'error') {\n    return (\n      <Box flexDirection=\"column\" paddingX={2}>\n        <Text color=\"error\">Error: {error}</Text>\n        <Text dimColor>Press any key to continue…</Text>\n      </Box>\n    )\n  }\n\n  if (state === 'prompt-download') {\n    return (\n      <Box flexDirection=\"column\" paddingX={2}>\n        <Text>{downloadMessage}</Text>\n        <Text>Download now? (y/n)</Text>\n      </Box>\n    )\n  }\n\n  const messages: Record<\n    Exclude<DesktopHandoffState, 'error' | 'prompt-download'>,\n    string\n  > = {\n    checking: 'Checking for Claude Desktop…',\n    flushing: 'Saving session…',\n    opening: 'Opening Claude Desktop…',\n    success: 'Opening in Claude Desktop…',\n  }\n\n  return <LoadingState message={messages[state]} />\n}\n"],"mappings":"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","ignoreList":[]}

package/components/DesktopUpsell/DesktopUpsellStartup.tsx

@@ -0,0 +1,171 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { Box, Text } from '../../ink.js';
+import { getDynamicConfig_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { Select } from '../CustomSelect/select.js';
+import { DesktopHandoff } from '../DesktopHandoff.js';
+import { PermissionDialog } from '../permissions/PermissionDialog.js';
+type DesktopUpsellConfig = {
+  enable_shortcut_tip: boolean;
+  enable_startup_dialog: boolean;
+};
+const DESKTOP_UPSELL_DEFAULT: DesktopUpsellConfig = {
+  enable_shortcut_tip: false,
+  enable_startup_dialog: false
+};
+export function getDesktopUpsellConfig(): DesktopUpsellConfig {
+  return getDynamicConfig_CACHED_MAY_BE_STALE('tengu_desktop_upsell', DESKTOP_UPSELL_DEFAULT);
+}
+function isSupportedPlatform(): boolean {
+  return process.platform === 'darwin' || process.platform === 'win32' && process.arch === 'x64';
+}
+export function shouldShowDesktopUpsellStartup(): boolean {
+  if (!isSupportedPlatform()) return false;
+  if (!getDesktopUpsellConfig().enable_startup_dialog) return false;
+  const config = getGlobalConfig();
+  if (config.desktopUpsellDismissed) return false;
+  if ((config.desktopUpsellSeenCount ?? 0) >= 3) return false;
+  return true;
+}
+type DesktopUpsellSelection = 'try' | 'not-now' | 'never';
+type Props = {
+  onDone: () => void;
+};
+export function DesktopUpsellStartup(t0) {
+  const $ = _c(14);
+  const {
+    onDone
+  } = t0;
+  const [showHandoff, setShowHandoff] = useState(false);
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = [];
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  useEffect(_temp, t1);
+  if (showHandoff) {
+    let t2;
+    if ($[1] !== onDone) {
+      t2 = <DesktopHandoff onDone={() => onDone()} />;
+      $[1] = onDone;
+      $[2] = t2;
+    } else {
+      t2 = $[2];
+    }
+    return t2;
+  }
+  let t2;
+  if ($[3] !== onDone) {
+    t2 = function handleSelect(value) {
+      switch (value) {
+        case "try":
+          {
+            setShowHandoff(true);
+            return;
+          }
+        case "never":
+          {
+            saveGlobalConfig(_temp2);
+            onDone();
+            return;
+          }
+        case "not-now":
+          {
+            onDone();
+            return;
+          }
+      }
+    };
+    $[3] = onDone;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const handleSelect = t2;
+  let t3;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = {
+      label: "Open in Claude Code Desktop",
+      value: "try" as const
+    };
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = {
+      label: "Not now",
+      value: "not-now" as const
+    };
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = [t3, t4, {
+      label: "Don't ask again",
+      value: "never" as const
+    }];
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  const options = t5;
+  let t6;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = <Box marginBottom={1}><Text>Same Claude Code with visual diffs, live app preview, parallel sessions, and more.</Text></Box>;
+    $[8] = t6;
+  } else {
+    t6 = $[8];
+  }
+  let t7;
+  if ($[9] !== handleSelect) {
+    t7 = () => handleSelect("not-now");
+    $[9] = handleSelect;
+    $[10] = t7;
+  } else {
+    t7 = $[10];
+  }
+  let t8;
+  if ($[11] !== handleSelect || $[12] !== t7) {
+    t8 = <PermissionDialog title="Try Claude Code Desktop"><Box flexDirection="column" paddingX={2} paddingY={1}>{t6}<Select options={options} onChange={handleSelect} onCancel={t7} /></Box></PermissionDialog>;
+    $[11] = handleSelect;
+    $[12] = t7;
+    $[13] = t8;
+  } else {
+    t8 = $[13];
+  }
+  return t8;
+}
+function _temp2(prev_0) {
+  if (prev_0.desktopUpsellDismissed) {
+    return prev_0;
+  }
+  return {
+    ...prev_0,
+    desktopUpsellDismissed: true
+  };
+}
+function _temp() {
+  const newCount = (getGlobalConfig().desktopUpsellSeenCount ?? 0) + 1;
+  saveGlobalConfig(prev => {
+    if ((prev.desktopUpsellSeenCount ?? 0) >= newCount) {
+      return prev;
+    }
+    return {
+      ...prev,
+      desktopUpsellSeenCount: newCount
+    };
+  });
+  logEvent("tengu_desktop_upsell_shown", {
+    seen_count: newCount
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useState","Box","Text","getDynamicConfig_CACHED_MAY_BE_STALE","logEvent","getGlobalConfig","saveGlobalConfig","Select","DesktopHandoff","PermissionDialog","DesktopUpsellConfig","enable_shortcut_tip","enable_startup_dialog","DESKTOP_UPSELL_DEFAULT","getDesktopUpsellConfig","isSupportedPlatform","process","platform","arch","shouldShowDesktopUpsellStartup","config","desktopUpsellDismissed","desktopUpsellSeenCount","DesktopUpsellSelection","Props","onDone","DesktopUpsellStartup","t0","$","_c","showHandoff","setShowHandoff","t1","Symbol","for","_temp","t2","handleSelect","value","_temp2","t3","label","const","t4","t5","options","t6","t7","t8","prev_0","prev","newCount","seen_count"],"sources":["DesktopUpsellStartup.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { Box, Text } from '../../ink.js'\nimport { getDynamicConfig_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'\nimport { logEvent } from '../../services/analytics/index.js'\nimport { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'\nimport { Select } from '../CustomSelect/select.js'\nimport { DesktopHandoff } from '../DesktopHandoff.js'\nimport { PermissionDialog } from '../permissions/PermissionDialog.js'\n\ntype DesktopUpsellConfig = {\n  enable_shortcut_tip: boolean\n  enable_startup_dialog: boolean\n}\n\nconst DESKTOP_UPSELL_DEFAULT: DesktopUpsellConfig = {\n  enable_shortcut_tip: false,\n  enable_startup_dialog: false,\n}\n\nexport function getDesktopUpsellConfig(): DesktopUpsellConfig {\n  return getDynamicConfig_CACHED_MAY_BE_STALE(\n    'tengu_desktop_upsell',\n    DESKTOP_UPSELL_DEFAULT,\n  )\n}\n\nfunction isSupportedPlatform(): boolean {\n  return (\n    process.platform === 'darwin' ||\n    (process.platform === 'win32' && process.arch === 'x64')\n  )\n}\n\nexport function shouldShowDesktopUpsellStartup(): boolean {\n  if (!isSupportedPlatform()) return false\n  if (!getDesktopUpsellConfig().enable_startup_dialog) return false\n  const config = getGlobalConfig()\n  if (config.desktopUpsellDismissed) return false\n  if ((config.desktopUpsellSeenCount ?? 0) >= 3) return false\n  return true\n}\n\ntype DesktopUpsellSelection = 'try' | 'not-now' | 'never'\n\ntype Props = {\n  onDone: () => void\n}\n\nexport function DesktopUpsellStartup({ onDone }: Props): React.ReactNode {\n  const [showHandoff, setShowHandoff] = useState(false)\n\n  // Increment seen count on mount (guard in updater for StrictMode safety)\n  useEffect(() => {\n    const newCount = (getGlobalConfig().desktopUpsellSeenCount ?? 0) + 1\n    saveGlobalConfig(prev => {\n      if ((prev.desktopUpsellSeenCount ?? 0) >= newCount) return prev\n      return { ...prev, desktopUpsellSeenCount: newCount }\n    })\n    logEvent('tengu_desktop_upsell_shown', { seen_count: newCount })\n  }, [])\n\n  if (showHandoff) {\n    return <DesktopHandoff onDone={() => onDone()} />\n  }\n\n  function handleSelect(value: DesktopUpsellSelection): void {\n    switch (value) {\n      case 'try':\n        setShowHandoff(true)\n        return\n      case 'never':\n        saveGlobalConfig(prev => {\n          if (prev.desktopUpsellDismissed) return prev\n          return { ...prev, desktopUpsellDismissed: true }\n        })\n        onDone()\n        return\n      case 'not-now':\n        onDone()\n        return\n    }\n  }\n\n  const options = [\n    { label: 'Open in Claude Code Desktop', value: 'try' as const },\n    { label: 'Not now', value: 'not-now' as const },\n    { label: \"Don't ask again\", value: 'never' as const },\n  ]\n\n  return (\n    <PermissionDialog title=\"Try Claude Code Desktop\">\n      <Box flexDirection=\"column\" paddingX={2} paddingY={1}>\n        <Box marginBottom={1}>\n          <Text>\n            Same Claude Code with visual diffs, live app preview, parallel\n            sessions, and more.\n          </Text>\n        </Box>\n        <Select\n          options={options}\n          onChange={handleSelect}\n          onCancel={() => handleSelect('not-now')}\n        />\n      </Box>\n    </PermissionDialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/components/DevBar.tsx

@@ -0,0 +1,49 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useState } from 'react';
+import { getSlowOperations } from '../bootstrap/state.js';
+import { Text, useInterval } from '../ink.js';
+
+// Show DevBar for dev builds or all ants
+function shouldShowDevBar(): boolean {
+  return "production" === 'development' || "external" === 'ant';
+}
+export function DevBar() {
+  const $ = _c(5);
+  const [slowOps, setSlowOps] = useState(getSlowOperations);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = () => {
+      setSlowOps(getSlowOperations());
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  useInterval(t0, shouldShowDevBar() ? 500 : null);
+  if (!shouldShowDevBar() || slowOps.length === 0) {
+    return null;
+  }
+  let t1;
+  if ($[1] !== slowOps) {
+    t1 = slowOps.slice(-3).map(_temp).join(" \xB7 ");
+    $[1] = slowOps;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const recentOps = t1;
+  let t2;
+  if ($[3] !== recentOps) {
+    t2 = <Text wrap="truncate-end" color="warning">[ANT-ONLY] slow sync: {recentOps}</Text>;
+    $[3] = recentOps;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return t2;
+}
+function _temp(op) {
+  return `${op.operation} (${Math.round(op.durationMs)}ms)`;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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