@xelauvas/xela-cli 0.1.0

package/src/commands/install-github-app/OAuthFlowStep.tsx

@@ -0,0 +1,276 @@
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+import { Spinner } from '../../components/Spinner.js';
+import TextInput from '../../components/TextInput.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import { setClipboard } from '../../ink/termio/osc.js';
+import { Box, Link, Text } from '../../ink.js';
+import { OAuthService } from '../../services/oauth/index.js';
+import { saveOAuthTokensIfNeeded } from '../../utils/auth.js';
+import { logError } from '../../utils/log.js';
+interface OAuthFlowStepProps {
+  onSuccess: (token: string) => void;
+  onCancel: () => void;
+}
+type OAuthStatus = {
+  state: 'starting';
+} | {
+  state: 'waiting_for_login';
+  url: string;
+} | {
+  state: 'processing';
+} | {
+  state: 'success';
+  token: string;
+} | {
+  state: 'error';
+  message: string;
+  toRetry?: OAuthStatus;
+} | {
+  state: 'about_to_retry';
+  nextState: OAuthStatus;
+};
+const PASTE_HERE_MSG = 'Paste code here if prompted > ';
+export function OAuthFlowStep({
+  onSuccess,
+  onCancel
+}: OAuthFlowStepProps): React.ReactNode {
+  const [oauthStatus, setOAuthStatus] = useState<OAuthStatus>({
+    state: 'starting'
+  });
+  const [oauthService] = useState(() => new OAuthService());
+  const [pastedCode, setPastedCode] = useState('');
+  const [cursorOffset, setCursorOffset] = useState(0);
+  const [showPastePrompt, setShowPastePrompt] = useState(false);
+  const [urlCopied, setUrlCopied] = useState(false);
+  const timersRef = useRef<Set<NodeJS.Timeout>>(new Set());
+  // Separate ref so startOAuth's timer clear doesn't cancel the urlCopied reset
+  const urlCopiedTimerRef = useRef<NodeJS.Timeout | undefined>(undefined);
+  const terminalSize = useTerminalSize();
+  const textInputColumns = Math.max(50, terminalSize.columns - PASTE_HERE_MSG.length - 4);
+  function handleKeyDown(e: KeyboardEvent): void {
+    if (oauthStatus.state !== 'error') return;
+    e.preventDefault();
+    if (e.key === 'return' && oauthStatus.toRetry) {
+      setPastedCode('');
+      setCursorOffset(0);
+      setOAuthStatus({
+        state: 'about_to_retry',
+        nextState: oauthStatus.toRetry
+      });
+    } else {
+      onCancel();
+    }
+  }
+  async function handleSubmitCode(value: string, url: string) {
+    try {
+      // Expecting format "authorizationCode#state" from the authorization callback URL
+      const [authorizationCode, state] = value.split('#');
+      if (!authorizationCode || !state) {
+        setOAuthStatus({
+          state: 'error',
+          message: 'Invalid code. Please make sure the full code was copied',
+          toRetry: {
+            state: 'waiting_for_login',
+            url
+          }
+        });
+        return;
+      }
+
+      // Track which path the user is taking (manual code entry)
+      logEvent('tengu_oauth_manual_entry', {});
+      oauthService.handleManualAuthCodeInput({
+        authorizationCode,
+        state
+      });
+    } catch (err: unknown) {
+      logError(err);
+      setOAuthStatus({
+        state: 'error',
+        message: (err as Error).message,
+        toRetry: {
+          state: 'waiting_for_login',
+          url
+        }
+      });
+    }
+  }
+  const startOAuth = useCallback(async () => {
+    // Clear any existing timers when starting new OAuth flow
+    timersRef.current.forEach(timer => clearTimeout(timer));
+    timersRef.current.clear();
+    try {
+      const result = await oauthService.startOAuthFlow(async url_0 => {
+        setOAuthStatus({
+          state: 'waiting_for_login',
+          url: url_0
+        });
+        const timer_0 = setTimeout(setShowPastePrompt, 3000, true);
+        timersRef.current.add(timer_0);
+      }, {
+        loginWithClaudeAi: true,
+        // Always use Claude AI for subscription tokens
+        inferenceOnly: true,
+        expiresIn: 365 * 24 * 60 * 60 // 1 year
+      });
+
+      // Show processing state
+      setOAuthStatus({
+        state: 'processing'
+      });
+
+      // OAuthFlowStep creates inference-only tokens for GitHub Actions, not a
+      // replacement login. Use saveOAuthTokensIfNeeded directly to avoid
+      // performLogout which would destroy the user's existing auth session.
+      saveOAuthTokensIfNeeded(result);
+
+      // For OAuth flow, the access token can be used as an API key
+      const timer1 = setTimeout((setOAuthStatus_0, accessToken, onSuccess_0, timersRef_0) => {
+        setOAuthStatus_0({
+          state: 'success',
+          token: accessToken
+        });
+        // Auto-continue after brief delay to show success
+        const timer2 = setTimeout(onSuccess_0, 1000, accessToken);
+        timersRef_0.current.add(timer2);
+      }, 100, setOAuthStatus, result.accessToken, onSuccess, timersRef);
+      timersRef.current.add(timer1);
+    } catch (err_0) {
+      const errorMessage = (err_0 as Error).message;
+      setOAuthStatus({
+        state: 'error',
+        message: errorMessage,
+        toRetry: {
+          state: 'starting'
+        } // Allow retry by starting fresh OAuth flow
+      });
+      logError(err_0);
+      logEvent('tengu_oauth_error', {
+        error: errorMessage as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+    }
+  }, [oauthService, onSuccess]);
+  useEffect(() => {
+    if (oauthStatus.state === 'starting') {
+      void startOAuth();
+    }
+  }, [oauthStatus.state, startOAuth]);
+
+  // Retry logic
+  useEffect(() => {
+    if (oauthStatus.state === 'about_to_retry') {
+      const timer_1 = setTimeout((nextState, setShowPastePrompt_0, setOAuthStatus_1) => {
+        // Only show paste prompt when retrying to waiting_for_login
+        setShowPastePrompt_0(nextState.state === 'waiting_for_login');
+        setOAuthStatus_1(nextState);
+      }, 500, oauthStatus.nextState, setShowPastePrompt, setOAuthStatus);
+      timersRef.current.add(timer_1);
+    }
+  }, [oauthStatus]);
+  useEffect(() => {
+    if (pastedCode === 'c' && oauthStatus.state === 'waiting_for_login' && showPastePrompt && !urlCopied) {
+      void setClipboard(oauthStatus.url).then(raw => {
+        if (raw) process.stdout.write(raw);
+        setUrlCopied(true);
+        clearTimeout(urlCopiedTimerRef.current);
+        urlCopiedTimerRef.current = setTimeout(setUrlCopied, 2000, false);
+      });
+      setPastedCode('');
+    }
+  }, [pastedCode, oauthStatus, showPastePrompt, urlCopied]);
+
+  // Cleanup OAuth service and timers when component unmounts
+  useEffect(() => {
+    const timers = timersRef.current;
+    return () => {
+      oauthService.cleanup();
+      // Clear all timers
+      timers.forEach(timer_2 => clearTimeout(timer_2));
+      timers.clear();
+      clearTimeout(urlCopiedTimerRef.current);
+    };
+  }, [oauthService]);
+
+  // Helper function to render the appropriate status message
+  function renderStatusMessage(): React.ReactNode {
+    switch (oauthStatus.state) {
+      case 'starting':
+        return <Box>
+            <Spinner />
+            <Text>Starting authentication…</Text>
+          </Box>;
+      case 'waiting_for_login':
+        return <Box flexDirection="column" gap={1}>
+            {!showPastePrompt && <Box>
+                <Spinner />
+                <Text>
+                  Opening browser to sign in with your Claude account…
+                </Text>
+              </Box>}
+
+            {showPastePrompt && <Box>
+                <Text>{PASTE_HERE_MSG}</Text>
+                <TextInput value={pastedCode} onChange={setPastedCode} onSubmit={(value_0: string) => handleSubmitCode(value_0, oauthStatus.url)} cursorOffset={cursorOffset} onChangeCursorOffset={setCursorOffset} columns={textInputColumns} />
+              </Box>}
+          </Box>;
+      case 'processing':
+        return <Box>
+            <Spinner />
+            <Text>Processing authentication…</Text>
+          </Box>;
+      case 'success':
+        return <Box flexDirection="column" gap={1}>
+            <Text color="success">
+              ✓ Authentication token created successfully!
+            </Text>
+            <Text dimColor>Using token for GitHub Actions setup…</Text>
+          </Box>;
+      case 'error':
+        return <Box flexDirection="column" gap={1}>
+            <Text color="error">OAuth error: {oauthStatus.message}</Text>
+            {oauthStatus.toRetry ? <Text dimColor>
+                Press Enter to try again, or any other key to cancel
+              </Text> : <Text dimColor>Press any key to return to API key selection</Text>}
+          </Box>;
+      case 'about_to_retry':
+        return <Box flexDirection="column" gap={1}>
+            <Text color="permission">Retrying…</Text>
+          </Box>;
+      default:
+        return null;
+    }
+  }
+  return <Box flexDirection="column" gap={1} tabIndex={0} autoFocus onKeyDown={handleKeyDown}>
+      {/* Show header inline only for initial starting state */}
+      {oauthStatus.state === 'starting' && <Box flexDirection="column" gap={1} paddingBottom={1}>
+          <Text bold>Create Authentication Token</Text>
+          <Text dimColor>Creating a long-lived token for GitHub Actions</Text>
+        </Box>}
+      {/* Show header for non-starting states (to avoid duplicate with inline header)*/}
+      {oauthStatus.state !== 'success' && oauthStatus.state !== 'starting' && oauthStatus.state !== 'processing' && <Box key="header" flexDirection="column" gap={1} paddingBottom={1}>
+            <Text bold>Create Authentication Token</Text>
+            <Text dimColor>Creating a long-lived token for GitHub Actions</Text>
+          </Box>}
+      {/* Show URL when paste prompt is visible */}
+      {oauthStatus.state === 'waiting_for_login' && showPastePrompt && <Box flexDirection="column" key="urlToCopy" gap={1} paddingBottom={1}>
+          <Box paddingX={1}>
+            <Text dimColor>
+              Browser didn&apos;t open? Use the url below to sign in{' '}
+            </Text>
+            {urlCopied ? <Text color="success">(Copied!)</Text> : <Text dimColor>
+                <KeyboardShortcutHint shortcut="c" action="copy" parens />
+              </Text>}
+          </Box>
+          <Link url={oauthStatus.url}>
+            <Text dimColor>{oauthStatus.url}</Text>
+          </Link>
+        </Box>}
+      <Box paddingLeft={1} flexDirection="column" gap={1}>
+        {renderStatusMessage()}
+      </Box>
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useRef","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","KeyboardShortcutHint","Spinner","TextInput","useTerminalSize","KeyboardEvent","setClipboard","Box","Link","Text","OAuthService","saveOAuthTokensIfNeeded","logError","OAuthFlowStepProps","onSuccess","token","onCancel","OAuthStatus","state","url","message","toRetry","nextState","PASTE_HERE_MSG","OAuthFlowStep","ReactNode","oauthStatus","setOAuthStatus","oauthService","pastedCode","setPastedCode","cursorOffset","setCursorOffset","showPastePrompt","setShowPastePrompt","urlCopied","setUrlCopied","timersRef","Set","NodeJS","Timeout","urlCopiedTimerRef","undefined","terminalSize","textInputColumns","Math","max","columns","length","handleKeyDown","e","preventDefault","key","handleSubmitCode","value","authorizationCode","split","handleManualAuthCodeInput","err","Error","startOAuth","current","forEach","timer","clearTimeout","clear","result","startOAuthFlow","setTimeout","add","loginWithClaudeAi","inferenceOnly","expiresIn","timer1","accessToken","timer2","errorMessage","error","then","raw","process","stdout","write","timers","cleanup","renderStatusMessage"],"sources":["OAuthFlowStep.tsx"],"sourcesContent":["import React, { useCallback, useEffect, useRef, 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 { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\nimport { Spinner } from '../../components/Spinner.js'\nimport TextInput from '../../components/TextInput.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport { setClipboard } from '../../ink/termio/osc.js'\nimport { Box, Link, Text } from '../../ink.js'\nimport { OAuthService } from '../../services/oauth/index.js'\nimport { saveOAuthTokensIfNeeded } from '../../utils/auth.js'\nimport { logError } from '../../utils/log.js'\n\ninterface OAuthFlowStepProps {\n  onSuccess: (token: string) => void\n  onCancel: () => void\n}\n\ntype OAuthStatus =\n  | { state: 'starting' }\n  | { state: 'waiting_for_login'; url: string }\n  | { state: 'processing' }\n  | { state: 'success'; token: string }\n  | { state: 'error'; message: string; toRetry?: OAuthStatus }\n  | { state: 'about_to_retry'; nextState: OAuthStatus }\n\nconst PASTE_HERE_MSG = 'Paste code here if prompted > '\n\nexport function OAuthFlowStep({\n  onSuccess,\n  onCancel,\n}: OAuthFlowStepProps): React.ReactNode {\n  const [oauthStatus, setOAuthStatus] = useState<OAuthStatus>({\n    state: 'starting',\n  })\n  const [oauthService] = useState(() => new OAuthService())\n  const [pastedCode, setPastedCode] = useState('')\n  const [cursorOffset, setCursorOffset] = useState(0)\n  const [showPastePrompt, setShowPastePrompt] = useState(false)\n  const [urlCopied, setUrlCopied] = useState(false)\n  const timersRef = useRef<Set<NodeJS.Timeout>>(new Set())\n  // Separate ref so startOAuth's timer clear doesn't cancel the urlCopied reset\n  const urlCopiedTimerRef = useRef<NodeJS.Timeout | undefined>(undefined)\n\n  const terminalSize = useTerminalSize()\n  const textInputColumns = Math.max(\n    50,\n    terminalSize.columns - PASTE_HERE_MSG.length - 4,\n  )\n\n  function handleKeyDown(e: KeyboardEvent): void {\n    if (oauthStatus.state !== 'error') return\n    e.preventDefault()\n    if (e.key === 'return' && oauthStatus.toRetry) {\n      setPastedCode('')\n      setCursorOffset(0)\n      setOAuthStatus({\n        state: 'about_to_retry',\n        nextState: oauthStatus.toRetry,\n      })\n    } else {\n      onCancel()\n    }\n  }\n\n  async function handleSubmitCode(value: string, url: string) {\n    try {\n      // Expecting format \"authorizationCode#state\" from the authorization callback URL\n      const [authorizationCode, state] = value.split('#')\n\n      if (!authorizationCode || !state) {\n        setOAuthStatus({\n          state: 'error',\n          message: 'Invalid code. Please make sure the full code was copied',\n          toRetry: { state: 'waiting_for_login', url },\n        })\n        return\n      }\n\n      // Track which path the user is taking (manual code entry)\n      logEvent('tengu_oauth_manual_entry', {})\n      oauthService.handleManualAuthCodeInput({\n        authorizationCode,\n        state,\n      })\n    } catch (err: unknown) {\n      logError(err)\n      setOAuthStatus({\n        state: 'error',\n        message: (err as Error).message,\n        toRetry: { state: 'waiting_for_login', url },\n      })\n    }\n  }\n\n  const startOAuth = useCallback(async () => {\n    // Clear any existing timers when starting new OAuth flow\n    timersRef.current.forEach(timer => clearTimeout(timer))\n    timersRef.current.clear()\n\n    try {\n      const result = await oauthService.startOAuthFlow(\n        async url => {\n          setOAuthStatus({ state: 'waiting_for_login', url })\n          const timer = setTimeout(setShowPastePrompt, 3000, true)\n          timersRef.current.add(timer)\n        },\n        {\n          loginWithClaudeAi: true, // Always use Claude AI for subscription tokens\n          inferenceOnly: true,\n          expiresIn: 365 * 24 * 60 * 60, // 1 year\n        },\n      )\n\n      // Show processing state\n      setOAuthStatus({ state: 'processing' })\n\n      // OAuthFlowStep creates inference-only tokens for GitHub Actions, not a\n      // replacement login. Use saveOAuthTokensIfNeeded directly to avoid\n      // performLogout which would destroy the user's existing auth session.\n      saveOAuthTokensIfNeeded(result)\n\n      // For OAuth flow, the access token can be used as an API key\n      const timer1 = setTimeout(\n        (setOAuthStatus, accessToken, onSuccess, timersRef) => {\n          setOAuthStatus({ state: 'success', token: accessToken })\n          // Auto-continue after brief delay to show success\n          const timer2 = setTimeout(onSuccess, 1000, accessToken)\n          timersRef.current.add(timer2)\n        },\n        100,\n        setOAuthStatus,\n        result.accessToken,\n        onSuccess,\n        timersRef,\n      )\n      timersRef.current.add(timer1)\n    } catch (err) {\n      const errorMessage = (err as Error).message\n      setOAuthStatus({\n        state: 'error',\n        message: errorMessage,\n        toRetry: { state: 'starting' }, // Allow retry by starting fresh OAuth flow\n      })\n      logError(err)\n      logEvent('tengu_oauth_error', {\n        error:\n          errorMessage as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n    }\n  }, [oauthService, onSuccess])\n\n  useEffect(() => {\n    if (oauthStatus.state === 'starting') {\n      void startOAuth()\n    }\n  }, [oauthStatus.state, startOAuth])\n\n  // Retry logic\n  useEffect(() => {\n    if (oauthStatus.state === 'about_to_retry') {\n      const timer = setTimeout(\n        (nextState, setShowPastePrompt, setOAuthStatus) => {\n          // Only show paste prompt when retrying to waiting_for_login\n          setShowPastePrompt(nextState.state === 'waiting_for_login')\n          setOAuthStatus(nextState)\n        },\n        500,\n        oauthStatus.nextState,\n        setShowPastePrompt,\n        setOAuthStatus,\n      )\n      timersRef.current.add(timer)\n    }\n  }, [oauthStatus])\n\n  useEffect(() => {\n    if (\n      pastedCode === 'c' &&\n      oauthStatus.state === 'waiting_for_login' &&\n      showPastePrompt &&\n      !urlCopied\n    ) {\n      void setClipboard(oauthStatus.url).then(raw => {\n        if (raw) process.stdout.write(raw)\n        setUrlCopied(true)\n        clearTimeout(urlCopiedTimerRef.current)\n        urlCopiedTimerRef.current = setTimeout(setUrlCopied, 2000, false)\n      })\n      setPastedCode('')\n    }\n  }, [pastedCode, oauthStatus, showPastePrompt, urlCopied])\n\n  // Cleanup OAuth service and timers when component unmounts\n  useEffect(() => {\n    const timers = timersRef.current\n    return () => {\n      oauthService.cleanup()\n      // Clear all timers\n      timers.forEach(timer => clearTimeout(timer))\n      timers.clear()\n      clearTimeout(urlCopiedTimerRef.current)\n    }\n  }, [oauthService])\n\n  // Helper function to render the appropriate status message\n  function renderStatusMessage(): React.ReactNode {\n    switch (oauthStatus.state) {\n      case 'starting':\n        return (\n          <Box>\n            <Spinner />\n            <Text>Starting authentication…</Text>\n          </Box>\n        )\n\n      case 'waiting_for_login':\n        return (\n          <Box flexDirection=\"column\" gap={1}>\n            {!showPastePrompt && (\n              <Box>\n                <Spinner />\n                <Text>\n                  Opening browser to sign in with your Claude account…\n                </Text>\n              </Box>\n            )}\n\n            {showPastePrompt && (\n              <Box>\n                <Text>{PASTE_HERE_MSG}</Text>\n                <TextInput\n                  value={pastedCode}\n                  onChange={setPastedCode}\n                  onSubmit={(value: string) =>\n                    handleSubmitCode(value, oauthStatus.url)\n                  }\n                  cursorOffset={cursorOffset}\n                  onChangeCursorOffset={setCursorOffset}\n                  columns={textInputColumns}\n                />\n              </Box>\n            )}\n          </Box>\n        )\n\n      case 'processing':\n        return (\n          <Box>\n            <Spinner />\n            <Text>Processing authentication…</Text>\n          </Box>\n        )\n\n      case 'success':\n        return (\n          <Box flexDirection=\"column\" gap={1}>\n            <Text color=\"success\">\n              ✓ Authentication token created successfully!\n            </Text>\n            <Text dimColor>Using token for GitHub Actions setup…</Text>\n          </Box>\n        )\n\n      case 'error':\n        return (\n          <Box flexDirection=\"column\" gap={1}>\n            <Text color=\"error\">OAuth error: {oauthStatus.message}</Text>\n            {oauthStatus.toRetry ? (\n              <Text dimColor>\n                Press Enter to try again, or any other key to cancel\n              </Text>\n            ) : (\n              <Text dimColor>Press any key to return to API key selection</Text>\n            )}\n          </Box>\n        )\n\n      case 'about_to_retry':\n        return (\n          <Box flexDirection=\"column\" gap={1}>\n            <Text color=\"permission\">Retrying…</Text>\n          </Box>\n        )\n\n      default:\n        return null\n    }\n  }\n\n  return (\n    <Box\n      flexDirection=\"column\"\n      gap={1}\n      tabIndex={0}\n      autoFocus\n      onKeyDown={handleKeyDown}\n    >\n      {/* Show header inline only for initial starting state */}\n      {oauthStatus.state === 'starting' && (\n        <Box flexDirection=\"column\" gap={1} paddingBottom={1}>\n          <Text bold>Create Authentication Token</Text>\n          <Text dimColor>Creating a long-lived token for GitHub Actions</Text>\n        </Box>\n      )}\n      {/* Show header for non-starting states (to avoid duplicate with inline header)*/}\n      {oauthStatus.state !== 'success' &&\n        oauthStatus.state !== 'starting' &&\n        oauthStatus.state !== 'processing' && (\n          <Box key=\"header\" flexDirection=\"column\" gap={1} paddingBottom={1}>\n            <Text bold>Create Authentication Token</Text>\n            <Text dimColor>Creating a long-lived token for GitHub Actions</Text>\n          </Box>\n        )}\n      {/* Show URL when paste prompt is visible */}\n      {oauthStatus.state === 'waiting_for_login' && showPastePrompt && (\n        <Box flexDirection=\"column\" key=\"urlToCopy\" gap={1} paddingBottom={1}>\n          <Box paddingX={1}>\n            <Text dimColor>\n              Browser didn&apos;t open? Use the url below to sign in{' '}\n            </Text>\n            {urlCopied ? (\n              <Text color=\"success\">(Copied!)</Text>\n            ) : (\n              <Text dimColor>\n                <KeyboardShortcutHint shortcut=\"c\" action=\"copy\" parens />\n              </Text>\n            )}\n          </Box>\n          <Link url={oauthStatus.url}>\n            <Text dimColor>{oauthStatus.url}</Text>\n          </Link>\n        </Box>\n      )}\n      <Box paddingLeft={1} flexDirection=\"column\" gap={1}>\n        {renderStatusMessage()}\n      </Box>\n    </Box>\n  )\n}\n"],"mappings":"AAAA,OAAOA,KAAK,IAAIC,WAAW,EAAEC,SAAS,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,OAAO;AACvE,SACE,KAAKC,0DAA0D,EAC/DC,QAAQ,QACH,iCAAiC;AACxC,SAASC,oBAAoB,QAAQ,wDAAwD;AAC7F,SAASC,OAAO,QAAQ,6BAA6B;AACrD,OAAOC,SAAS,MAAM,+BAA+B;AACrD,SAASC,eAAe,QAAQ,gCAAgC;AAChE,cAAcC,aAAa,QAAQ,oCAAoC;AACvE,SAASC,YAAY,QAAQ,yBAAyB;AACtD,SAASC,GAAG,EAAEC,IAAI,EAAEC,IAAI,QAAQ,cAAc;AAC9C,SAASC,YAAY,QAAQ,+BAA+B;AAC5D,SAASC,uBAAuB,QAAQ,qBAAqB;AAC7D,SAASC,QAAQ,QAAQ,oBAAoB;AAE7C,UAAUC,kBAAkB,CAAC;EAC3BC,SAAS,EAAE,CAACC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;EAClCC,QAAQ,EAAE,GAAG,GAAG,IAAI;AACtB;AAEA,KAAKC,WAAW,GACZ;EAAEC,KAAK,EAAE,UAAU;AAAC,CAAC,GACrB;EAAEA,KAAK,EAAE,mBAAmB;EAAEC,GAAG,EAAE,MAAM;AAAC,CAAC,GAC3C;EAAED,KAAK,EAAE,YAAY;AAAC,CAAC,GACvB;EAAEA,KAAK,EAAE,SAAS;EAAEH,KAAK,EAAE,MAAM;AAAC,CAAC,GACnC;EAAEG,KAAK,EAAE,OAAO;EAAEE,OAAO,EAAE,MAAM;EAAEC,OAAO,CAAC,EAAEJ,WAAW;AAAC,CAAC,GAC1D;EAAEC,KAAK,EAAE,gBAAgB;EAAEI,SAAS,EAAEL,WAAW;AAAC,CAAC;AAEvD,MAAMM,cAAc,GAAG,gCAAgC;AAEvD,OAAO,SAASC,aAAaA,CAAC;EAC5BV,SAAS;EACTE;AACkB,CAAnB,EAAEH,kBAAkB,CAAC,EAAEnB,KAAK,CAAC+B,SAAS,CAAC;EACtC,MAAM,CAACC,WAAW,EAAEC,cAAc,CAAC,GAAG7B,QAAQ,CAACmB,WAAW,CAAC,CAAC;IAC1DC,KAAK,EAAE;EACT,CAAC,CAAC;EACF,MAAM,CAACU,YAAY,CAAC,GAAG9B,QAAQ,CAAC,MAAM,IAAIY,YAAY,CAAC,CAAC,CAAC;EACzD,MAAM,CAACmB,UAAU,EAAEC,aAAa,CAAC,GAAGhC,QAAQ,CAAC,EAAE,CAAC;EAChD,MAAM,CAACiC,YAAY,EAAEC,eAAe,CAAC,GAAGlC,QAAQ,CAAC,CAAC,CAAC;EACnD,MAAM,CAACmC,eAAe,EAAEC,kBAAkB,CAAC,GAAGpC,QAAQ,CAAC,KAAK,CAAC;EAC7D,MAAM,CAACqC,SAAS,EAAEC,YAAY,CAAC,GAAGtC,QAAQ,CAAC,KAAK,CAAC;EACjD,MAAMuC,SAAS,GAAGxC,MAAM,CAACyC,GAAG,CAACC,MAAM,CAACC,OAAO,CAAC,CAAC,CAAC,IAAIF,GAAG,CAAC,CAAC,CAAC;EACxD;EACA,MAAMG,iBAAiB,GAAG5C,MAAM,CAAC0C,MAAM,CAACC,OAAO,GAAG,SAAS,CAAC,CAACE,SAAS,CAAC;EAEvE,MAAMC,YAAY,GAAGvC,eAAe,CAAC,CAAC;EACtC,MAAMwC,gBAAgB,GAAGC,IAAI,CAACC,GAAG,CAC/B,EAAE,EACFH,YAAY,CAACI,OAAO,GAAGxB,cAAc,CAACyB,MAAM,GAAG,CACjD,CAAC;EAED,SAASC,aAAaA,CAACC,CAAC,EAAE7C,aAAa,CAAC,EAAE,IAAI,CAAC;IAC7C,IAAIqB,WAAW,CAACR,KAAK,KAAK,OAAO,EAAE;IACnCgC,CAAC,CAACC,cAAc,CAAC,CAAC;IAClB,IAAID,CAAC,CAACE,GAAG,KAAK,QAAQ,IAAI1B,WAAW,CAACL,OAAO,EAAE;MAC7CS,aAAa,CAAC,EAAE,CAAC;MACjBE,eAAe,CAAC,CAAC,CAAC;MAClBL,cAAc,CAAC;QACbT,KAAK,EAAE,gBAAgB;QACvBI,SAAS,EAAEI,WAAW,CAACL;MACzB,CAAC,CAAC;IACJ,CAAC,MAAM;MACLL,QAAQ,CAAC,CAAC;IACZ;EACF;EAEA,eAAeqC,gBAAgBA,CAACC,KAAK,EAAE,MAAM,EAAEnC,GAAG,EAAE,MAAM,EAAE;IAC1D,IAAI;MACF;MACA,MAAM,CAACoC,iBAAiB,EAAErC,KAAK,CAAC,GAAGoC,KAAK,CAACE,KAAK,CAAC,GAAG,CAAC;MAEnD,IAAI,CAACD,iBAAiB,IAAI,CAACrC,KAAK,EAAE;QAChCS,cAAc,CAAC;UACbT,KAAK,EAAE,OAAO;UACdE,OAAO,EAAE,yDAAyD;UAClEC,OAAO,EAAE;YAAEH,KAAK,EAAE,mBAAmB;YAAEC;UAAI;QAC7C,CAAC,CAAC;QACF;MACF;;MAEA;MACAnB,QAAQ,CAAC,0BAA0B,EAAE,CAAC,CAAC,CAAC;MACxC4B,YAAY,CAAC6B,yBAAyB,CAAC;QACrCF,iBAAiB;QACjBrC;MACF,CAAC,CAAC;IACJ,CAAC,CAAC,OAAOwC,GAAG,EAAE,OAAO,EAAE;MACrB9C,QAAQ,CAAC8C,GAAG,CAAC;MACb/B,cAAc,CAAC;QACbT,KAAK,EAAE,OAAO;QACdE,OAAO,EAAE,CAACsC,GAAG,IAAIC,KAAK,EAAEvC,OAAO;QAC/BC,OAAO,EAAE;UAAEH,KAAK,EAAE,mBAAmB;UAAEC;QAAI;MAC7C,CAAC,CAAC;IACJ;EACF;EAEA,MAAMyC,UAAU,GAAGjE,WAAW,CAAC,YAAY;IACzC;IACA0C,SAAS,CAACwB,OAAO,CAACC,OAAO,CAACC,KAAK,IAAIC,YAAY,CAACD,KAAK,CAAC,CAAC;IACvD1B,SAAS,CAACwB,OAAO,CAACI,KAAK,CAAC,CAAC;IAEzB,IAAI;MACF,MAAMC,MAAM,GAAG,MAAMtC,YAAY,CAACuC,cAAc,CAC9C,MAAMhD,KAAG,IAAI;QACXQ,cAAc,CAAC;UAAET,KAAK,EAAE,mBAAmB;UAAEC,GAAG,EAAHA;QAAI,CAAC,CAAC;QACnD,MAAM4C,OAAK,GAAGK,UAAU,CAAClC,kBAAkB,EAAE,IAAI,EAAE,IAAI,CAAC;QACxDG,SAAS,CAACwB,OAAO,CAACQ,GAAG,CAACN,OAAK,CAAC;MAC9B,CAAC,EACD;QACEO,iBAAiB,EAAE,IAAI;QAAE;QACzBC,aAAa,EAAE,IAAI;QACnBC,SAAS,EAAE,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAE;MACjC,CACF,CAAC;;MAED;MACA7C,cAAc,CAAC;QAAET,KAAK,EAAE;MAAa,CAAC,CAAC;;MAEvC;MACA;MACA;MACAP,uBAAuB,CAACuD,MAAM,CAAC;;MAE/B;MACA,MAAMO,MAAM,GAAGL,UAAU,CACvB,CAACzC,gBAAc,EAAE+C,WAAW,EAAE5D,WAAS,EAAEuB,WAAS,KAAK;QACrDV,gBAAc,CAAC;UAAET,KAAK,EAAE,SAAS;UAAEH,KAAK,EAAE2D;QAAY,CAAC,CAAC;QACxD;QACA,MAAMC,MAAM,GAAGP,UAAU,CAACtD,WAAS,EAAE,IAAI,EAAE4D,WAAW,CAAC;QACvDrC,WAAS,CAACwB,OAAO,CAACQ,GAAG,CAACM,MAAM,CAAC;MAC/B,CAAC,EACD,GAAG,EACHhD,cAAc,EACduC,MAAM,CAACQ,WAAW,EAClB5D,SAAS,EACTuB,SACF,CAAC;MACDA,SAAS,CAACwB,OAAO,CAACQ,GAAG,CAACI,MAAM,CAAC;IAC/B,CAAC,CAAC,OAAOf,KAAG,EAAE;MACZ,MAAMkB,YAAY,GAAG,CAAClB,KAAG,IAAIC,KAAK,EAAEvC,OAAO;MAC3CO,cAAc,CAAC;QACbT,KAAK,EAAE,OAAO;QACdE,OAAO,EAAEwD,YAAY;QACrBvD,OAAO,EAAE;UAAEH,KAAK,EAAE;QAAW,CAAC,CAAE;MAClC,CAAC,CAAC;MACFN,QAAQ,CAAC8C,KAAG,CAAC;MACb1D,QAAQ,CAAC,mBAAmB,EAAE;QAC5B6E,KAAK,EACHD,YAAY,IAAI7E;MACpB,CAAC,CAAC;IACJ;EACF,CAAC,EAAE,CAAC6B,YAAY,EAAEd,SAAS,CAAC,CAAC;EAE7BlB,SAAS,CAAC,MAAM;IACd,IAAI8B,WAAW,CAACR,KAAK,KAAK,UAAU,EAAE;MACpC,KAAK0C,UAAU,CAAC,CAAC;IACnB;EACF,CAAC,EAAE,CAAClC,WAAW,CAACR,KAAK,EAAE0C,UAAU,CAAC,CAAC;;EAEnC;EACAhE,SAAS,CAAC,MAAM;IACd,IAAI8B,WAAW,CAACR,KAAK,KAAK,gBAAgB,EAAE;MAC1C,MAAM6C,OAAK,GAAGK,UAAU,CACtB,CAAC9C,SAAS,EAAEY,oBAAkB,EAAEP,gBAAc,KAAK;QACjD;QACAO,oBAAkB,CAACZ,SAAS,CAACJ,KAAK,KAAK,mBAAmB,CAAC;QAC3DS,gBAAc,CAACL,SAAS,CAAC;MAC3B,CAAC,EACD,GAAG,EACHI,WAAW,CAACJ,SAAS,EACrBY,kBAAkB,EAClBP,cACF,CAAC;MACDU,SAAS,CAACwB,OAAO,CAACQ,GAAG,CAACN,OAAK,CAAC;IAC9B;EACF,CAAC,EAAE,CAACrC,WAAW,CAAC,CAAC;EAEjB9B,SAAS,CAAC,MAAM;IACd,IACEiC,UAAU,KAAK,GAAG,IAClBH,WAAW,CAACR,KAAK,KAAK,mBAAmB,IACzCe,eAAe,IACf,CAACE,SAAS,EACV;MACA,KAAK7B,YAAY,CAACoB,WAAW,CAACP,GAAG,CAAC,CAAC2D,IAAI,CAACC,GAAG,IAAI;QAC7C,IAAIA,GAAG,EAAEC,OAAO,CAACC,MAAM,CAACC,KAAK,CAACH,GAAG,CAAC;QAClC3C,YAAY,CAAC,IAAI,CAAC;QAClB4B,YAAY,CAACvB,iBAAiB,CAACoB,OAAO,CAAC;QACvCpB,iBAAiB,CAACoB,OAAO,GAAGO,UAAU,CAAChC,YAAY,EAAE,IAAI,EAAE,KAAK,CAAC;MACnE,CAAC,CAAC;MACFN,aAAa,CAAC,EAAE,CAAC;IACnB;EACF,CAAC,EAAE,CAACD,UAAU,EAAEH,WAAW,EAAEO,eAAe,EAAEE,SAAS,CAAC,CAAC;;EAEzD;EACAvC,SAAS,CAAC,MAAM;IACd,MAAMuF,MAAM,GAAG9C,SAAS,CAACwB,OAAO;IAChC,OAAO,MAAM;MACXjC,YAAY,CAACwD,OAAO,CAAC,CAAC;MACtB;MACAD,MAAM,CAACrB,OAAO,CAACC,OAAK,IAAIC,YAAY,CAACD,OAAK,CAAC,CAAC;MAC5CoB,MAAM,CAAClB,KAAK,CAAC,CAAC;MACdD,YAAY,CAACvB,iBAAiB,CAACoB,OAAO,CAAC;IACzC,CAAC;EACH,CAAC,EAAE,CAACjC,YAAY,CAAC,CAAC;;EAElB;EACA,SAASyD,mBAAmBA,CAAA,CAAE,EAAE3F,KAAK,CAAC+B,SAAS,CAAC;IAC9C,QAAQC,WAAW,CAACR,KAAK;MACvB,KAAK,UAAU;QACb,OACE,CAAC,GAAG;AACd,YAAY,CAAC,OAAO;AACpB,YAAY,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI;AAChD,UAAU,EAAE,GAAG,CAAC;MAGV,KAAK,mBAAmB;QACtB,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC7C,YAAY,CAAC,CAACe,eAAe,IACf,CAAC,GAAG;AAClB,gBAAgB,CAAC,OAAO;AACxB,gBAAgB,CAAC,IAAI;AACrB;AACA,gBAAgB,EAAE,IAAI;AACtB,cAAc,EAAE,GAAG,CACN;AACb;AACA,YAAY,CAACA,eAAe,IACd,CAAC,GAAG;AAClB,gBAAgB,CAAC,IAAI,CAAC,CAACV,cAAc,CAAC,EAAE,IAAI;AAC5C,gBAAgB,CAAC,SAAS,CACR,KAAK,CAAC,CAACM,UAAU,CAAC,CAClB,QAAQ,CAAC,CAACC,aAAa,CAAC,CACxB,QAAQ,CAAC,CAAC,CAACwB,OAAK,EAAE,MAAM,KACtBD,gBAAgB,CAACC,OAAK,EAAE5B,WAAW,CAACP,GAAG,CACzC,CAAC,CACD,YAAY,CAAC,CAACY,YAAY,CAAC,CAC3B,oBAAoB,CAAC,CAACC,eAAe,CAAC,CACtC,OAAO,CAAC,CAACY,gBAAgB,CAAC;AAE5C,cAAc,EAAE,GAAG,CACN;AACb,UAAU,EAAE,GAAG,CAAC;MAGV,KAAK,YAAY;QACf,OACE,CAAC,GAAG;AACd,YAAY,CAAC,OAAO;AACpB,YAAY,CAAC,IAAI,CAAC,0BAA0B,EAAE,IAAI;AAClD,UAAU,EAAE,GAAG,CAAC;MAGV,KAAK,SAAS;QACZ,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC7C,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS;AACjC;AACA,YAAY,EAAE,IAAI;AAClB,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,qCAAqC,EAAE,IAAI;AACtE,UAAU,EAAE,GAAG,CAAC;MAGV,KAAK,OAAO;QACV,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC7C,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAClB,WAAW,CAACN,OAAO,CAAC,EAAE,IAAI;AACxE,YAAY,CAACM,WAAW,CAACL,OAAO,GAClB,CAAC,IAAI,CAAC,QAAQ;AAC5B;AACA,cAAc,EAAE,IAAI,CAAC,GAEP,CAAC,IAAI,CAAC,QAAQ,CAAC,4CAA4C,EAAE,IAAI,CAClE;AACb,UAAU,EAAE,GAAG,CAAC;MAGV,KAAK,gBAAgB;QACnB,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC7C,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI;AACpD,UAAU,EAAE,GAAG,CAAC;MAGV;QACE,OAAO,IAAI;IACf;EACF;EAEA,OACE,CAAC,GAAG,CACF,aAAa,CAAC,QAAQ,CACtB,GAAG,CAAC,CAAC,CAAC,CAAC,CACP,QAAQ,CAAC,CAAC,CAAC,CAAC,CACZ,SAAS,CACT,SAAS,CAAC,CAAC4B,aAAa,CAAC;AAE/B,MAAM,CAAC,wDAAwD;AAC/D,MAAM,CAACvB,WAAW,CAACR,KAAK,KAAK,UAAU,IAC/B,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;AAC7D,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,2BAA2B,EAAE,IAAI;AACtD,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,8CAA8C,EAAE,IAAI;AAC7E,QAAQ,EAAE,GAAG,CACN;AACP,MAAM,CAAC,gFAAgF;AACvF,MAAM,CAACQ,WAAW,CAACR,KAAK,KAAK,SAAS,IAC9BQ,WAAW,CAACR,KAAK,KAAK,UAAU,IAChCQ,WAAW,CAACR,KAAK,KAAK,YAAY,IAChC,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;AAC5E,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,2BAA2B,EAAE,IAAI;AACxD,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,8CAA8C,EAAE,IAAI;AAC/E,UAAU,EAAE,GAAG,CACN;AACT,MAAM,CAAC,2CAA2C;AAClD,MAAM,CAACQ,WAAW,CAACR,KAAK,KAAK,mBAAmB,IAAIe,eAAe,IAC3D,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;AAC7E,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAC3B,YAAY,CAAC,IAAI,CAAC,QAAQ;AAC1B,oEAAoE,CAAC,GAAG;AACxE,YAAY,EAAE,IAAI;AAClB,YAAY,CAACE,SAAS,GACR,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC,GAEtC,CAAC,IAAI,CAAC,QAAQ;AAC5B,gBAAgB,CAAC,oBAAoB,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM;AACvE,cAAc,EAAE,IAAI,CACP;AACb,UAAU,EAAE,GAAG;AACf,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAACT,WAAW,CAACP,GAAG,CAAC;AACrC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAACO,WAAW,CAACP,GAAG,CAAC,EAAE,IAAI;AAClD,UAAU,EAAE,IAAI;AAChB,QAAQ,EAAE,GAAG,CACN;AACP,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACzD,QAAQ,CAACkE,mBAAmB,CAAC,CAAC;AAC9B,MAAM,EAAE,GAAG;AACX,IAAI,EAAE,GAAG,CAAC;AAEV","ignoreList":[]}

package/src/commands/install-github-app/SuccessStep.tsx

@@ -0,0 +1,96 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { Box, Text } from '../../ink.js';
+type SuccessStepProps = {
+  secretExists: boolean;
+  useExistingSecret: boolean;
+  secretName: string;
+  skipWorkflow?: boolean;
+};
+export function SuccessStep(t0) {
+  const $ = _c(21);
+  const {
+    secretExists,
+    useExistingSecret,
+    secretName,
+    skipWorkflow: t1
+  } = t0;
+  const skipWorkflow = t1 === undefined ? false : t1;
+  let t2;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Box flexDirection="column" marginBottom={1}><Text bold={true}>Install GitHub App</Text><Text dimColor={true}>Success</Text></Box>;
+    $[0] = t2;
+  } else {
+    t2 = $[0];
+  }
+  let t3;
+  if ($[1] !== skipWorkflow) {
+    t3 = !skipWorkflow && <Text color="success">✓ GitHub Actions workflow created!</Text>;
+    $[1] = skipWorkflow;
+    $[2] = t3;
+  } else {
+    t3 = $[2];
+  }
+  let t4;
+  if ($[3] !== secretExists || $[4] !== useExistingSecret) {
+    t4 = secretExists && useExistingSecret && <Box marginTop={1}><Text color="success">✓ Using existing ANTHROPIC_API_KEY secret</Text></Box>;
+    $[3] = secretExists;
+    $[4] = useExistingSecret;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== secretExists || $[7] !== secretName || $[8] !== useExistingSecret) {
+    t5 = (!secretExists || !useExistingSecret) && <Box marginTop={1}><Text color="success">✓ API key saved as {secretName} secret</Text></Box>;
+    $[6] = secretExists;
+    $[7] = secretName;
+    $[8] = useExistingSecret;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  let t6;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = <Box marginTop={1}><Text>Next steps:</Text></Box>;
+    $[10] = t6;
+  } else {
+    t6 = $[10];
+  }
+  let t7;
+  if ($[11] !== skipWorkflow) {
+    t7 = skipWorkflow ? <><Text>1. Install the Claude GitHub App if you haven't already</Text><Text>2. Your workflow file was kept unchanged</Text><Text>3. API key is configured and ready to use</Text></> : <><Text>1. A pre-filled PR page has been created</Text><Text>2. Install the Claude GitHub App if you haven't already</Text><Text>3. Merge the PR to enable Claude PR assistance</Text></>;
+    $[11] = skipWorkflow;
+    $[12] = t7;
+  } else {
+    t7 = $[12];
+  }
+  let t8;
+  if ($[13] !== t3 || $[14] !== t4 || $[15] !== t5 || $[16] !== t7) {
+    t8 = <Box flexDirection="column" borderStyle="round" paddingX={1}>{t2}{t3}{t4}{t5}{t6}{t7}</Box>;
+    $[13] = t3;
+    $[14] = t4;
+    $[15] = t5;
+    $[16] = t7;
+    $[17] = t8;
+  } else {
+    t8 = $[17];
+  }
+  let t9;
+  if ($[18] === Symbol.for("react.memo_cache_sentinel")) {
+    t9 = <Box marginLeft={3}><Text dimColor={true}>Press any key to exit</Text></Box>;
+    $[18] = t9;
+  } else {
+    t9 = $[18];
+  }
+  let t10;
+  if ($[19] !== t8) {
+    t10 = <>{t8}{t9}</>;
+    $[19] = t8;
+    $[20] = t10;
+  } else {
+    t10 = $[20];
+  }
+  return t10;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/commands/install-github-app/WarningsStep.tsx

@@ -0,0 +1,73 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import React from 'react';
+import { GITHUB_ACTION_SETUP_DOCS_URL } from '../../constants/github-app.js';
+import { Box, Text } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import type { Warning } from './types.js';
+interface WarningsStepProps {
+  warnings: Warning[];
+  onContinue: () => void;
+}
+export function WarningsStep(t0) {
+  const $ = _c(8);
+  const {
+    warnings,
+    onContinue
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = {
+      context: "Confirmation"
+    };
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  useKeybinding("confirm:yes", onContinue, t1);
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Box flexDirection="column" marginBottom={1}><Text bold={true}>{figures.warning} Setup Warnings</Text><Text dimColor={true}>We found some potential issues, but you can continue anyway</Text></Box>;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  let t3;
+  if ($[2] !== warnings) {
+    t3 = warnings.map(_temp2);
+    $[2] = warnings;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  let t4;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = <Box marginTop={1}><Text bold={true} color="permission">Press Enter to continue anyway, or Ctrl+C to exit and fix issues</Text></Box>;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = <Box marginTop={1}><Text dimColor={true}>You can also try the manual setup steps if needed:{" "}<Text color="claude">{GITHUB_ACTION_SETUP_DOCS_URL}</Text></Text></Box>;
+    $[5] = t5;
+  } else {
+    t5 = $[5];
+  }
+  let t6;
+  if ($[6] !== t3) {
+    t6 = <><Box flexDirection="column" borderStyle="round" paddingX={1}>{t2}{t3}{t4}{t5}</Box></>;
+    $[6] = t3;
+    $[7] = t6;
+  } else {
+    t6 = $[7];
+  }
+  return t6;
+}
+function _temp2(warning, index) {
+  return <Box key={index} flexDirection="column" marginBottom={1}><Text color="warning" bold={true}>{warning.title}</Text><Text>{warning.message}</Text>{warning.instructions.length > 0 && <Box flexDirection="column" marginLeft={2} marginTop={1}>{warning.instructions.map(_temp)}</Box>}</Box>;
+}
+function _temp(instruction, i) {
+  return <Text key={i} dimColor={true}>• {instruction}</Text>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmaWd1cmVzIiwiUmVhY3QiLCJHSVRIVUJfQUNUSU9OX1NFVFVQX0RPQ1NfVVJMIiwiQm94IiwiVGV4dCIsInVzZUtleWJpbmRpbmciLCJXYXJuaW5nIiwiV2FybmluZ3NTdGVwUHJvcHMiLCJ3YXJuaW5ncyIsIm9uQ29udGludWUiLCJXYXJuaW5nc1N0ZXAiLCJ0MCIsIiQiLCJfYyIsInQxIiwiU3ltYm9sIiwiZm9yIiwiY29udGV4dCIsInQyIiwid2FybmluZyIsInQzIiwibWFwIiwiX3RlbXAyIiwidDQiLCJ0NSIsInQ2IiwiaW5kZXgiLCJ0aXRsZSIsIm1lc3NhZ2UiLCJpbnN0cnVjdGlvbnMiLCJsZW5ndGgiLCJfdGVtcCIsImluc3RydWN0aW9uIiwiaSJdLCJzb3VyY2VzIjpbIldhcm5pbmdzU3RlcC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGZpZ3VyZXMgZnJvbSAnZmlndXJlcydcbmltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCdcbmltcG9ydCB7IEdJVEhVQl9BQ1RJT05fU0VUVVBfRE9DU19VUkwgfSBmcm9tICcuLi8uLi9jb25zdGFudHMvZ2l0aHViLWFwcC5qcydcbmltcG9ydCB7IEJveCwgVGV4dCB9IGZyb20gJy4uLy4uL2luay5qcydcbmltcG9ydCB7IHVzZUtleWJpbmRpbmcgfSBmcm9tICcuLi8uLi9rZXliaW5kaW5ncy91c2VLZXliaW5kaW5nLmpzJ1xuaW1wb3J0IHR5cGUgeyBXYXJuaW5nIH0gZnJvbSAnLi90eXBlcy5qcydcblxuaW50ZXJmYWNlIFdhcm5pbmdzU3RlcFByb3BzIHtcbiAgd2FybmluZ3M6IFdhcm5pbmdbXVxuICBvbkNvbnRpbnVlOiAoKSA9PiB2b2lkXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBXYXJuaW5nc1N0ZXAoeyB3YXJuaW5ncywgb25Db250aW51ZSB9OiBXYXJuaW5nc1N0ZXBQcm9wcykge1xuICAvLyBFbnRlciB0byBjb250aW51ZVxuICB1c2VLZXliaW5kaW5nKCdjb25maXJtOnllcycsIG9uQ29udGludWUsIHsgY29udGV4dDogJ0NvbmZpcm1hdGlvbicgfSlcblxuICByZXR1cm4gKFxuICAgIDw+XG4gICAgICA8Qm94IGZsZXhEaXJlY3Rpb249XCJjb2x1bW5cIiBib3JkZXJTdHlsZT1cInJvdW5kXCIgcGFkZGluZ1g9ezF9PlxuICAgICAgICA8Qm94IGZsZXhEaXJlY3Rpb249XCJjb2x1bW5cIiBtYXJnaW5Cb3R0b209ezF9PlxuICAgICAgICAgIDxUZXh0IGJvbGQ+e2ZpZ3VyZXMud2FybmluZ30gU2V0dXAgV2FybmluZ3M8L1RleHQ+XG4gICAgICAgICAgPFRleHQgZGltQ29sb3I+XG4gICAgICAgICAgICBXZSBmb3VuZCBzb21lIHBvdGVudGlhbCBpc3N1ZXMsIGJ1dCB5b3UgY2FuIGNvbnRpbnVlIGFueXdheVxuICAgICAgICAgIDwvVGV4dD5cbiAgICAgICAgPC9Cb3g+XG5cbiAgICAgICAge3dhcm5pbmdzLm1hcCgod2FybmluZywgaW5kZXgpID0+IChcbiAgICAgICAgICA8Qm94IGtleT17aW5kZXh9IGZsZXhEaXJlY3Rpb249XCJjb2x1bW5cIiBtYXJnaW5Cb3R0b209ezF9PlxuICAgICAgICAgICAgPFRleHQgY29sb3I9XCJ3YXJuaW5nXCIgYm9sZD5cbiAgICAgICAgICAgICAge3dhcm5pbmcudGl0bGV9XG4gICAgICAgICAgICA8L1RleHQ+XG4gICAgICAgICAgICA8VGV4dD57d2FybmluZy5tZXNzYWdlfTwvVGV4dD5cbiAgICAgICAgICAgIHt3YXJuaW5nLmluc3RydWN0aW9ucy5sZW5ndGggPiAwICYmIChcbiAgICAgICAgICAgICAgPEJveCBmbGV4RGlyZWN0aW9uPVwiY29sdW1uXCIgbWFyZ2luTGVmdD17Mn0gbWFyZ2luVG9wPXsxfT5cbiAgICAgICAgICAgICAgICB7d2FybmluZy5pbnN0cnVjdGlvbnMubWFwKChpbnN0cnVjdGlvbiwgaSkgPT4gKFxuICAgICAgICAgICAgICAgICAgPFRleHQga2V5PXtpfSBkaW1Db2xvcj5cbiAgICAgICAgICAgICAgICAgICAg4oCiIHtpbnN0cnVjdGlvbn1cbiAgICAgICAgICAgICAgICAgIDwvVGV4dD5cbiAgICAgICAgICAgICAgICApKX1cbiAgICAgICAgICAgICAgPC9Cb3g+XG4gICAgICAgICAgICApfVxuICAgICAgICAgIDwvQm94PlxuICAgICAgICApKX1cblxuICAgICAgICA8Qm94IG1hcmdpblRvcD17MX0+XG4gICAgICAgICAgPFRleHQgYm9sZCBjb2xvcj1cInBlcm1pc3Npb25cIj5cbiAgICAgICAgICAgIFByZXNzIEVudGVyIHRvIGNvbnRpbnVlIGFueXdheSwgb3IgQ3RybCtDIHRvIGV4aXQgYW5kIGZpeCBpc3N1ZXNcbiAgICAgICAgICA8L1RleHQ+XG4gICAgICAgIDwvQm94PlxuICAgICAgICA8Qm94IG1hcmdpblRvcD17MX0+XG4gICAgICAgICAgPFRleHQgZGltQ29sb3I+XG4gICAgICAgICAgICBZb3UgY2FuIGFsc28gdHJ5IHRoZSBtYW51YWwgc2V0dXAgc3RlcHMgaWYgbmVlZGVkOnsnICd9XG4gICAgICAgICAgICA8VGV4dCBjb2xvcj1cImNsYXVkZVwiPntHSVRIVUJfQUNUSU9OX1NFVFVQX0RPQ1NfVVJMfTwvVGV4dD5cbiAgICAgICAgICA8L1RleHQ+XG4gICAgICAgIDwvQm94PlxuICAgICAgPC9Cb3g+XG4gICAgPC8+XG4gIClcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU9BLE9BQU8sTUFBTSxTQUFTO0FBQzdCLE9BQU9DLEtBQUssTUFBTSxPQUFPO0FBQ3pCLFNBQVNDLDRCQUE0QixRQUFRLCtCQUErQjtBQUM1RSxTQUFTQyxHQUFHLEVBQUVDLElBQUksUUFBUSxjQUFjO0FBQ3hDLFNBQVNDLGFBQWEsUUFBUSxvQ0FBb0M7QUFDbEUsY0FBY0MsT0FBTyxRQUFRLFlBQVk7QUFFekMsVUFBVUMsaUJBQWlCLENBQUM7RUFDMUJDLFFBQVEsRUFBRUYsT0FBTyxFQUFFO0VBQ25CRyxVQUFVLEVBQUUsR0FBRyxHQUFHLElBQUk7QUFDeEI7QUFFQSxPQUFPLFNBQUFDLGFBQUFDLEVBQUE7RUFBQSxNQUFBQyxDQUFBLEdBQUFDLEVBQUE7RUFBc0I7SUFBQUwsUUFBQTtJQUFBQztFQUFBLElBQUFFLEVBQTJDO0VBQUEsSUFBQUcsRUFBQTtFQUFBLElBQUFGLENBQUEsUUFBQUcsTUFBQSxDQUFBQyxHQUFBO0lBRTdCRixFQUFBO01BQUFHLE9BQUEsRUFBVztJQUFlLENBQUM7SUFBQUwsQ0FBQSxNQUFBRSxFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBRixDQUFBO0VBQUE7RUFBcEVQLGFBQWEsQ0FBQyxhQUFhLEVBQUVJLFVBQVUsRUFBRUssRUFBMkIsQ0FBQztFQUFBLElBQUFJLEVBQUE7RUFBQSxJQUFBTixDQUFBLFFBQUFHLE1BQUEsQ0FBQUMsR0FBQTtJQUsvREUsRUFBQSxJQUFDLEdBQUcsQ0FBZSxhQUFRLENBQVIsUUFBUSxDQUFlLFlBQUMsQ0FBRCxHQUFDLENBQ3pDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBSixLQUFHLENBQUMsQ0FBRSxDQUFBbEIsT0FBTyxDQUFBbUIsT0FBTyxDQUFFLGVBQWUsRUFBMUMsSUFBSSxDQUNMLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBUixLQUFPLENBQUMsQ0FBQywyREFFZixFQUZDLElBQUksQ0FHUCxFQUxDLEdBQUcsQ0FLRTtJQUFBUCxDQUFBLE1BQUFNLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFOLENBQUE7RUFBQTtFQUFBLElBQUFRLEVBQUE7RUFBQSxJQUFBUixDQUFBLFFBQUFKLFFBQUE7SUFFTFksRUFBQSxHQUFBWixRQUFRLENBQUFhLEdBQUksQ0FBQ0MsTUFnQmIsQ0FBQztJQUFBVixDQUFBLE1BQUFKLFFBQUE7SUFBQUksQ0FBQSxNQUFBUSxFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBUixDQUFBO0VBQUE7RUFBQSxJQUFBVyxFQUFBO0VBQUEsSUFBQVgsQ0FBQSxRQUFBRyxNQUFBLENBQUFDLEdBQUE7SUFFRk8sRUFBQSxJQUFDLEdBQUcsQ0FBWSxTQUFDLENBQUQsR0FBQyxDQUNmLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBSixLQUFHLENBQUMsQ0FBTyxLQUFZLENBQVosWUFBWSxDQUFDLGdFQUU5QixFQUZDLElBQUksQ0FHUCxFQUpDLEdBQUcsQ0FJRTtJQUFBWCxDQUFBLE1BQUFXLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFYLENBQUE7RUFBQTtFQUFBLElBQUFZLEVBQUE7RUFBQSxJQUFBWixDQUFBLFFBQUFHLE1BQUEsQ0FBQUMsR0FBQTtJQUNOUSxFQUFBLElBQUMsR0FBRyxDQUFZLFNBQUMsQ0FBRCxHQUFDLENBQ2YsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFSLEtBQU8sQ0FBQyxDQUFDLGtEQUNzQyxJQUFFLENBQ3JELENBQUMsSUFBSSxDQUFPLEtBQVEsQ0FBUixRQUFRLENBQUV0Qiw2QkFBMkIsQ0FBRSxFQUFsRCxJQUFJLENBQ1AsRUFIQyxJQUFJLENBSVAsRUFMQyxHQUFHLENBS0U7SUFBQVUsQ0FBQSxNQUFBWSxFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBWixDQUFBO0VBQUE7RUFBQSxJQUFBYSxFQUFBO0VBQUEsSUFBQWIsQ0FBQSxRQUFBUSxFQUFBO0lBckNWSyxFQUFBLEtBQ0UsQ0FBQyxHQUFHLENBQWUsYUFBUSxDQUFSLFFBQVEsQ0FBYSxXQUFPLENBQVAsT0FBTyxDQUFXLFFBQUMsQ0FBRCxHQUFDLENBQ3pELENBQUFQLEVBS0ssQ0FFSixDQUFBRSxFQWdCQSxDQUVELENBQUFHLEVBSUssQ0FDTCxDQUFBQyxFQUtLLENBQ1AsRUFyQ0MsR0FBRyxDQXFDRSxHQUNMO0lBQUFaLENBQUEsTUFBQVEsRUFBQTtJQUFBUixDQUFBLE1BQUFhLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFiLENBQUE7RUFBQTtFQUFBLE9BdkNIYSxFQXVDRztBQUFBO0FBNUNBLFNBQUFILE9BQUFILE9BQUEsRUFBQU8sS0FBQTtFQUFBLE9BZUcsQ0FBQyxHQUFHLENBQU1BLEdBQUssQ0FBTEEsTUFBSSxDQUFDLENBQWdCLGFBQVEsQ0FBUixRQUFRLENBQWUsWUFBQyxDQUFELEdBQUMsQ0FDckQsQ0FBQyxJQUFJLENBQU8sS0FBUyxDQUFULFNBQVMsQ0FBQyxJQUFJLENBQUosS0FBRyxDQUFDLENBQ3ZCLENBQUFQLE9BQU8sQ0FBQVEsS0FBSyxDQUNmLEVBRkMsSUFBSSxDQUdMLENBQUMsSUFBSSxDQUFFLENBQUFSLE9BQU8sQ0FBQVMsT0FBTyxDQUFFLEVBQXRCLElBQUksQ0FDSixDQUFBVCxPQUFPLENBQUFVLFlBQWEsQ0FBQUMsTUFBTyxHQUFHLENBUTlCLElBUEMsQ0FBQyxHQUFHLENBQWUsYUFBUSxDQUFSLFFBQVEsQ0FBYSxVQUFDLENBQUQsR0FBQyxDQUFhLFNBQUMsQ0FBRCxHQUFDLENBQ3BELENBQUFYLE9BQU8sQ0FBQVUsWUFBYSxDQUFBUixHQUFJLENBQUNVLEtBSXpCLEVBQ0gsRUFOQyxHQUFHLENBT04sQ0FDRixFQWRDLEdBQUcsQ0FjRTtBQUFBO0FBN0JULFNBQUFBLE1BQUFDLFdBQUEsRUFBQUMsQ0FBQTtFQUFBLE9BdUJXLENBQUMsSUFBSSxDQUFNQSxHQUFDLENBQURBLEVBQUEsQ0FBQyxDQUFFLFFBQVEsQ0FBUixLQUFPLENBQUMsQ0FBQyxFQUNsQkQsWUFBVSxDQUNmLEVBRkMsSUFBSSxDQUVFO0FBQUEiLCJpZ25vcmVMaXN0IjpbXX0=

package/src/commands/install-github-app/index.ts

@@ -0,0 +1,13 @@
+import type { Command } from '../../commands.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+const installGitHubApp = {
+  type: 'local-jsx',
+  name: 'install-github-app',
+  description: 'Set up Claude GitHub Actions for a repository',
+  availability: ['claude-ai', 'console'],
+  isEnabled: () => !isEnvTruthy(process.env.DISABLE_INSTALL_GITHUB_APP_COMMAND),
+  load: () => import('./install-github-app.js'),
+} satisfies Command
+
+export default installGitHubApp