@xortex/xcode 3.0.1 → 3.0.2

package/components/Onboarding.tsx

@@ -0,0 +1,244 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { setupTerminal, shouldOfferTerminalSetup } from '../commands/terminalSetup/terminalSetup.js';
+import { useExitOnCtrlCDWithKeybindings } from '../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { Box, Link, Newline, Text, useTheme } from '../ink.js';
+import { useKeybindings } from '../keybindings/useKeybinding.js';
+import { isAnthropicAuthEnabled } from '../utils/auth.js';
+import { normalizeApiKeyForConfig } from '../utils/authPortable.js';
+import { getCustomApiKeyStatus } from '../utils/config.js';
+import { env } from '../utils/env.js';
+import { isRunningOnHomespace } from '../utils/envUtils.js';
+import { PreflightStep } from '../utils/preflightChecks.js';
+import type { ThemeSetting } from '../utils/theme.js';
+import { ApproveApiKey } from './ApproveApiKey.js';
+import { ConsoleOAuthFlow } from './ConsoleOAuthFlow.js';
+import { Select } from './CustomSelect/select.js';
+import { WelcomeV2 } from './LogoV2/WelcomeV2.js';
+import { PressEnterToContinue } from './PressEnterToContinue.js';
+import { ThemePicker } from './ThemePicker.js';
+import { OrderedList } from './ui/OrderedList.js';
+type StepId = 'preflight' | 'theme' | 'oauth' | 'api-key' | 'security' | 'terminal-setup';
+interface OnboardingStep {
+  id: StepId;
+  component: React.ReactNode;
+}
+type Props = {
+  onDone(): void;
+};
+export function Onboarding({
+  onDone
+}: Props): React.ReactNode {
+  const [currentStepIndex, setCurrentStepIndex] = useState(0);
+  const [skipOAuth, setSkipOAuth] = useState(false);
+  const [oauthEnabled] = useState(() => isAnthropicAuthEnabled());
+  const [theme, setTheme] = useTheme();
+  useEffect(() => {
+    logEvent('tengu_began_setup', {
+      oauthEnabled
+    });
+  }, [oauthEnabled]);
+  function goToNextStep() {
+    if (currentStepIndex < steps.length - 1) {
+      const nextIndex = currentStepIndex + 1;
+      setCurrentStepIndex(nextIndex);
+      logEvent('tengu_onboarding_step', {
+        oauthEnabled,
+        stepId: steps[nextIndex]?.id as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+    } else {
+      onDone();
+    }
+  }
+  function handleThemeSelection(newTheme: ThemeSetting) {
+    setTheme(newTheme);
+    goToNextStep();
+  }
+  const exitState = useExitOnCtrlCDWithKeybindings();
+
+  // Define all onboarding steps
+  const themeStep = <Box marginX={1}>
+      <ThemePicker onThemeSelect={handleThemeSelection} showIntroText={true} helpText="To change this later, run /theme" hideEscToCancel={true} skipExitHandling={true} // Skip exit handling as Onboarding already handles it
+    />
+    </Box>;
+  const securityStep = <Box flexDirection="column" gap={1} paddingLeft={1}>
+      <Text bold>Security notes:</Text>
+      <Box flexDirection="column" width={70}>
+        {/**
+         * OrderedList misnumbers items when rendering conditionally,
+         * so put all items in the if/else
+         */}
+        <OrderedList>
+          <OrderedList.Item>
+            <Text>Claude can make mistakes</Text>
+            <Text dimColor wrap="wrap">
+              You should always review Claude&apos;s responses, especially when
+              <Newline />
+              running code.
+              <Newline />
+            </Text>
+          </OrderedList.Item>
+          <OrderedList.Item>
+            <Text>
+              Due to prompt injection risks, only use it with code you trust
+            </Text>
+            <Text dimColor wrap="wrap">
+              For more details see:
+              <Newline />
+              <Link url="https://code.claude.com/docs/en/security" />
+            </Text>
+          </OrderedList.Item>
+        </OrderedList>
+      </Box>
+      <PressEnterToContinue />
+    </Box>;
+  const preflightStep = <PreflightStep onSuccess={goToNextStep} />;
+  // Create the steps array - determine which steps to include based on reAuth and oauthEnabled
+  const apiKeyNeedingApproval = useMemo(() => {
+    // Add API key step if needed
+    // On homespace, ANTHROPIC_API_KEY is preserved in process.env for child
+    // processes but ignored by Claude Code itself (see auth.ts).
+    if (!process.env.ANTHROPIC_API_KEY || isRunningOnHomespace()) {
+      return '';
+    }
+    const customApiKeyTruncated = normalizeApiKeyForConfig(process.env.ANTHROPIC_API_KEY);
+    if (getCustomApiKeyStatus(customApiKeyTruncated) === 'new') {
+      return customApiKeyTruncated;
+    }
+  }, []);
+  function handleApiKeyDone(approved: boolean) {
+    if (approved) {
+      setSkipOAuth(true);
+    }
+    goToNextStep();
+  }
+  const steps: OnboardingStep[] = [];
+  if (oauthEnabled) {
+    steps.push({
+      id: 'preflight',
+      component: preflightStep
+    });
+  }
+  steps.push({
+    id: 'theme',
+    component: themeStep
+  });
+  if (apiKeyNeedingApproval) {
+    steps.push({
+      id: 'api-key',
+      component: <ApproveApiKey customApiKeyTruncated={apiKeyNeedingApproval} onDone={handleApiKeyDone} />
+    });
+  }
+  if (oauthEnabled) {
+    steps.push({
+      id: 'oauth',
+      component: <SkippableStep skip={skipOAuth} onSkip={goToNextStep}>
+          <ConsoleOAuthFlow onDone={goToNextStep} />
+        </SkippableStep>
+    });
+  }
+  steps.push({
+    id: 'security',
+    component: securityStep
+  });
+  if (shouldOfferTerminalSetup()) {
+    steps.push({
+      id: 'terminal-setup',
+      component: <Box flexDirection="column" gap={1} paddingLeft={1}>
+          <Text bold>Use Claude Code&apos;s terminal setup?</Text>
+          <Box flexDirection="column" width={70} gap={1}>
+            <Text>
+              For the optimal coding experience, enable the recommended settings
+              <Newline />
+              for your terminal:{' '}
+              {env.terminal === 'Apple_Terminal' ? 'Option+Enter for newlines and visual bell' : 'Shift+Enter for newlines'}
+            </Text>
+            <Select options={[{
+            label: 'Yes, use recommended settings',
+            value: 'install'
+          }, {
+            label: 'No, maybe later with /terminal-setup',
+            value: 'no'
+          }]} onChange={value => {
+            if (value === 'install') {
+              // Errors already logged in setupTerminal, just swallow and proceed
+              void setupTerminal(theme).catch(() => {}).finally(goToNextStep);
+            } else {
+              goToNextStep();
+            }
+          }} onCancel={() => goToNextStep()} />
+            <Text dimColor>
+              {exitState.pending ? <>Press {exitState.keyName} again to exit</> : <>Enter to confirm · Esc to skip</>}
+            </Text>
+          </Box>
+        </Box>
+    });
+  }
+  const currentStep = steps[currentStepIndex];
+
+  // Handle Enter on security step and Escape on terminal-setup step
+  // Dependencies match what goToNextStep uses internally
+  const handleSecurityContinue = useCallback(() => {
+    if (currentStepIndex === steps.length - 1) {
+      onDone();
+    } else {
+      goToNextStep();
+    }
+  }, [currentStepIndex, steps.length, oauthEnabled, onDone]);
+  const handleTerminalSetupSkip = useCallback(() => {
+    goToNextStep();
+  }, [currentStepIndex, steps.length, oauthEnabled, onDone]);
+  useKeybindings({
+    'confirm:yes': handleSecurityContinue
+  }, {
+    context: 'Confirmation',
+    isActive: currentStep?.id === 'security'
+  });
+  useKeybindings({
+    'confirm:no': handleTerminalSetupSkip
+  }, {
+    context: 'Confirmation',
+    isActive: currentStep?.id === 'terminal-setup'
+  });
+  return <Box flexDirection="column">
+      <WelcomeV2 />
+      <Box flexDirection="column" marginTop={1}>
+        {currentStep?.component}
+        {exitState.pending && <Box padding={1}>
+            <Text dimColor>Press {exitState.keyName} again to exit</Text>
+          </Box>}
+      </Box>
+    </Box>;
+}
+export function SkippableStep(t0) {
+  const $ = _c(4);
+  const {
+    skip,
+    onSkip,
+    children
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== onSkip || $[1] !== skip) {
+    t1 = () => {
+      if (skip) {
+        onSkip();
+      }
+    };
+    t2 = [skip, onSkip];
+    $[0] = onSkip;
+    $[1] = skip;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t1 = $[2];
+    t2 = $[3];
+  }
+  useEffect(t1, t2);
+  if (skip) {
+    return null;
+  }
+  return children;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useMemo","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","setupTerminal","shouldOfferTerminalSetup","useExitOnCtrlCDWithKeybindings","Box","Link","Newline","Text","useTheme","useKeybindings","isAnthropicAuthEnabled","normalizeApiKeyForConfig","getCustomApiKeyStatus","env","isRunningOnHomespace","PreflightStep","ThemeSetting","ApproveApiKey","ConsoleOAuthFlow","Select","WelcomeV2","PressEnterToContinue","ThemePicker","OrderedList","StepId","OnboardingStep","id","component","ReactNode","Props","onDone","Onboarding","currentStepIndex","setCurrentStepIndex","skipOAuth","setSkipOAuth","oauthEnabled","theme","setTheme","goToNextStep","steps","length","nextIndex","stepId","handleThemeSelection","newTheme","exitState","themeStep","securityStep","preflightStep","apiKeyNeedingApproval","process","ANTHROPIC_API_KEY","customApiKeyTruncated","handleApiKeyDone","approved","push","terminal","label","value","catch","finally","pending","keyName","currentStep","handleSecurityContinue","handleTerminalSetupSkip","context","isActive","SkippableStep","t0","$","_c","skip","onSkip","children","t1","t2"],"sources":["Onboarding.tsx"],"sourcesContent":["import React, { useCallback, useEffect, useMemo, useState } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport {\n  setupTerminal,\n  shouldOfferTerminalSetup,\n} from '../commands/terminalSetup/terminalSetup.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { Box, Link, Newline, Text, useTheme } from '../ink.js'\nimport { useKeybindings } from '../keybindings/useKeybinding.js'\nimport { isAnthropicAuthEnabled } from '../utils/auth.js'\nimport { normalizeApiKeyForConfig } from '../utils/authPortable.js'\nimport { getCustomApiKeyStatus } from '../utils/config.js'\nimport { env } from '../utils/env.js'\nimport { isRunningOnHomespace } from '../utils/envUtils.js'\nimport { PreflightStep } from '../utils/preflightChecks.js'\nimport type { ThemeSetting } from '../utils/theme.js'\nimport { ApproveApiKey } from './ApproveApiKey.js'\nimport { ConsoleOAuthFlow } from './ConsoleOAuthFlow.js'\nimport { Select } from './CustomSelect/select.js'\nimport { WelcomeV2 } from './LogoV2/WelcomeV2.js'\nimport { PressEnterToContinue } from './PressEnterToContinue.js'\nimport { ThemePicker } from './ThemePicker.js'\nimport { OrderedList } from './ui/OrderedList.js'\n\ntype StepId =\n  | 'preflight'\n  | 'theme'\n  | 'oauth'\n  | 'api-key'\n  | 'security'\n  | 'terminal-setup'\n\ninterface OnboardingStep {\n  id: StepId\n  component: React.ReactNode\n}\n\ntype Props = {\n  onDone(): void\n}\n\nexport function Onboarding({ onDone }: Props): React.ReactNode {\n  const [currentStepIndex, setCurrentStepIndex] = useState(0)\n  const [skipOAuth, setSkipOAuth] = useState(false)\n  const [oauthEnabled] = useState(() => isAnthropicAuthEnabled())\n  const [theme, setTheme] = useTheme()\n\n  useEffect(() => {\n    logEvent('tengu_began_setup', {\n      oauthEnabled,\n    })\n  }, [oauthEnabled])\n\n  function goToNextStep() {\n    if (currentStepIndex < steps.length - 1) {\n      const nextIndex = currentStepIndex + 1\n      setCurrentStepIndex(nextIndex)\n\n      logEvent('tengu_onboarding_step', {\n        oauthEnabled,\n        stepId: steps[nextIndex]\n          ?.id as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n    } else {\n      onDone()\n    }\n  }\n\n  function handleThemeSelection(newTheme: ThemeSetting) {\n    setTheme(newTheme)\n    goToNextStep()\n  }\n\n  const exitState = useExitOnCtrlCDWithKeybindings()\n\n  // Define all onboarding steps\n  const themeStep = (\n    <Box marginX={1}>\n      <ThemePicker\n        onThemeSelect={handleThemeSelection}\n        showIntroText={true}\n        helpText=\"To change this later, run /theme\"\n        hideEscToCancel={true}\n        skipExitHandling={true} // Skip exit handling as Onboarding already handles it\n      />\n    </Box>\n  )\n\n  const securityStep = (\n    <Box flexDirection=\"column\" gap={1} paddingLeft={1}>\n      <Text bold>Security notes:</Text>\n      <Box flexDirection=\"column\" width={70}>\n        {/**\n         * OrderedList misnumbers items when rendering conditionally,\n         * so put all items in the if/else\n         */}\n        <OrderedList>\n          <OrderedList.Item>\n            <Text>Claude can make mistakes</Text>\n            <Text dimColor wrap=\"wrap\">\n              You should always review Claude&apos;s responses, especially when\n              <Newline />\n              running code.\n              <Newline />\n            </Text>\n          </OrderedList.Item>\n          <OrderedList.Item>\n            <Text>\n              Due to prompt injection risks, only use it with code you trust\n            </Text>\n            <Text dimColor wrap=\"wrap\">\n              For more details see:\n              <Newline />\n              <Link url=\"https://code.claude.com/docs/en/security\" />\n            </Text>\n          </OrderedList.Item>\n        </OrderedList>\n      </Box>\n      <PressEnterToContinue />\n    </Box>\n  )\n\n  const preflightStep = <PreflightStep onSuccess={goToNextStep} />\n  // Create the steps array - determine which steps to include based on reAuth and oauthEnabled\n  const apiKeyNeedingApproval = useMemo(() => {\n    // Add API key step if needed\n    // On homespace, ANTHROPIC_API_KEY is preserved in process.env for child\n    // processes but ignored by Claude Code itself (see auth.ts).\n    if (!process.env.ANTHROPIC_API_KEY || isRunningOnHomespace()) {\n      return ''\n    }\n    const customApiKeyTruncated = normalizeApiKeyForConfig(\n      process.env.ANTHROPIC_API_KEY,\n    )\n    if (getCustomApiKeyStatus(customApiKeyTruncated) === 'new') {\n      return customApiKeyTruncated\n    }\n  }, [])\n\n  function handleApiKeyDone(approved: boolean) {\n    if (approved) {\n      setSkipOAuth(true)\n    }\n    goToNextStep()\n  }\n\n  const steps: OnboardingStep[] = []\n  if (oauthEnabled) {\n    steps.push({ id: 'preflight', component: preflightStep })\n  }\n  steps.push({ id: 'theme', component: themeStep })\n\n  if (apiKeyNeedingApproval) {\n    steps.push({\n      id: 'api-key',\n      component: (\n        <ApproveApiKey\n          customApiKeyTruncated={apiKeyNeedingApproval}\n          onDone={handleApiKeyDone}\n        />\n      ),\n    })\n  }\n\n  if (oauthEnabled) {\n    steps.push({\n      id: 'oauth',\n      component: (\n        <SkippableStep skip={skipOAuth} onSkip={goToNextStep}>\n          <ConsoleOAuthFlow onDone={goToNextStep} />\n        </SkippableStep>\n      ),\n    })\n  }\n\n  steps.push({ id: 'security', component: securityStep })\n\n  if (shouldOfferTerminalSetup()) {\n    steps.push({\n      id: 'terminal-setup',\n      component: (\n        <Box flexDirection=\"column\" gap={1} paddingLeft={1}>\n          <Text bold>Use Claude Code&apos;s terminal setup?</Text>\n          <Box flexDirection=\"column\" width={70} gap={1}>\n            <Text>\n              For the optimal coding experience, enable the recommended settings\n              <Newline />\n              for your terminal:{' '}\n              {env.terminal === 'Apple_Terminal'\n                ? 'Option+Enter for newlines and visual bell'\n                : 'Shift+Enter for newlines'}\n            </Text>\n            <Select\n              options={[\n                {\n                  label: 'Yes, use recommended settings',\n                  value: 'install',\n                },\n                {\n                  label: 'No, maybe later with /terminal-setup',\n                  value: 'no',\n                },\n              ]}\n              onChange={value => {\n                if (value === 'install') {\n                  // Errors already logged in setupTerminal, just swallow and proceed\n                  void setupTerminal(theme)\n                    .catch(() => {})\n                    .finally(goToNextStep)\n                } else {\n                  goToNextStep()\n                }\n              }}\n              onCancel={() => goToNextStep()}\n            />\n            <Text dimColor>\n              {exitState.pending ? (\n                <>Press {exitState.keyName} again to exit</>\n              ) : (\n                <>Enter to confirm · Esc to skip</>\n              )}\n            </Text>\n          </Box>\n        </Box>\n      ),\n    })\n  }\n\n  const currentStep = steps[currentStepIndex]\n\n  // Handle Enter on security step and Escape on terminal-setup step\n  // Dependencies match what goToNextStep uses internally\n  const handleSecurityContinue = useCallback(() => {\n    if (currentStepIndex === steps.length - 1) {\n      onDone()\n    } else {\n      goToNextStep()\n    }\n  }, [currentStepIndex, steps.length, oauthEnabled, onDone])\n\n  const handleTerminalSetupSkip = useCallback(() => {\n    goToNextStep()\n  }, [currentStepIndex, steps.length, oauthEnabled, onDone])\n\n  useKeybindings(\n    {\n      'confirm:yes': handleSecurityContinue,\n    },\n    {\n      context: 'Confirmation',\n      isActive: currentStep?.id === 'security',\n    },\n  )\n\n  useKeybindings(\n    {\n      'confirm:no': handleTerminalSetupSkip,\n    },\n    {\n      context: 'Confirmation',\n      isActive: currentStep?.id === 'terminal-setup',\n    },\n  )\n\n  return (\n    <Box flexDirection=\"column\">\n      <WelcomeV2 />\n      <Box flexDirection=\"column\" marginTop={1}>\n        {currentStep?.component}\n        {exitState.pending && (\n          <Box padding={1}>\n            <Text dimColor>Press {exitState.keyName} again to exit</Text>\n          </Box>\n        )}\n      </Box>\n    </Box>\n  )\n}\n\nexport function SkippableStep({\n  skip,\n  onSkip,\n  children,\n}: {\n  skip: boolean\n  onSkip(): void\n  children: React.ReactNode\n}): React.ReactNode {\n  useEffect(() => {\n    if (skip) {\n      onSkip()\n    }\n  }, [skip, onSkip])\n  if (skip) {\n    return null\n  }\n  return children\n}\n"],"mappings":"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","ignoreList":[]}

package/components/OutputStylePicker.tsx

@@ -0,0 +1,112 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useCallback, useEffect, useState } from 'react';
+import { getAllOutputStyles, OUTPUT_STYLE_CONFIG, type OutputStyleConfig } from '../constants/outputStyles.js';
+import { Box, Text } from '../ink.js';
+import type { OutputStyle } from '../utils/config.js';
+import { getCwd } from '../utils/cwd.js';
+import type { OptionWithDescription } from './CustomSelect/select.js';
+import { Select } from './CustomSelect/select.js';
+import { Dialog } from './design-system/Dialog.js';
+const DEFAULT_OUTPUT_STYLE_LABEL = 'Default';
+const DEFAULT_OUTPUT_STYLE_DESCRIPTION = 'Claude completes coding tasks efficiently and provides concise responses';
+function mapConfigsToOptions(styles: {
+  [styleName: string]: OutputStyleConfig | null;
+}): OptionWithDescription[] {
+  return Object.entries(styles).map(([style, config]) => ({
+    label: config?.name ?? DEFAULT_OUTPUT_STYLE_LABEL,
+    value: style,
+    description: config?.description ?? DEFAULT_OUTPUT_STYLE_DESCRIPTION
+  }));
+}
+export type OutputStylePickerProps = {
+  initialStyle: OutputStyle;
+  onComplete: (style: OutputStyle) => void;
+  onCancel: () => void;
+  isStandaloneCommand?: boolean;
+};
+export function OutputStylePicker(t0) {
+  const $ = _c(16);
+  const {
+    initialStyle,
+    onComplete,
+    onCancel,
+    isStandaloneCommand
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = [];
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const [styleOptions, setStyleOptions] = useState(t1);
+  const [isLoading, setIsLoading] = useState(true);
+  let t2;
+  let t3;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = () => {
+      getAllOutputStyles(getCwd()).then(allStyles => {
+        const options = mapConfigsToOptions(allStyles);
+        setStyleOptions(options);
+        setIsLoading(false);
+      }).catch(() => {
+        const builtInOptions = mapConfigsToOptions(OUTPUT_STYLE_CONFIG);
+        setStyleOptions(builtInOptions);
+        setIsLoading(false);
+      });
+    };
+    t3 = [];
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t2 = $[1];
+    t3 = $[2];
+  }
+  useEffect(t2, t3);
+  let t4;
+  if ($[3] !== onComplete) {
+    t4 = style => {
+      const outputStyle = style as OutputStyle;
+      onComplete(outputStyle);
+    };
+    $[3] = onComplete;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  const handleStyleSelect = t4;
+  const t5 = !isStandaloneCommand;
+  const t6 = !isStandaloneCommand;
+  let t7;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = <Box marginTop={1}><Text dimColor={true}>This changes how Claude Code communicates with you</Text></Box>;
+    $[5] = t7;
+  } else {
+    t7 = $[5];
+  }
+  let t8;
+  if ($[6] !== handleStyleSelect || $[7] !== initialStyle || $[8] !== isLoading || $[9] !== styleOptions) {
+    t8 = <Box flexDirection="column" gap={1}>{t7}{isLoading ? <Text dimColor={true}>Loading output styles…</Text> : <Select options={styleOptions} onChange={handleStyleSelect} visibleOptionCount={10} defaultValue={initialStyle} />}</Box>;
+    $[6] = handleStyleSelect;
+    $[7] = initialStyle;
+    $[8] = isLoading;
+    $[9] = styleOptions;
+    $[10] = t8;
+  } else {
+    t8 = $[10];
+  }
+  let t9;
+  if ($[11] !== onCancel || $[12] !== t5 || $[13] !== t6 || $[14] !== t8) {
+    t9 = <Dialog title="Preferred output style" onCancel={onCancel} hideInputGuide={t5} hideBorder={t6}>{t8}</Dialog>;
+    $[11] = onCancel;
+    $[12] = t5;
+    $[13] = t6;
+    $[14] = t8;
+    $[15] = t9;
+  } else {
+    t9 = $[15];
+  }
+  return t9;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","getAllOutputStyles","OUTPUT_STYLE_CONFIG","OutputStyleConfig","Box","Text","OutputStyle","getCwd","OptionWithDescription","Select","Dialog","DEFAULT_OUTPUT_STYLE_LABEL","DEFAULT_OUTPUT_STYLE_DESCRIPTION","mapConfigsToOptions","styles","styleName","Object","entries","map","style","config","label","name","value","description","OutputStylePickerProps","initialStyle","onComplete","onCancel","isStandaloneCommand","OutputStylePicker","t0","$","_c","t1","Symbol","for","styleOptions","setStyleOptions","isLoading","setIsLoading","t2","t3","then","allStyles","options","catch","builtInOptions","t4","outputStyle","handleStyleSelect","t5","t6","t7","t8","t9"],"sources":["OutputStylePicker.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useCallback, useEffect, useState } from 'react'\nimport {\n  getAllOutputStyles,\n  OUTPUT_STYLE_CONFIG,\n  type OutputStyleConfig,\n} from '../constants/outputStyles.js'\nimport { Box, Text } from '../ink.js'\nimport type { OutputStyle } from '../utils/config.js'\nimport { getCwd } from '../utils/cwd.js'\nimport type { OptionWithDescription } from './CustomSelect/select.js'\nimport { Select } from './CustomSelect/select.js'\nimport { Dialog } from './design-system/Dialog.js'\n\nconst DEFAULT_OUTPUT_STYLE_LABEL = 'Default'\nconst DEFAULT_OUTPUT_STYLE_DESCRIPTION =\n  'Claude completes coding tasks efficiently and provides concise responses'\n\nfunction mapConfigsToOptions(styles: {\n  [styleName: string]: OutputStyleConfig | null\n}): OptionWithDescription[] {\n  return Object.entries(styles).map(([style, config]) => ({\n    label: config?.name ?? DEFAULT_OUTPUT_STYLE_LABEL,\n    value: style,\n    description: config?.description ?? DEFAULT_OUTPUT_STYLE_DESCRIPTION,\n  }))\n}\n\nexport type OutputStylePickerProps = {\n  initialStyle: OutputStyle\n  onComplete: (style: OutputStyle) => void\n  onCancel: () => void\n  isStandaloneCommand?: boolean\n}\n\nexport function OutputStylePicker({\n  initialStyle,\n  onComplete,\n  onCancel,\n  isStandaloneCommand,\n}: OutputStylePickerProps): React.ReactNode {\n  const [styleOptions, setStyleOptions] = useState<OptionWithDescription[]>([])\n  const [isLoading, setIsLoading] = useState(true)\n\n  useEffect(() => {\n    // Load all output styles including custom ones\n    getAllOutputStyles(getCwd())\n      .then(allStyles => {\n        const options = mapConfigsToOptions(allStyles)\n        setStyleOptions(options)\n        setIsLoading(false)\n      })\n      .catch(() => {\n        // On error, fall back to built-in styles only\n        const builtInOptions = mapConfigsToOptions(OUTPUT_STYLE_CONFIG)\n        setStyleOptions(builtInOptions)\n        setIsLoading(false)\n      })\n  }, [])\n\n  const handleStyleSelect = useCallback(\n    (style: string) => {\n      const outputStyle = style as OutputStyle\n      onComplete(outputStyle)\n    },\n    [onComplete],\n  )\n\n  return (\n    <Dialog\n      title=\"Preferred output style\"\n      onCancel={onCancel}\n      hideInputGuide={!isStandaloneCommand}\n      hideBorder={!isStandaloneCommand}\n    >\n      <Box flexDirection=\"column\" gap={1}>\n        <Box marginTop={1}>\n          <Text dimColor>\n            This changes how Claude Code communicates with you\n          </Text>\n        </Box>\n        {isLoading ? (\n          <Text dimColor>Loading output styles…</Text>\n        ) : (\n          <Select\n            options={styleOptions}\n            onChange={handleStyleSelect}\n            visibleOptionCount={10}\n            defaultValue={initialStyle}\n          />\n        )}\n      </Box>\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/components/PackageManagerAutoUpdater.tsx

@@ -0,0 +1,104 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useState } from 'react';
+import { useInterval } from 'usehooks-ts';
+import { Text } from '../ink.js';
+import { type AutoUpdaterResult, getLatestVersionFromGcs, getMaxVersion, shouldSkipVersion } from '../utils/autoUpdater.js';
+import { isAutoUpdaterDisabled } from '../utils/config.js';
+import { logForDebugging } from '../utils/debug.js';
+import { getPackageManager, type PackageManager } from '../utils/nativeInstaller/packageManagers.js';
+import { gt, gte } from '../utils/semver.js';
+import { getInitialSettings } from '../utils/settings/settings.js';
+type Props = {
+  isUpdating: boolean;
+  onChangeIsUpdating: (isUpdating: boolean) => void;
+  onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void;
+  autoUpdaterResult: AutoUpdaterResult | null;
+  showSuccessMessage: boolean;
+  verbose: boolean;
+};
+export function PackageManagerAutoUpdater(t0) {
+  const $ = _c(10);
+  const {
+    verbose
+  } = t0;
+  const [updateAvailable, setUpdateAvailable] = useState(false);
+  const [packageManager, setPackageManager] = useState("unknown");
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = async () => {
+      false || false;
+      if (isAutoUpdaterDisabled()) {
+        return;
+      }
+      const [channel, pm] = await Promise.all([Promise.resolve(getInitialSettings()?.autoUpdatesChannel ?? "latest"), getPackageManager()]);
+      setPackageManager(pm);
+      let latest = await getLatestVersionFromGcs(channel);
+      const maxVersion = await getMaxVersion();
+      if (maxVersion && latest && gt(latest, maxVersion)) {
+        logForDebugging(`PackageManagerAutoUpdater: maxVersion ${maxVersion} is set, capping update from ${latest} to ${maxVersion}`);
+        if (gte(MACRO.VERSION, maxVersion)) {
+          logForDebugging(`PackageManagerAutoUpdater: current version ${MACRO.VERSION} is already at or above maxVersion ${maxVersion}, skipping update`);
+          setUpdateAvailable(false);
+          return;
+        }
+        latest = maxVersion;
+      }
+      const hasUpdate = latest && !gte(MACRO.VERSION, latest) && !shouldSkipVersion(latest);
+      setUpdateAvailable(!!hasUpdate);
+      if (hasUpdate) {
+        logForDebugging(`PackageManagerAutoUpdater: Update available ${MACRO.VERSION} -> ${latest}`);
+      }
+    };
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const checkForUpdates = t1;
+  let t2;
+  let t3;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = () => {
+      checkForUpdates();
+    };
+    t3 = [checkForUpdates];
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t2 = $[1];
+    t3 = $[2];
+  }
+  React.useEffect(t2, t3);
+  useInterval(checkForUpdates, 1800000);
+  if (!updateAvailable) {
+    return null;
+  }
+  const updateCommand = packageManager === "homebrew" ? "brew upgrade claude-code" : packageManager === "winget" ? "winget upgrade Anthropic.ClaudeCode" : packageManager === "apk" ? "apk upgrade claude-code" : "your package manager update command";
+  let t4;
+  if ($[3] !== verbose) {
+    t4 = verbose && <Text dimColor={true} wrap="truncate">currentVersion: {MACRO.VERSION}</Text>;
+    $[3] = verbose;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] !== updateCommand) {
+    t5 = <Text color="warning" wrap="truncate">Update available! Run: <Text bold={true}>{updateCommand}</Text></Text>;
+    $[5] = updateCommand;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  let t6;
+  if ($[7] !== t4 || $[8] !== t5) {
+    t6 = <>{t4}{t5}</>;
+    $[7] = t4;
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  return t6;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","useInterval","Text","AutoUpdaterResult","getLatestVersionFromGcs","getMaxVersion","shouldSkipVersion","isAutoUpdaterDisabled","logForDebugging","getPackageManager","PackageManager","gt","gte","getInitialSettings","Props","isUpdating","onChangeIsUpdating","onAutoUpdaterResult","autoUpdaterResult","showSuccessMessage","verbose","PackageManagerAutoUpdater","t0","$","_c","updateAvailable","setUpdateAvailable","packageManager","setPackageManager","t1","Symbol","for","channel","pm","Promise","all","resolve","autoUpdatesChannel","latest","maxVersion","MACRO","VERSION","hasUpdate","checkForUpdates","t2","t3","useEffect","updateCommand","t4","t5","t6"],"sources":["PackageManagerAutoUpdater.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useState } from 'react'\nimport { useInterval } from 'usehooks-ts'\nimport { Text } from '../ink.js'\nimport {\n  type AutoUpdaterResult,\n  getLatestVersionFromGcs,\n  getMaxVersion,\n  shouldSkipVersion,\n} from '../utils/autoUpdater.js'\nimport { isAutoUpdaterDisabled } from '../utils/config.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport {\n  getPackageManager,\n  type PackageManager,\n} from '../utils/nativeInstaller/packageManagers.js'\nimport { gt, gte } from '../utils/semver.js'\nimport { getInitialSettings } from '../utils/settings/settings.js'\n\ntype Props = {\n  isUpdating: boolean\n  onChangeIsUpdating: (isUpdating: boolean) => void\n  onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void\n  autoUpdaterResult: AutoUpdaterResult | null\n  showSuccessMessage: boolean\n  verbose: boolean\n}\n\nexport function PackageManagerAutoUpdater({ verbose }: Props): React.ReactNode {\n  const [updateAvailable, setUpdateAvailable] = useState(false)\n  const [packageManager, setPackageManager] =\n    useState<PackageManager>('unknown')\n\n  const checkForUpdates = React.useCallback(async () => {\n    if (\n      \"production\" === 'test' ||\n      \"production\" === 'development'\n    ) {\n      return\n    }\n\n    if (isAutoUpdaterDisabled()) {\n      return\n    }\n\n    const [channel, pm] = await Promise.all([\n      Promise.resolve(getInitialSettings()?.autoUpdatesChannel ?? 'latest'),\n      getPackageManager(),\n    ])\n    setPackageManager(pm)\n\n    let latest = await getLatestVersionFromGcs(channel)\n\n    // Check if max version is set (server-side kill switch for auto-updates)\n    const maxVersion = await getMaxVersion()\n\n    if (maxVersion && latest && gt(latest, maxVersion)) {\n      logForDebugging(\n        `PackageManagerAutoUpdater: maxVersion ${maxVersion} is set, capping update from ${latest} to ${maxVersion}`,\n      )\n      if (gte(MACRO.VERSION, maxVersion)) {\n        logForDebugging(\n          `PackageManagerAutoUpdater: current version ${MACRO.VERSION} is already at or above maxVersion ${maxVersion}, skipping update`,\n        )\n        setUpdateAvailable(false)\n        return\n      }\n      latest = maxVersion\n    }\n\n    const hasUpdate =\n      latest && !gte(MACRO.VERSION, latest) && !shouldSkipVersion(latest)\n\n    setUpdateAvailable(!!hasUpdate)\n\n    if (hasUpdate) {\n      logForDebugging(\n        `PackageManagerAutoUpdater: Update available ${MACRO.VERSION} -> ${latest}`,\n      )\n    }\n  }, [])\n\n  // Initial check\n  React.useEffect(() => {\n    void checkForUpdates()\n  }, [checkForUpdates])\n\n  // Check every 30 minutes\n  useInterval(checkForUpdates, 30 * 60 * 1000)\n\n  if (!updateAvailable) {\n    return null\n  }\n\n  // pacman, deb, and rpm don't get specific commands because they each have\n  // multiple frontends (pacman: yay/paru/makepkg, deb: apt/apt-get/aptitude/nala,\n  // rpm: dnf/yum/zypper)\n  const updateCommand =\n    packageManager === 'homebrew'\n      ? 'brew upgrade claude-code'\n      : packageManager === 'winget'\n        ? 'winget upgrade Anthropic.ClaudeCode'\n        : packageManager === 'apk'\n          ? 'apk upgrade claude-code'\n          : 'your package manager update command'\n\n  return (\n    <>\n      {verbose && (\n        <Text dimColor wrap=\"truncate\">\n          currentVersion: {MACRO.VERSION}\n        </Text>\n      )}\n      <Text color=\"warning\" wrap=\"truncate\">\n        Update available! Run: <Text bold>{updateCommand}</Text>\n      </Text>\n    </>\n  )\n}\n"],"mappings":"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","ignoreList":[]}