remote-setup.tsx

import { execa } from 'execa';
import * as React from 'react';
import { useEffect, useState } from 'react';
import { Select } from '../../components/CustomSelect/index.js';
import { Dialog } from '../../components/design-system/Dialog.js';
import { LoadingState } from '../../components/design-system/LoadingState.js';
import { Box, Text } from '../../ink.js';
import { logEvent, type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS as SafeString } from '../../services/analytics/index.js';
import type { LocalJSXCommandOnDone } from '../../types/command.js';
import { openBrowser } from '../../utils/browser.js';
import { getGhAuthStatus } from '../../utils/github/ghAuthStatus.js';
import { createDefaultEnvironment, getCodeWebUrl, type ImportTokenError, importGithubToken, isSignedIn, RedactedGithubToken } from './api.js';
type CheckResult = {
  status: 'not_signed_in';
} | {
  status: 'has_gh_token';
  token: RedactedGithubToken;
} | {
  status: 'gh_not_installed';
} | {
  status: 'gh_not_authenticated';
};
async function checkLoginState(): Promise<CheckResult> {
  if (!(await isSignedIn())) {
    return {
      status: 'not_signed_in'
    };
  }
  const ghStatus = await getGhAuthStatus();
  if (ghStatus === 'not_installed') {
    return {
      status: 'gh_not_installed'
    };
  }
  if (ghStatus === 'not_authenticated') {
    return {
      status: 'gh_not_authenticated'
    };
  }

  // ghStatus === 'authenticated'. getGhAuthStatus spawns with stdout:'ignore'
  // (telemetry-safe); spawn once more with stdout:'pipe' to read the token.
  const {
    stdout
  } = await execa('gh', ['auth', 'token'], {
    stdout: 'pipe',
    stderr: 'ignore',
    timeout: 5000,
    reject: false
  });
  const trimmed = stdout.trim();
  if (!trimmed) {
    return {
      status: 'gh_not_authenticated'
    };
  }
  return {
    status: 'has_gh_token',
    token: new RedactedGithubToken(trimmed)
  };
}
function errorMessage(err: ImportTokenError, codeUrl: string): string {
  switch (err.kind) {
    case 'not_signed_in':
      return `Login failed. Please visit ${codeUrl} and login using the GitHub App`;
    case 'invalid_token':
      return 'GitHub rejected that token. Run `gh auth login` and try again.';
    case 'server':
      return `Server error (${err.status}). Try again in a moment.`;
    case 'network':
      return "Couldn't reach the server. Check your connection.";
  }
}
type Step = {
  name: 'checking';
} | {
  name: 'confirm';
  token: RedactedGithubToken;
} | {
  name: 'uploading';
};
function Web({
  onDone
}: {
  onDone: LocalJSXCommandOnDone;
}) {
  const [step, setStep] = useState<Step>({
    name: 'checking'
  });
  useEffect(() => {
    logEvent('tengu_remote_setup_started', {});
    void checkLoginState().then(async result => {
      switch (result.status) {
        case 'not_signed_in':
          logEvent('tengu_remote_setup_result', {
            result: 'not_signed_in' as SafeString
          });
          onDone('Not signed in to Claude. Run /login first.');
          return;
        case 'gh_not_installed':
        case 'gh_not_authenticated':
          {
            const url = `${getCodeWebUrl()}/onboarding?step=alt-auth`;
            await openBrowser(url);
            logEvent('tengu_remote_setup_result', {
              result: result.status as SafeString
            });
            onDone(result.status === 'gh_not_installed' ? `GitHub CLI not found. Install it via https://cli.github.com/, then run \`gh auth login\`, or connect GitHub on the web: ${url}` : `GitHub CLI not authenticated. Run \`gh auth login\` and try again, or connect GitHub on the web: ${url}`);
            return;
          }
        case 'has_gh_token':
          setStep({
            name: 'confirm',
            token: result.token
          });
      }
    });
    // onDone is stable across renders; intentionally not in deps.
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);
  const handleCancel = () => {
    logEvent('tengu_remote_setup_result', {
      result: 'cancelled' as SafeString
    });
    onDone();
  };
  const handleConfirm = async (token: RedactedGithubToken) => {
    setStep({
      name: 'uploading'
    });
    const result = await importGithubToken(token);
    if (!result.ok) {
      logEvent('tengu_remote_setup_result', {
        result: 'import_failed' as SafeString,
        error_kind: result.error.kind as SafeString
      });
      onDone(errorMessage(result.error, getCodeWebUrl()));
      return;
    }

    // Token import succeeded. Environment creation is best-effort — if it
    // fails, the web state machine routes to env-setup on landing, which is
    // one extra click but still better than the OAuth dance.
    await createDefaultEnvironment();
    const url = getCodeWebUrl();
    await openBrowser(url);
    logEvent('tengu_remote_setup_result', {
      result: 'success' as SafeString
    });
    onDone(`Connected as ${result.result.github_username}. Opened ${url}`);
  };
  if (step.name === 'checking') {
    return <LoadingState message="Checking login status…" />;
  }
  if (step.name === 'uploading') {
    return <LoadingState message="Connecting GitHub to Claude…" />;
  }
  const token = step.token;
  return <Dialog title="Connect Claude on the web to GitHub?" onCancel={handleCancel} hideInputGuide>
      <Box flexDirection="column">
        <Text>
          Claude on the web requires connecting to your GitHub account to clone
          and push code on your behalf.
        </Text>
        <Text dimColor>
          Your local credentials are used to authenticate with GitHub
        </Text>
      </Box>
      <Select options={[{
      label: 'Continue',
      value: 'send'
    }, {
      label: 'Cancel',
      value: 'cancel'
    }]} onChange={value => {
      if (value === 'send') {
        void handleConfirm(token);
      } else {
        handleCancel();
      }
    }} onCancel={handleCancel} />
    </Dialog>;
}
export async function call(onDone: LocalJSXCommandOnDone): Promise<React.ReactNode> {
  return <Web onDone={onDone} />;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["execa","React","useEffect","useState","Select","Dialog","LoadingState","Box","Text","logEvent","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","SafeString","LocalJSXCommandOnDone","openBrowser","getGhAuthStatus","createDefaultEnvironment","getCodeWebUrl","ImportTokenError","importGithubToken","isSignedIn","RedactedGithubToken","CheckResult","status","token","checkLoginState","Promise","ghStatus","stdout","stderr","timeout","reject","trimmed","trim","errorMessage","err","codeUrl","kind","Step","name","Web","onDone","step","setStep","then","result","url","handleCancel","handleConfirm","ok","error_kind","error","github_username","label","value","call","ReactNode"],"sources":["remote-setup.tsx"],"sourcesContent":["import { execa } from 'execa'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { Select } from '../../components/CustomSelect/index.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { LoadingState } from '../../components/design-system/LoadingState.js'\nimport { Box, Text } from '../../ink.js'\nimport {\n  logEvent,\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS as SafeString,\n} from '../../services/analytics/index.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport { getGhAuthStatus } from '../../utils/github/ghAuthStatus.js'\nimport {\n  createDefaultEnvironment,\n  getCodeWebUrl,\n  type ImportTokenError,\n  importGithubToken,\n  isSignedIn,\n  RedactedGithubToken,\n} from './api.js'\n\ntype CheckResult =\n  | { status: 'not_signed_in' }\n  | { status: 'has_gh_token'; token: RedactedGithubToken }\n  | { status: 'gh_not_installed' }\n  | { status: 'gh_not_authenticated' }\n\nasync function checkLoginState(): Promise<CheckResult> {\n  if (!(await isSignedIn())) {\n    return { status: 'not_signed_in' }\n  }\n\n  const ghStatus = await getGhAuthStatus()\n  if (ghStatus === 'not_installed') {\n    return { status: 'gh_not_installed' }\n  }\n  if (ghStatus === 'not_authenticated') {\n    return { status: 'gh_not_authenticated' }\n  }\n\n  // ghStatus === 'authenticated'. getGhAuthStatus spawns with stdout:'ignore'\n  // (telemetry-safe); spawn once more with stdout:'pipe' to read the token.\n  const { stdout } = await execa('gh', ['auth', 'token'], {\n    stdout: 'pipe',\n    stderr: 'ignore',\n    timeout: 5000,\n    reject: false,\n  })\n  const trimmed = stdout.trim()\n  if (!trimmed) {\n    return { status: 'gh_not_authenticated' }\n  }\n  return { status: 'has_gh_token', token: new RedactedGithubToken(trimmed) }\n}\n\nfunction errorMessage(err: ImportTokenError, codeUrl: string): string {\n  switch (err.kind) {\n    case 'not_signed_in':\n      return `Login failed. Please visit ${codeUrl} and login using the GitHub App`\n    case 'invalid_token':\n      return 'GitHub rejected that token. Run `gh auth login` and try again.'\n    case 'server':\n      return `Server error (${err.status}). Try again in a moment.`\n    case 'network':\n      return \"Couldn't reach the server. Check your connection.\"\n  }\n}\n\ntype Step =\n  | { name: 'checking' }\n  | { name: 'confirm'; token: RedactedGithubToken }\n  | { name: 'uploading' }\n\nfunction Web({ onDone }: { onDone: LocalJSXCommandOnDone }) {\n  const [step, setStep] = useState<Step>({ name: 'checking' })\n\n  useEffect(() => {\n    logEvent('tengu_remote_setup_started', {})\n    void checkLoginState().then(async result => {\n      switch (result.status) {\n        case 'not_signed_in':\n          logEvent('tengu_remote_setup_result', {\n            result: 'not_signed_in' as SafeString,\n          })\n          onDone('Not signed in to Claude. Run /login first.')\n          return\n        case 'gh_not_installed':\n        case 'gh_not_authenticated': {\n          const url = `${getCodeWebUrl()}/onboarding?step=alt-auth`\n          await openBrowser(url)\n          logEvent('tengu_remote_setup_result', {\n            result: result.status as SafeString,\n          })\n          onDone(\n            result.status === 'gh_not_installed'\n              ? `GitHub CLI not found. Install it via https://cli.github.com/, then run \\`gh auth login\\`, or connect GitHub on the web: ${url}`\n              : `GitHub CLI not authenticated. Run \\`gh auth login\\` and try again, or connect GitHub on the web: ${url}`,\n          )\n          return\n        }\n        case 'has_gh_token':\n          setStep({ name: 'confirm', token: result.token })\n      }\n    })\n    // onDone is stable across renders; intentionally not in deps.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  const handleCancel = () => {\n    logEvent('tengu_remote_setup_result', {\n      result: 'cancelled' as SafeString,\n    })\n    onDone()\n  }\n\n  const handleConfirm = async (token: RedactedGithubToken) => {\n    setStep({ name: 'uploading' })\n\n    const result = await importGithubToken(token)\n    if (!result.ok) {\n      logEvent('tengu_remote_setup_result', {\n        result: 'import_failed' as SafeString,\n        error_kind: result.error.kind as SafeString,\n      })\n      onDone(errorMessage(result.error, getCodeWebUrl()))\n      return\n    }\n\n    // Token import succeeded. Environment creation is best-effort — if it\n    // fails, the web state machine routes to env-setup on landing, which is\n    // one extra click but still better than the OAuth dance.\n    await createDefaultEnvironment()\n\n    const url = getCodeWebUrl()\n    await openBrowser(url)\n\n    logEvent('tengu_remote_setup_result', {\n      result: 'success' as SafeString,\n    })\n    onDone(`Connected as ${result.result.github_username}. Opened ${url}`)\n  }\n\n  if (step.name === 'checking') {\n    return <LoadingState message=\"Checking login status…\" />\n  }\n\n  if (step.name === 'uploading') {\n    return <LoadingState message=\"Connecting GitHub to Claude…\" />\n  }\n\n  const token = step.token\n  return (\n    <Dialog\n      title=\"Connect Claude on the web to GitHub?\"\n      onCancel={handleCancel}\n      hideInputGuide\n    >\n      <Box flexDirection=\"column\">\n        <Text>\n          Claude on the web requires connecting to your GitHub account to clone\n          and push code on your behalf.\n        </Text>\n        <Text dimColor>\n          Your local credentials are used to authenticate with GitHub\n        </Text>\n      </Box>\n      <Select\n        options={[\n          { label: 'Continue', value: 'send' },\n          { label: 'Cancel', value: 'cancel' },\n        ]}\n        onChange={value => {\n          if (value === 'send') {\n            void handleConfirm(token)\n          } else {\n            handleCancel()\n          }\n        }}\n        onCancel={handleCancel}\n      />\n    </Dialog>\n  )\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n): Promise<React.ReactNode> {\n  return <Web onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}