@xelauvas/xela-cli 0.1.0

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

@@ -0,0 +1,587 @@
+import { execa } from 'execa';
+import React, { useCallback, useState } from 'react';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { WorkflowMultiselectDialog } from '../../components/WorkflowMultiselectDialog.js';
+import { GITHUB_ACTION_SETUP_DOCS_URL } from '../../constants/github-app.js';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import { Box } from '../../ink.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { getAnthropicApiKey, isAnthropicAuthEnabled } from '../../utils/auth.js';
+import { openBrowser } from '../../utils/browser.js';
+import { execFileNoThrow } from '../../utils/execFileNoThrow.js';
+import { getGithubRepo } from '../../utils/git.js';
+import { plural } from '../../utils/stringUtils.js';
+import { ApiKeyStep } from './ApiKeyStep.js';
+import { CheckExistingSecretStep } from './CheckExistingSecretStep.js';
+import { CheckGitHubStep } from './CheckGitHubStep.js';
+import { ChooseRepoStep } from './ChooseRepoStep.js';
+import { CreatingStep } from './CreatingStep.js';
+import { ErrorStep } from './ErrorStep.js';
+import { ExistingWorkflowStep } from './ExistingWorkflowStep.js';
+import { InstallAppStep } from './InstallAppStep.js';
+import { OAuthFlowStep } from './OAuthFlowStep.js';
+import { SuccessStep } from './SuccessStep.js';
+import { setupGitHubActions } from './setupGitHubActions.js';
+import type { State, Warning, Workflow } from './types.js';
+import { WarningsStep } from './WarningsStep.js';
+const INITIAL_STATE: State = {
+  step: 'check-gh',
+  selectedRepoName: '',
+  currentRepo: '',
+  useCurrentRepo: false,
+  // Default to false, will be set to true if repo detected
+  apiKeyOrOAuthToken: '',
+  useExistingKey: true,
+  currentWorkflowInstallStep: 0,
+  warnings: [],
+  secretExists: false,
+  secretName: 'ANTHROPIC_API_KEY',
+  useExistingSecret: true,
+  workflowExists: false,
+  selectedWorkflows: ['claude', 'claude-review'] as Workflow[],
+  selectedApiKeyOption: 'new' as 'existing' | 'new' | 'oauth',
+  authType: 'api_key'
+};
+function InstallGitHubApp(props: {
+  onDone: (message: string) => void;
+}): React.ReactNode {
+  const [existingApiKey] = useState(() => getAnthropicApiKey());
+  const [state, setState] = useState({
+    ...INITIAL_STATE,
+    useExistingKey: !!existingApiKey,
+    selectedApiKeyOption: (existingApiKey ? 'existing' : isAnthropicAuthEnabled() ? 'oauth' : 'new') as 'existing' | 'new' | 'oauth'
+  });
+  useExitOnCtrlCDWithKeybindings();
+  React.useEffect(() => {
+    logEvent('tengu_install_github_app_started', {});
+  }, []);
+  const checkGitHubCLI = useCallback(async () => {
+    const warnings: Warning[] = [];
+
+    // Check if gh is installed
+    const ghVersionResult = await execa('gh --version', {
+      shell: true,
+      reject: false
+    });
+    if (ghVersionResult.exitCode !== 0) {
+      warnings.push({
+        title: 'GitHub CLI not found',
+        message: 'GitHub CLI (gh) does not appear to be installed or accessible.',
+        instructions: ['Install GitHub CLI from https://cli.github.com/', 'macOS: brew install gh', 'Windows: winget install --id GitHub.cli', 'Linux: See installation instructions at https://github.com/cli/cli#installation']
+      });
+    }
+
+    // Check auth status
+    const authResult = await execa('gh auth status -a', {
+      shell: true,
+      reject: false
+    });
+    if (authResult.exitCode !== 0) {
+      warnings.push({
+        title: 'GitHub CLI not authenticated',
+        message: 'GitHub CLI does not appear to be authenticated.',
+        instructions: ['Run: gh auth login', 'Follow the prompts to authenticate with GitHub', 'Or set up authentication using environment variables or other methods']
+      });
+    } else {
+      // Check if required scopes are present in the Token scopes line
+      const tokenScopesMatch = authResult.stdout.match(/Token scopes:.*$/m);
+      if (tokenScopesMatch) {
+        const scopes = tokenScopesMatch[0];
+        const missingScopes: string[] = [];
+        if (!scopes.includes('repo')) {
+          missingScopes.push('repo');
+        }
+        if (!scopes.includes('workflow')) {
+          missingScopes.push('workflow');
+        }
+        if (missingScopes.length > 0) {
+          // Missing required scopes - exit immediately
+          setState(prev => ({
+            ...prev,
+            step: 'error',
+            error: `GitHub CLI is missing required permissions: ${missingScopes.join(', ')}.`,
+            errorReason: 'Missing required scopes',
+            errorInstructions: [`Your GitHub CLI authentication is missing the "${missingScopes.join('" and "')}" ${plural(missingScopes.length, 'scope')} needed to manage GitHub Actions and secrets.`, '', 'To fix this, run:', '  gh auth refresh -h github.com -s repo,workflow', '', 'This will add the necessary permissions to manage workflows and secrets.']
+          }));
+          return;
+        }
+      }
+    }
+
+    // Check if in a git repo and get remote URL
+    const currentRepo = (await getGithubRepo()) ?? '';
+    logEvent('tengu_install_github_app_step_completed', {
+      step: 'check-gh' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    setState(prev_0 => ({
+      ...prev_0,
+      warnings,
+      currentRepo,
+      selectedRepoName: currentRepo,
+      useCurrentRepo: !!currentRepo,
+      // Set to false if no repo detected
+      step: warnings.length > 0 ? 'warnings' : 'choose-repo'
+    }));
+  }, []);
+  React.useEffect(() => {
+    if (state.step === 'check-gh') {
+      void checkGitHubCLI();
+    }
+  }, [state.step, checkGitHubCLI]);
+  const runSetupGitHubActions = useCallback(async (apiKeyOrOAuthToken: string | null, secretName: string) => {
+    setState(prev_1 => ({
+      ...prev_1,
+      step: 'creating',
+      currentWorkflowInstallStep: 0
+    }));
+    try {
+      await setupGitHubActions(state.selectedRepoName, apiKeyOrOAuthToken, secretName, () => {
+        setState(prev_4 => ({
+          ...prev_4,
+          currentWorkflowInstallStep: prev_4.currentWorkflowInstallStep + 1
+        }));
+      }, state.workflowAction === 'skip', state.selectedWorkflows, state.authType, {
+        useCurrentRepo: state.useCurrentRepo,
+        workflowExists: state.workflowExists,
+        secretExists: state.secretExists
+      });
+      logEvent('tengu_install_github_app_step_completed', {
+        step: 'creating' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      setState(prev_5 => ({
+        ...prev_5,
+        step: 'success'
+      }));
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to set up GitHub Actions';
+      if (errorMessage.includes('workflow file already exists')) {
+        logEvent('tengu_install_github_app_error', {
+          reason: 'workflow_file_exists' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+        setState(prev_2 => ({
+          ...prev_2,
+          step: 'error',
+          error: 'A Claude workflow file already exists in this repository.',
+          errorReason: 'Workflow file conflict',
+          errorInstructions: ['The file .github/workflows/claude.yml already exists', 'You can either:', '  1. Delete the existing file and run this command again', '  2. Update the existing file manually using the template from:', `     ${GITHUB_ACTION_SETUP_DOCS_URL}`]
+        }));
+      } else {
+        logEvent('tengu_install_github_app_error', {
+          reason: 'setup_github_actions_failed' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+        setState(prev_3 => ({
+          ...prev_3,
+          step: 'error',
+          error: errorMessage,
+          errorReason: 'GitHub Actions setup failed',
+          errorInstructions: []
+        }));
+      }
+    }
+  }, [state.selectedRepoName, state.workflowAction, state.selectedWorkflows, state.useCurrentRepo, state.workflowExists, state.secretExists, state.authType]);
+  async function openGitHubAppInstallation() {
+    const installUrl = 'https://github.com/apps/claude';
+    await openBrowser(installUrl);
+  }
+  async function checkRepositoryPermissions(repoName: string): Promise<{
+    hasAccess: boolean;
+    error?: string;
+  }> {
+    try {
+      const result = await execFileNoThrow('gh', ['api', `repos/${repoName}`, '--jq', '.permissions.admin']);
+      if (result.code === 0) {
+        const hasAdmin = result.stdout.trim() === 'true';
+        return {
+          hasAccess: hasAdmin
+        };
+      }
+      if (result.stderr.includes('404') || result.stderr.includes('Not Found')) {
+        return {
+          hasAccess: false,
+          error: 'repository_not_found'
+        };
+      }
+      return {
+        hasAccess: false
+      };
+    } catch {
+      return {
+        hasAccess: false
+      };
+    }
+  }
+  async function checkExistingWorkflowFile(repoName_0: string): Promise<boolean> {
+    const checkFileResult = await execFileNoThrow('gh', ['api', `repos/${repoName_0}/contents/.github/workflows/claude.yml`, '--jq', '.sha']);
+    return checkFileResult.code === 0;
+  }
+  async function checkExistingSecret() {
+    const checkSecretsResult = await execFileNoThrow('gh', ['secret', 'list', '--app', 'actions', '--repo', state.selectedRepoName]);
+    if (checkSecretsResult.code === 0) {
+      const lines = checkSecretsResult.stdout.split('\n');
+      const hasAnthropicKey = lines.some((line: string) => {
+        return /^ANTHROPIC_API_KEY\s+/.test(line);
+      });
+      if (hasAnthropicKey) {
+        setState(prev_6 => ({
+          ...prev_6,
+          secretExists: true,
+          step: 'check-existing-secret'
+        }));
+      } else {
+        // No existing secret found
+        if (existingApiKey) {
+          // User has local key, skip to creating with it
+          setState(prev_7 => ({
+            ...prev_7,
+            apiKeyOrOAuthToken: existingApiKey,
+            useExistingKey: true
+          }));
+          await runSetupGitHubActions(existingApiKey, state.secretName);
+        } else {
+          // No local key, go to API key step
+          setState(prev_8 => ({
+            ...prev_8,
+            step: 'api-key'
+          }));
+        }
+      }
+    } else {
+      // Error checking secrets
+      if (existingApiKey) {
+        // User has local key, skip to creating with it
+        setState(prev_9 => ({
+          ...prev_9,
+          apiKeyOrOAuthToken: existingApiKey,
+          useExistingKey: true
+        }));
+        await runSetupGitHubActions(existingApiKey, state.secretName);
+      } else {
+        // No local key, go to API key step
+        setState(prev_10 => ({
+          ...prev_10,
+          step: 'api-key'
+        }));
+      }
+    }
+  }
+  const handleSubmit = async () => {
+    if (state.step === 'warnings') {
+      logEvent('tengu_install_github_app_step_completed', {
+        step: 'warnings' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      setState(prev_11 => ({
+        ...prev_11,
+        step: 'install-app'
+      }));
+      setTimeout(openGitHubAppInstallation, 0);
+    } else if (state.step === 'choose-repo') {
+      let repoName_1 = state.useCurrentRepo ? state.currentRepo : state.selectedRepoName;
+      if (!repoName_1.trim()) {
+        return;
+      }
+      const repoWarnings: Warning[] = [];
+      if (repoName_1.includes('github.com')) {
+        const match = repoName_1.match(/github\.com[:/]([^/]+\/[^/]+)(\.git)?$/);
+        if (!match) {
+          repoWarnings.push({
+            title: 'Invalid GitHub URL format',
+            message: 'The repository URL format appears to be invalid.',
+            instructions: ['Use format: owner/repo or https://github.com/owner/repo', 'Example: anthropics/claude-cli']
+          });
+        } else {
+          repoName_1 = match[1]?.replace(/\.git$/, '') || '';
+        }
+      }
+      if (!repoName_1.includes('/')) {
+        repoWarnings.push({
+          title: 'Repository format warning',
+          message: 'Repository should be in format "owner/repo"',
+          instructions: ['Use format: owner/repo', 'Example: anthropics/claude-cli']
+        });
+      }
+      const permissionCheck = await checkRepositoryPermissions(repoName_1);
+      if (permissionCheck.error === 'repository_not_found') {
+        repoWarnings.push({
+          title: 'Repository not found',
+          message: `Repository ${repoName_1} was not found or you don't have access.`,
+          instructions: [`Check that the repository name is correct: ${repoName_1}`, 'Ensure you have access to this repository', 'For private repositories, make sure your GitHub token has the "repo" scope', 'You can add the repo scope with: gh auth refresh -h github.com -s repo,workflow']
+        });
+      } else if (!permissionCheck.hasAccess) {
+        repoWarnings.push({
+          title: 'Admin permissions required',
+          message: `You might need admin permissions on ${repoName_1} to set up GitHub Actions.`,
+          instructions: ['Repository admins can install GitHub Apps and set secrets', 'Ask a repository admin to run this command if setup fails', 'Alternatively, you can use the manual setup instructions']
+        });
+      }
+      const workflowExists = await checkExistingWorkflowFile(repoName_1);
+      if (repoWarnings.length > 0) {
+        const allWarnings = [...state.warnings, ...repoWarnings];
+        setState(prev_12 => ({
+          ...prev_12,
+          selectedRepoName: repoName_1,
+          workflowExists,
+          warnings: allWarnings,
+          step: 'warnings'
+        }));
+      } else {
+        logEvent('tengu_install_github_app_step_completed', {
+          step: 'choose-repo' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+        setState(prev_13 => ({
+          ...prev_13,
+          selectedRepoName: repoName_1,
+          workflowExists,
+          step: 'install-app'
+        }));
+        setTimeout(openGitHubAppInstallation, 0);
+      }
+    } else if (state.step === 'install-app') {
+      logEvent('tengu_install_github_app_step_completed', {
+        step: 'install-app' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      if (state.workflowExists) {
+        setState(prev_14 => ({
+          ...prev_14,
+          step: 'check-existing-workflow'
+        }));
+      } else {
+        setState(prev_15 => ({
+          ...prev_15,
+          step: 'select-workflows'
+        }));
+      }
+    } else if (state.step === 'check-existing-workflow') {
+      return;
+    } else if (state.step === 'select-workflows') {
+      // Handled by the WorkflowMultiselectDialog component
+      return;
+    } else if (state.step === 'check-existing-secret') {
+      logEvent('tengu_install_github_app_step_completed', {
+        step: 'check-existing-secret' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      if (state.useExistingSecret) {
+        await runSetupGitHubActions(null, state.secretName);
+      } else {
+        // User wants to use a new secret name with their API key
+        await runSetupGitHubActions(state.apiKeyOrOAuthToken, state.secretName);
+      }
+    } else if (state.step === 'api-key') {
+      // In the new flow, api-key step only appears when user has no existing key
+      // They either entered a new key or will create OAuth token
+      if (state.selectedApiKeyOption === 'oauth') {
+        // OAuth flow already handled by handleCreateOAuthToken
+        return;
+      }
+
+      // If user selected 'existing' option, use the existing API key
+      const apiKeyToUse = state.selectedApiKeyOption === 'existing' ? existingApiKey : state.apiKeyOrOAuthToken;
+      if (!apiKeyToUse) {
+        logEvent('tengu_install_github_app_error', {
+          reason: 'api_key_missing' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+        setState(prev_16 => ({
+          ...prev_16,
+          step: 'error',
+          error: 'API key is required'
+        }));
+        return;
+      }
+
+      // Store the API key being used (either existing or newly entered)
+      setState(prev_17 => ({
+        ...prev_17,
+        apiKeyOrOAuthToken: apiKeyToUse,
+        useExistingKey: state.selectedApiKeyOption === 'existing'
+      }));
+
+      // Check if ANTHROPIC_API_KEY secret already exists
+      const checkSecretsResult_0 = await execFileNoThrow('gh', ['secret', 'list', '--app', 'actions', '--repo', state.selectedRepoName]);
+      if (checkSecretsResult_0.code === 0) {
+        const lines_0 = checkSecretsResult_0.stdout.split('\n');
+        const hasAnthropicKey_0 = lines_0.some((line_0: string) => {
+          return /^ANTHROPIC_API_KEY\s+/.test(line_0);
+        });
+        if (hasAnthropicKey_0) {
+          logEvent('tengu_install_github_app_step_completed', {
+            step: 'api-key' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+          });
+          setState(prev_18 => ({
+            ...prev_18,
+            secretExists: true,
+            step: 'check-existing-secret'
+          }));
+        } else {
+          logEvent('tengu_install_github_app_step_completed', {
+            step: 'api-key' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+          });
+          // No existing secret, proceed to creating
+          await runSetupGitHubActions(apiKeyToUse, state.secretName);
+        }
+      } else {
+        logEvent('tengu_install_github_app_step_completed', {
+          step: 'api-key' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+        // Error checking secrets, proceed anyway
+        await runSetupGitHubActions(apiKeyToUse, state.secretName);
+      }
+    }
+  };
+  const handleRepoUrlChange = (value: string) => {
+    setState(prev_19 => ({
+      ...prev_19,
+      selectedRepoName: value
+    }));
+  };
+  const handleApiKeyChange = (value_0: string) => {
+    setState(prev_20 => ({
+      ...prev_20,
+      apiKeyOrOAuthToken: value_0
+    }));
+  };
+  const handleApiKeyOptionChange = (option: 'existing' | 'new' | 'oauth') => {
+    setState(prev_21 => ({
+      ...prev_21,
+      selectedApiKeyOption: option
+    }));
+  };
+  const handleCreateOAuthToken = useCallback(() => {
+    logEvent('tengu_install_github_app_step_completed', {
+      step: 'api-key' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    setState(prev_22 => ({
+      ...prev_22,
+      step: 'oauth-flow'
+    }));
+  }, []);
+  const handleOAuthSuccess = useCallback((token: string) => {
+    logEvent('tengu_install_github_app_step_completed', {
+      step: 'oauth-flow' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    setState(prev_23 => ({
+      ...prev_23,
+      apiKeyOrOAuthToken: token,
+      useExistingKey: false,
+      secretName: 'CLAUDE_CODE_OAUTH_TOKEN',
+      authType: 'oauth_token'
+    }));
+    void runSetupGitHubActions(token, 'CLAUDE_CODE_OAUTH_TOKEN');
+  }, [runSetupGitHubActions]);
+  const handleOAuthCancel = useCallback(() => {
+    setState(prev_24 => ({
+      ...prev_24,
+      step: 'api-key'
+    }));
+  }, []);
+  const handleSecretNameChange = (value_1: string) => {
+    if (value_1 && !/^[a-zA-Z0-9_]+$/.test(value_1)) return;
+    setState(prev_25 => ({
+      ...prev_25,
+      secretName: value_1
+    }));
+  };
+  const handleToggleUseCurrentRepo = (useCurrentRepo: boolean) => {
+    setState(prev_26 => ({
+      ...prev_26,
+      useCurrentRepo,
+      selectedRepoName: useCurrentRepo ? prev_26.currentRepo : ''
+    }));
+  };
+  const handleToggleUseExistingKey = (useExistingKey: boolean) => {
+    setState(prev_27 => ({
+      ...prev_27,
+      useExistingKey
+    }));
+  };
+  const handleToggleUseExistingSecret = (useExistingSecret: boolean) => {
+    setState(prev_28 => ({
+      ...prev_28,
+      useExistingSecret,
+      secretName: useExistingSecret ? 'ANTHROPIC_API_KEY' : ''
+    }));
+  };
+  const handleWorkflowAction = async (action: 'update' | 'skip' | 'exit') => {
+    if (action === 'exit') {
+      props.onDone('Installation cancelled by user');
+      return;
+    }
+    logEvent('tengu_install_github_app_step_completed', {
+      step: 'check-existing-workflow' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    setState(prev_29 => ({
+      ...prev_29,
+      workflowAction: action
+    }));
+    if (action === 'skip' || action === 'update') {
+      // Check if user has existing local API key
+      if (existingApiKey) {
+        await checkExistingSecret();
+      } else {
+        // No local key, go straight to API key step
+        setState(prev_30 => ({
+          ...prev_30,
+          step: 'api-key'
+        }));
+      }
+    }
+  };
+  function handleDismissKeyDown(e: KeyboardEvent): void {
+    e.preventDefault();
+    if (state.step === 'success') {
+      logEvent('tengu_install_github_app_completed', {});
+    }
+    props.onDone(state.step === 'success' ? 'GitHub Actions setup complete!' : state.error ? `Couldn't install GitHub App: ${state.error}\nFor manual setup instructions, see: ${GITHUB_ACTION_SETUP_DOCS_URL}` : `GitHub App installation failed\nFor manual setup instructions, see: ${GITHUB_ACTION_SETUP_DOCS_URL}`);
+  }
+  switch (state.step) {
+    case 'check-gh':
+      return <CheckGitHubStep />;
+    case 'warnings':
+      return <WarningsStep warnings={state.warnings} onContinue={handleSubmit} />;
+    case 'choose-repo':
+      return <ChooseRepoStep currentRepo={state.currentRepo} useCurrentRepo={state.useCurrentRepo} repoUrl={state.selectedRepoName} onRepoUrlChange={handleRepoUrlChange} onToggleUseCurrentRepo={handleToggleUseCurrentRepo} onSubmit={handleSubmit} />;
+    case 'install-app':
+      return <InstallAppStep repoUrl={state.selectedRepoName} onSubmit={handleSubmit} />;
+    case 'check-existing-workflow':
+      return <ExistingWorkflowStep repoName={state.selectedRepoName} onSelectAction={handleWorkflowAction} />;
+    case 'check-existing-secret':
+      return <CheckExistingSecretStep useExistingSecret={state.useExistingSecret} secretName={state.secretName} onToggleUseExistingSecret={handleToggleUseExistingSecret} onSecretNameChange={handleSecretNameChange} onSubmit={handleSubmit} />;
+    case 'api-key':
+      return <ApiKeyStep existingApiKey={existingApiKey} useExistingKey={state.useExistingKey} apiKeyOrOAuthToken={state.apiKeyOrOAuthToken} onApiKeyChange={handleApiKeyChange} onToggleUseExistingKey={handleToggleUseExistingKey} onSubmit={handleSubmit} onCreateOAuthToken={isAnthropicAuthEnabled() ? handleCreateOAuthToken : undefined} selectedOption={state.selectedApiKeyOption} onSelectOption={handleApiKeyOptionChange} />;
+    case 'creating':
+      return <CreatingStep currentWorkflowInstallStep={state.currentWorkflowInstallStep} secretExists={state.secretExists} useExistingSecret={state.useExistingSecret} secretName={state.secretName} skipWorkflow={state.workflowAction === 'skip'} selectedWorkflows={state.selectedWorkflows} />;
+    case 'success':
+      return <Box tabIndex={0} autoFocus onKeyDown={handleDismissKeyDown}>
+          <SuccessStep secretExists={state.secretExists} useExistingSecret={state.useExistingSecret} secretName={state.secretName} skipWorkflow={state.workflowAction === 'skip'} />
+        </Box>;
+    case 'error':
+      return <Box tabIndex={0} autoFocus onKeyDown={handleDismissKeyDown}>
+          <ErrorStep error={state.error} errorReason={state.errorReason} errorInstructions={state.errorInstructions} />
+        </Box>;
+    case 'select-workflows':
+      return <WorkflowMultiselectDialog defaultSelections={state.selectedWorkflows} onSubmit={selectedWorkflows => {
+        logEvent('tengu_install_github_app_step_completed', {
+          step: 'select-workflows' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+        setState(prev_31 => ({
+          ...prev_31,
+          selectedWorkflows
+        }));
+        // Check if user has existing local API key
+        if (existingApiKey) {
+          void checkExistingSecret();
+        } else {
+          // No local key, go straight to API key step
+          setState(prev_32 => ({
+            ...prev_32,
+            step: 'api-key'
+          }));
+        }
+      }} />;
+    case 'oauth-flow':
+      return <OAuthFlowStep onSuccess={handleOAuthSuccess} onCancel={handleOAuthCancel} />;
+  }
+}
+export async function call(onDone: LocalJSXCommandOnDone): Promise<React.ReactNode> {
+  return <InstallGitHubApp onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["execa","React","useCallback","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","WorkflowMultiselectDialog","GITHUB_ACTION_SETUP_DOCS_URL","useExitOnCtrlCDWithKeybindings","KeyboardEvent","Box","LocalJSXCommandOnDone","getAnthropicApiKey","isAnthropicAuthEnabled","openBrowser","execFileNoThrow","getGithubRepo","plural","ApiKeyStep","CheckExistingSecretStep","CheckGitHubStep","ChooseRepoStep","CreatingStep","ErrorStep","ExistingWorkflowStep","InstallAppStep","OAuthFlowStep","SuccessStep","setupGitHubActions","State","Warning","Workflow","WarningsStep","INITIAL_STATE","step","selectedRepoName","currentRepo","useCurrentRepo","apiKeyOrOAuthToken","useExistingKey","currentWorkflowInstallStep","warnings","secretExists","secretName","useExistingSecret","workflowExists","selectedWorkflows","selectedApiKeyOption","authType","InstallGitHubApp","props","onDone","message","ReactNode","existingApiKey","state","setState","useEffect","checkGitHubCLI","ghVersionResult","shell","reject","exitCode","push","title","instructions","authResult","tokenScopesMatch","stdout","match","scopes","missingScopes","includes","length","prev","error","join","errorReason","errorInstructions","runSetupGitHubActions","workflowAction","errorMessage","Error","reason","openGitHubAppInstallation","installUrl","checkRepositoryPermissions","repoName","Promise","hasAccess","result","code","hasAdmin","trim","stderr","checkExistingWorkflowFile","checkFileResult","checkExistingSecret","checkSecretsResult","lines","split","hasAnthropicKey","some","line","test","handleSubmit","setTimeout","repoWarnings","replace","permissionCheck","allWarnings","apiKeyToUse","handleRepoUrlChange","value","handleApiKeyChange","handleApiKeyOptionChange","option","handleCreateOAuthToken","handleOAuthSuccess","token","handleOAuthCancel","handleSecretNameChange","handleToggleUseCurrentRepo","handleToggleUseExistingKey","handleToggleUseExistingSecret","handleWorkflowAction","action","handleDismissKeyDown","e","preventDefault","undefined","call"],"sources":["install-github-app.tsx"],"sourcesContent":["import { execa } from 'execa'\nimport React, { useCallback, 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 { WorkflowMultiselectDialog } from '../../components/WorkflowMultiselectDialog.js'\nimport { GITHUB_ACTION_SETUP_DOCS_URL } from '../../constants/github-app.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport { Box } from '../../ink.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { getAnthropicApiKey, isAnthropicAuthEnabled } from '../../utils/auth.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport { execFileNoThrow } from '../../utils/execFileNoThrow.js'\nimport { getGithubRepo } from '../../utils/git.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport { ApiKeyStep } from './ApiKeyStep.js'\nimport { CheckExistingSecretStep } from './CheckExistingSecretStep.js'\nimport { CheckGitHubStep } from './CheckGitHubStep.js'\nimport { ChooseRepoStep } from './ChooseRepoStep.js'\nimport { CreatingStep } from './CreatingStep.js'\nimport { ErrorStep } from './ErrorStep.js'\nimport { ExistingWorkflowStep } from './ExistingWorkflowStep.js'\nimport { InstallAppStep } from './InstallAppStep.js'\nimport { OAuthFlowStep } from './OAuthFlowStep.js'\nimport { SuccessStep } from './SuccessStep.js'\nimport { setupGitHubActions } from './setupGitHubActions.js'\nimport type { State, Warning, Workflow } from './types.js'\nimport { WarningsStep } from './WarningsStep.js'\n\nconst INITIAL_STATE: State = {\n  step: 'check-gh',\n  selectedRepoName: '',\n  currentRepo: '',\n  useCurrentRepo: false, // Default to false, will be set to true if repo detected\n  apiKeyOrOAuthToken: '',\n  useExistingKey: true,\n  currentWorkflowInstallStep: 0,\n  warnings: [],\n  secretExists: false,\n  secretName: 'ANTHROPIC_API_KEY',\n  useExistingSecret: true,\n  workflowExists: false,\n  selectedWorkflows: ['claude', 'claude-review'] as Workflow[],\n  selectedApiKeyOption: 'new' as 'existing' | 'new' | 'oauth',\n  authType: 'api_key',\n}\n\nfunction InstallGitHubApp(props: {\n  onDone: (message: string) => void\n}): React.ReactNode {\n  const [existingApiKey] = useState(() => getAnthropicApiKey())\n  const [state, setState] = useState({\n    ...INITIAL_STATE,\n    useExistingKey: !!existingApiKey,\n    selectedApiKeyOption: (existingApiKey\n      ? 'existing'\n      : isAnthropicAuthEnabled()\n        ? 'oauth'\n        : 'new') as 'existing' | 'new' | 'oauth',\n  })\n  useExitOnCtrlCDWithKeybindings()\n\n  React.useEffect(() => {\n    logEvent('tengu_install_github_app_started', {})\n  }, [])\n\n  const checkGitHubCLI = useCallback(async () => {\n    const warnings: Warning[] = []\n\n    // Check if gh is installed\n    const ghVersionResult = await execa('gh --version', {\n      shell: true,\n      reject: false,\n    })\n    if (ghVersionResult.exitCode !== 0) {\n      warnings.push({\n        title: 'GitHub CLI not found',\n        message:\n          'GitHub CLI (gh) does not appear to be installed or accessible.',\n        instructions: [\n          'Install GitHub CLI from https://cli.github.com/',\n          'macOS: brew install gh',\n          'Windows: winget install --id GitHub.cli',\n          'Linux: See installation instructions at https://github.com/cli/cli#installation',\n        ],\n      })\n    }\n\n    // Check auth status\n    const authResult = await execa('gh auth status -a', {\n      shell: true,\n      reject: false,\n    })\n    if (authResult.exitCode !== 0) {\n      warnings.push({\n        title: 'GitHub CLI not authenticated',\n        message: 'GitHub CLI does not appear to be authenticated.',\n        instructions: [\n          'Run: gh auth login',\n          'Follow the prompts to authenticate with GitHub',\n          'Or set up authentication using environment variables or other methods',\n        ],\n      })\n    } else {\n      // Check if required scopes are present in the Token scopes line\n      const tokenScopesMatch = authResult.stdout.match(/Token scopes:.*$/m)\n      if (tokenScopesMatch) {\n        const scopes = tokenScopesMatch[0]\n        const missingScopes: string[] = []\n\n        if (!scopes.includes('repo')) {\n          missingScopes.push('repo')\n        }\n        if (!scopes.includes('workflow')) {\n          missingScopes.push('workflow')\n        }\n\n        if (missingScopes.length > 0) {\n          // Missing required scopes - exit immediately\n          setState(prev => ({\n            ...prev,\n            step: 'error',\n            error: `GitHub CLI is missing required permissions: ${missingScopes.join(', ')}.`,\n            errorReason: 'Missing required scopes',\n            errorInstructions: [\n              `Your GitHub CLI authentication is missing the \"${missingScopes.join('\" and \"')}\" ${plural(missingScopes.length, 'scope')} needed to manage GitHub Actions and secrets.`,\n              '',\n              'To fix this, run:',\n              '  gh auth refresh -h github.com -s repo,workflow',\n              '',\n              'This will add the necessary permissions to manage workflows and secrets.',\n            ],\n          }))\n          return\n        }\n      }\n    }\n\n    // Check if in a git repo and get remote URL\n    const currentRepo = (await getGithubRepo()) ?? ''\n\n    logEvent('tengu_install_github_app_step_completed', {\n      step: 'check-gh' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    setState(prev => ({\n      ...prev,\n      warnings,\n      currentRepo,\n      selectedRepoName: currentRepo,\n      useCurrentRepo: !!currentRepo, // Set to false if no repo detected\n      step: warnings.length > 0 ? 'warnings' : 'choose-repo',\n    }))\n  }, [])\n\n  React.useEffect(() => {\n    if (state.step === 'check-gh') {\n      void checkGitHubCLI()\n    }\n  }, [state.step, checkGitHubCLI])\n\n  const runSetupGitHubActions = useCallback(\n    async (apiKeyOrOAuthToken: string | null, secretName: string) => {\n      setState(prev => ({\n        ...prev,\n        step: 'creating',\n        currentWorkflowInstallStep: 0,\n      }))\n\n      try {\n        await setupGitHubActions(\n          state.selectedRepoName,\n          apiKeyOrOAuthToken,\n          secretName,\n          () => {\n            setState(prev => ({\n              ...prev,\n              currentWorkflowInstallStep: prev.currentWorkflowInstallStep + 1,\n            }))\n          },\n          state.workflowAction === 'skip',\n          state.selectedWorkflows,\n          state.authType,\n          {\n            useCurrentRepo: state.useCurrentRepo,\n            workflowExists: state.workflowExists,\n            secretExists: state.secretExists,\n          },\n        )\n        logEvent('tengu_install_github_app_step_completed', {\n          step: 'creating' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n        setState(prev => ({ ...prev, step: 'success' }))\n      } catch (error) {\n        const errorMessage =\n          error instanceof Error\n            ? error.message\n            : 'Failed to set up GitHub Actions'\n\n        if (errorMessage.includes('workflow file already exists')) {\n          logEvent('tengu_install_github_app_error', {\n            reason:\n              'workflow_file_exists' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n          setState(prev => ({\n            ...prev,\n            step: 'error',\n            error: 'A Claude workflow file already exists in this repository.',\n            errorReason: 'Workflow file conflict',\n            errorInstructions: [\n              'The file .github/workflows/claude.yml already exists',\n              'You can either:',\n              '  1. Delete the existing file and run this command again',\n              '  2. Update the existing file manually using the template from:',\n              `     ${GITHUB_ACTION_SETUP_DOCS_URL}`,\n            ],\n          }))\n        } else {\n          logEvent('tengu_install_github_app_error', {\n            reason:\n              'setup_github_actions_failed' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n\n          setState(prev => ({\n            ...prev,\n            step: 'error',\n            error: errorMessage,\n            errorReason: 'GitHub Actions setup failed',\n            errorInstructions: [],\n          }))\n        }\n      }\n    },\n    [\n      state.selectedRepoName,\n      state.workflowAction,\n      state.selectedWorkflows,\n      state.useCurrentRepo,\n      state.workflowExists,\n      state.secretExists,\n      state.authType,\n    ],\n  )\n\n  async function openGitHubAppInstallation() {\n    const installUrl = 'https://github.com/apps/claude'\n    await openBrowser(installUrl)\n  }\n\n  async function checkRepositoryPermissions(\n    repoName: string,\n  ): Promise<{ hasAccess: boolean; error?: string }> {\n    try {\n      const result = await execFileNoThrow('gh', [\n        'api',\n        `repos/${repoName}`,\n        '--jq',\n        '.permissions.admin',\n      ])\n\n      if (result.code === 0) {\n        const hasAdmin = result.stdout.trim() === 'true'\n        return { hasAccess: hasAdmin }\n      }\n\n      if (\n        result.stderr.includes('404') ||\n        result.stderr.includes('Not Found')\n      ) {\n        return {\n          hasAccess: false,\n          error: 'repository_not_found',\n        }\n      }\n\n      return { hasAccess: false }\n    } catch {\n      return { hasAccess: false }\n    }\n  }\n\n  async function checkExistingWorkflowFile(repoName: string): Promise<boolean> {\n    const checkFileResult = await execFileNoThrow('gh', [\n      'api',\n      `repos/${repoName}/contents/.github/workflows/claude.yml`,\n      '--jq',\n      '.sha',\n    ])\n\n    return checkFileResult.code === 0\n  }\n\n  async function checkExistingSecret() {\n    const checkSecretsResult = await execFileNoThrow('gh', [\n      'secret',\n      'list',\n      '--app',\n      'actions',\n      '--repo',\n      state.selectedRepoName,\n    ])\n\n    if (checkSecretsResult.code === 0) {\n      const lines = checkSecretsResult.stdout.split('\\n')\n      const hasAnthropicKey = lines.some((line: string) => {\n        return /^ANTHROPIC_API_KEY\\s+/.test(line)\n      })\n\n      if (hasAnthropicKey) {\n        setState(prev => ({\n          ...prev,\n          secretExists: true,\n          step: 'check-existing-secret',\n        }))\n      } else {\n        // No existing secret found\n        if (existingApiKey) {\n          // User has local key, skip to creating with it\n          setState(prev => ({\n            ...prev,\n            apiKeyOrOAuthToken: existingApiKey,\n            useExistingKey: true,\n          }))\n          await runSetupGitHubActions(existingApiKey, state.secretName)\n        } else {\n          // No local key, go to API key step\n          setState(prev => ({ ...prev, step: 'api-key' }))\n        }\n      }\n    } else {\n      // Error checking secrets\n      if (existingApiKey) {\n        // User has local key, skip to creating with it\n        setState(prev => ({\n          ...prev,\n          apiKeyOrOAuthToken: existingApiKey,\n          useExistingKey: true,\n        }))\n        await runSetupGitHubActions(existingApiKey, state.secretName)\n      } else {\n        // No local key, go to API key step\n        setState(prev => ({ ...prev, step: 'api-key' }))\n      }\n    }\n  }\n\n  const handleSubmit = async () => {\n    if (state.step === 'warnings') {\n      logEvent('tengu_install_github_app_step_completed', {\n        step: 'warnings' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      setState(prev => ({ ...prev, step: 'install-app' }))\n      setTimeout(openGitHubAppInstallation, 0)\n    } else if (state.step === 'choose-repo') {\n      let repoName = state.useCurrentRepo\n        ? state.currentRepo\n        : state.selectedRepoName\n\n      if (!repoName.trim()) {\n        return\n      }\n\n      const repoWarnings: Warning[] = []\n\n      if (repoName.includes('github.com')) {\n        const match = repoName.match(/github\\.com[:/]([^/]+\\/[^/]+)(\\.git)?$/)\n        if (!match) {\n          repoWarnings.push({\n            title: 'Invalid GitHub URL format',\n            message: 'The repository URL format appears to be invalid.',\n            instructions: [\n              'Use format: owner/repo or https://github.com/owner/repo',\n              'Example: anthropics/claude-cli',\n            ],\n          })\n        } else {\n          repoName = match[1]?.replace(/\\.git$/, '') || ''\n        }\n      }\n\n      if (!repoName.includes('/')) {\n        repoWarnings.push({\n          title: 'Repository format warning',\n          message: 'Repository should be in format \"owner/repo\"',\n          instructions: [\n            'Use format: owner/repo',\n            'Example: anthropics/claude-cli',\n          ],\n        })\n      }\n\n      const permissionCheck = await checkRepositoryPermissions(repoName)\n\n      if (permissionCheck.error === 'repository_not_found') {\n        repoWarnings.push({\n          title: 'Repository not found',\n          message: `Repository ${repoName} was not found or you don't have access.`,\n          instructions: [\n            `Check that the repository name is correct: ${repoName}`,\n            'Ensure you have access to this repository',\n            'For private repositories, make sure your GitHub token has the \"repo\" scope',\n            'You can add the repo scope with: gh auth refresh -h github.com -s repo,workflow',\n          ],\n        })\n      } else if (!permissionCheck.hasAccess) {\n        repoWarnings.push({\n          title: 'Admin permissions required',\n          message: `You might need admin permissions on ${repoName} to set up GitHub Actions.`,\n          instructions: [\n            'Repository admins can install GitHub Apps and set secrets',\n            'Ask a repository admin to run this command if setup fails',\n            'Alternatively, you can use the manual setup instructions',\n          ],\n        })\n      }\n\n      const workflowExists = await checkExistingWorkflowFile(repoName)\n\n      if (repoWarnings.length > 0) {\n        const allWarnings = [...state.warnings, ...repoWarnings]\n        setState(prev => ({\n          ...prev,\n          selectedRepoName: repoName,\n          workflowExists,\n          warnings: allWarnings,\n          step: 'warnings',\n        }))\n      } else {\n        logEvent('tengu_install_github_app_step_completed', {\n          step: 'choose-repo' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n        setState(prev => ({\n          ...prev,\n          selectedRepoName: repoName,\n          workflowExists,\n          step: 'install-app',\n        }))\n        setTimeout(openGitHubAppInstallation, 0)\n      }\n    } else if (state.step === 'install-app') {\n      logEvent('tengu_install_github_app_step_completed', {\n        step: 'install-app' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      if (state.workflowExists) {\n        setState(prev => ({ ...prev, step: 'check-existing-workflow' }))\n      } else {\n        setState(prev => ({ ...prev, step: 'select-workflows' }))\n      }\n    } else if (state.step === 'check-existing-workflow') {\n      return\n    } else if (state.step === 'select-workflows') {\n      // Handled by the WorkflowMultiselectDialog component\n      return\n    } else if (state.step === 'check-existing-secret') {\n      logEvent('tengu_install_github_app_step_completed', {\n        step: 'check-existing-secret' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      if (state.useExistingSecret) {\n        await runSetupGitHubActions(null, state.secretName)\n      } else {\n        // User wants to use a new secret name with their API key\n        await runSetupGitHubActions(state.apiKeyOrOAuthToken, state.secretName)\n      }\n    } else if (state.step === 'api-key') {\n      // In the new flow, api-key step only appears when user has no existing key\n      // They either entered a new key or will create OAuth token\n      if (state.selectedApiKeyOption === 'oauth') {\n        // OAuth flow already handled by handleCreateOAuthToken\n        return\n      }\n\n      // If user selected 'existing' option, use the existing API key\n      const apiKeyToUse =\n        state.selectedApiKeyOption === 'existing'\n          ? existingApiKey\n          : state.apiKeyOrOAuthToken\n\n      if (!apiKeyToUse) {\n        logEvent('tengu_install_github_app_error', {\n          reason:\n            'api_key_missing' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n        setState(prev => ({\n          ...prev,\n          step: 'error',\n          error: 'API key is required',\n        }))\n        return\n      }\n\n      // Store the API key being used (either existing or newly entered)\n      setState(prev => ({\n        ...prev,\n        apiKeyOrOAuthToken: apiKeyToUse,\n        useExistingKey: state.selectedApiKeyOption === 'existing',\n      }))\n\n      // Check if ANTHROPIC_API_KEY secret already exists\n      const checkSecretsResult = await execFileNoThrow('gh', [\n        'secret',\n        'list',\n        '--app',\n        'actions',\n        '--repo',\n        state.selectedRepoName,\n      ])\n\n      if (checkSecretsResult.code === 0) {\n        const lines = checkSecretsResult.stdout.split('\\n')\n        const hasAnthropicKey = lines.some((line: string) => {\n          return /^ANTHROPIC_API_KEY\\s+/.test(line)\n        })\n\n        if (hasAnthropicKey) {\n          logEvent('tengu_install_github_app_step_completed', {\n            step: 'api-key' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n          setState(prev => ({\n            ...prev,\n            secretExists: true,\n            step: 'check-existing-secret',\n          }))\n        } else {\n          logEvent('tengu_install_github_app_step_completed', {\n            step: 'api-key' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n          // No existing secret, proceed to creating\n          await runSetupGitHubActions(apiKeyToUse, state.secretName)\n        }\n      } else {\n        logEvent('tengu_install_github_app_step_completed', {\n          step: 'api-key' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n        // Error checking secrets, proceed anyway\n        await runSetupGitHubActions(apiKeyToUse, state.secretName)\n      }\n    }\n  }\n\n  const handleRepoUrlChange = (value: string) => {\n    setState(prev => ({ ...prev, selectedRepoName: value }))\n  }\n\n  const handleApiKeyChange = (value: string) => {\n    setState(prev => ({ ...prev, apiKeyOrOAuthToken: value }))\n  }\n\n  const handleApiKeyOptionChange = (option: 'existing' | 'new' | 'oauth') => {\n    setState(prev => ({ ...prev, selectedApiKeyOption: option }))\n  }\n\n  const handleCreateOAuthToken = useCallback(() => {\n    logEvent('tengu_install_github_app_step_completed', {\n      step: 'api-key' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    setState(prev => ({ ...prev, step: 'oauth-flow' }))\n  }, [])\n\n  const handleOAuthSuccess = useCallback(\n    (token: string) => {\n      logEvent('tengu_install_github_app_step_completed', {\n        step: 'oauth-flow' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      setState(prev => ({\n        ...prev,\n        apiKeyOrOAuthToken: token,\n        useExistingKey: false,\n        secretName: 'CLAUDE_CODE_OAUTH_TOKEN',\n        authType: 'oauth_token',\n      }))\n      void runSetupGitHubActions(token, 'CLAUDE_CODE_OAUTH_TOKEN')\n    },\n    [runSetupGitHubActions],\n  )\n\n  const handleOAuthCancel = useCallback(() => {\n    setState(prev => ({ ...prev, step: 'api-key' }))\n  }, [])\n\n  const handleSecretNameChange = (value: string) => {\n    if (value && !/^[a-zA-Z0-9_]+$/.test(value)) return\n    setState(prev => ({ ...prev, secretName: value }))\n  }\n\n  const handleToggleUseCurrentRepo = (useCurrentRepo: boolean) => {\n    setState(prev => ({\n      ...prev,\n      useCurrentRepo,\n      selectedRepoName: useCurrentRepo ? prev.currentRepo : '',\n    }))\n  }\n\n  const handleToggleUseExistingKey = (useExistingKey: boolean) => {\n    setState(prev => ({ ...prev, useExistingKey }))\n  }\n\n  const handleToggleUseExistingSecret = (useExistingSecret: boolean) => {\n    setState(prev => ({\n      ...prev,\n      useExistingSecret,\n      secretName: useExistingSecret ? 'ANTHROPIC_API_KEY' : '',\n    }))\n  }\n\n  const handleWorkflowAction = async (action: 'update' | 'skip' | 'exit') => {\n    if (action === 'exit') {\n      props.onDone('Installation cancelled by user')\n      return\n    }\n\n    logEvent('tengu_install_github_app_step_completed', {\n      step: 'check-existing-workflow' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    setState(prev => ({ ...prev, workflowAction: action }))\n\n    if (action === 'skip' || action === 'update') {\n      // Check if user has existing local API key\n      if (existingApiKey) {\n        await checkExistingSecret()\n      } else {\n        // No local key, go straight to API key step\n        setState(prev => ({ ...prev, step: 'api-key' }))\n      }\n    }\n  }\n\n  function handleDismissKeyDown(e: KeyboardEvent): void {\n    e.preventDefault()\n    if (state.step === 'success') {\n      logEvent('tengu_install_github_app_completed', {})\n    }\n    props.onDone(\n      state.step === 'success'\n        ? 'GitHub Actions setup complete!'\n        : state.error\n          ? `Couldn't install GitHub App: ${state.error}\\nFor manual setup instructions, see: ${GITHUB_ACTION_SETUP_DOCS_URL}`\n          : `GitHub App installation failed\\nFor manual setup instructions, see: ${GITHUB_ACTION_SETUP_DOCS_URL}`,\n    )\n  }\n\n  switch (state.step) {\n    case 'check-gh':\n      return <CheckGitHubStep />\n    case 'warnings':\n      return (\n        <WarningsStep warnings={state.warnings} onContinue={handleSubmit} />\n      )\n    case 'choose-repo':\n      return (\n        <ChooseRepoStep\n          currentRepo={state.currentRepo}\n          useCurrentRepo={state.useCurrentRepo}\n          repoUrl={state.selectedRepoName}\n          onRepoUrlChange={handleRepoUrlChange}\n          onToggleUseCurrentRepo={handleToggleUseCurrentRepo}\n          onSubmit={handleSubmit}\n        />\n      )\n    case 'install-app':\n      return (\n        <InstallAppStep\n          repoUrl={state.selectedRepoName}\n          onSubmit={handleSubmit}\n        />\n      )\n    case 'check-existing-workflow':\n      return (\n        <ExistingWorkflowStep\n          repoName={state.selectedRepoName}\n          onSelectAction={handleWorkflowAction}\n        />\n      )\n    case 'check-existing-secret':\n      return (\n        <CheckExistingSecretStep\n          useExistingSecret={state.useExistingSecret}\n          secretName={state.secretName}\n          onToggleUseExistingSecret={handleToggleUseExistingSecret}\n          onSecretNameChange={handleSecretNameChange}\n          onSubmit={handleSubmit}\n        />\n      )\n    case 'api-key':\n      return (\n        <ApiKeyStep\n          existingApiKey={existingApiKey}\n          useExistingKey={state.useExistingKey}\n          apiKeyOrOAuthToken={state.apiKeyOrOAuthToken}\n          onApiKeyChange={handleApiKeyChange}\n          onToggleUseExistingKey={handleToggleUseExistingKey}\n          onSubmit={handleSubmit}\n          onCreateOAuthToken={\n            isAnthropicAuthEnabled() ? handleCreateOAuthToken : undefined\n          }\n          selectedOption={state.selectedApiKeyOption}\n          onSelectOption={handleApiKeyOptionChange}\n        />\n      )\n    case 'creating':\n      return (\n        <CreatingStep\n          currentWorkflowInstallStep={state.currentWorkflowInstallStep}\n          secretExists={state.secretExists}\n          useExistingSecret={state.useExistingSecret}\n          secretName={state.secretName}\n          skipWorkflow={state.workflowAction === 'skip'}\n          selectedWorkflows={state.selectedWorkflows}\n        />\n      )\n    case 'success':\n      return (\n        <Box tabIndex={0} autoFocus onKeyDown={handleDismissKeyDown}>\n          <SuccessStep\n            secretExists={state.secretExists}\n            useExistingSecret={state.useExistingSecret}\n            secretName={state.secretName}\n            skipWorkflow={state.workflowAction === 'skip'}\n          />\n        </Box>\n      )\n    case 'error':\n      return (\n        <Box tabIndex={0} autoFocus onKeyDown={handleDismissKeyDown}>\n          <ErrorStep\n            error={state.error}\n            errorReason={state.errorReason}\n            errorInstructions={state.errorInstructions}\n          />\n        </Box>\n      )\n    case 'select-workflows':\n      return (\n        <WorkflowMultiselectDialog\n          defaultSelections={state.selectedWorkflows}\n          onSubmit={selectedWorkflows => {\n            logEvent('tengu_install_github_app_step_completed', {\n              step: 'select-workflows' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            })\n            setState(prev => ({\n              ...prev,\n              selectedWorkflows,\n            }))\n            // Check if user has existing local API key\n            if (existingApiKey) {\n              void checkExistingSecret()\n            } else {\n              // No local key, go straight to API key step\n              setState(prev => ({ ...prev, step: 'api-key' }))\n            }\n          }}\n        />\n      )\n    case 'oauth-flow':\n      return (\n        <OAuthFlowStep\n          onSuccess={handleOAuthSuccess}\n          onCancel={handleOAuthCancel}\n        />\n      )\n  }\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n): Promise<React.ReactNode> {\n  return <InstallGitHubApp onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}