@xortex/xcode 3.0.1 → 3.0.2

package/components/TeleportError.tsx

@@ -0,0 +1,189 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useCallback, useEffect, useState } from 'react';
+import { checkIsGitClean, checkNeedsClaudeAiLogin } from 'src/utils/background/remote/preconditions.js';
+import { gracefulShutdownSync } from 'src/utils/gracefulShutdown.js';
+import { Box, Text } from '../ink.js';
+import { ConsoleOAuthFlow } from './ConsoleOAuthFlow.js';
+import { Select } from './CustomSelect/index.js';
+import { Dialog } from './design-system/Dialog.js';
+import { TeleportStash } from './TeleportStash.js';
+export type TeleportLocalErrorType = 'needsLogin' | 'needsGitStash';
+type TeleportErrorProps = {
+  onComplete: () => void;
+  errorsToIgnore?: ReadonlySet<TeleportLocalErrorType>;
+};
+
+// Module-level sentinel so the default parameter has stable identity.
+// Previously `= new Set()` created a fresh Set every render, which put
+// a new object in checkErrors' deps and caused the mount effect to
+// re-fire on every render.
+const EMPTY_ERRORS_TO_IGNORE: ReadonlySet<TeleportLocalErrorType> = new Set();
+export function TeleportError(t0) {
+  const $ = _c(18);
+  const {
+    onComplete,
+    errorsToIgnore: t1
+  } = t0;
+  const errorsToIgnore = t1 === undefined ? EMPTY_ERRORS_TO_IGNORE : t1;
+  const [currentError, setCurrentError] = useState(null);
+  const [isLoggingIn, setIsLoggingIn] = useState(false);
+  let t2;
+  if ($[0] !== errorsToIgnore || $[1] !== onComplete) {
+    t2 = async () => {
+      const currentErrors = await getTeleportErrors();
+      const filteredErrors = new Set(Array.from(currentErrors).filter(error => !errorsToIgnore.has(error)));
+      if (filteredErrors.size === 0) {
+        onComplete();
+        return;
+      }
+      if (filteredErrors.has("needsLogin")) {
+        setCurrentError("needsLogin");
+      } else {
+        if (filteredErrors.has("needsGitStash")) {
+          setCurrentError("needsGitStash");
+        }
+      }
+    };
+    $[0] = errorsToIgnore;
+    $[1] = onComplete;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const checkErrors = t2;
+  let t3;
+  let t4;
+  if ($[3] !== checkErrors) {
+    t3 = () => {
+      checkErrors();
+    };
+    t4 = [checkErrors];
+    $[3] = checkErrors;
+    $[4] = t3;
+    $[5] = t4;
+  } else {
+    t3 = $[4];
+    t4 = $[5];
+  }
+  useEffect(t3, t4);
+  const onCancel = _temp;
+  let t5;
+  if ($[6] !== checkErrors) {
+    t5 = () => {
+      setIsLoggingIn(false);
+      checkErrors();
+    };
+    $[6] = checkErrors;
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  const handleLoginComplete = t5;
+  let t6;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = () => {
+      setIsLoggingIn(true);
+    };
+    $[8] = t6;
+  } else {
+    t6 = $[8];
+  }
+  const handleLoginWithClaudeAI = t6;
+  let t7;
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = value => {
+      if (value === "login") {
+        handleLoginWithClaudeAI();
+      } else {
+        onCancel();
+      }
+    };
+    $[9] = t7;
+  } else {
+    t7 = $[9];
+  }
+  const handleLoginDialogSelect = t7;
+  let t8;
+  if ($[10] !== checkErrors) {
+    t8 = () => {
+      checkErrors();
+    };
+    $[10] = checkErrors;
+    $[11] = t8;
+  } else {
+    t8 = $[11];
+  }
+  const handleStashComplete = t8;
+  if (!currentError) {
+    return null;
+  }
+  switch (currentError) {
+    case "needsGitStash":
+      {
+        let t9;
+        if ($[12] !== handleStashComplete) {
+          t9 = <TeleportStash onStashAndContinue={handleStashComplete} onCancel={onCancel} />;
+          $[12] = handleStashComplete;
+          $[13] = t9;
+        } else {
+          t9 = $[13];
+        }
+        return t9;
+      }
+    case "needsLogin":
+      {
+        if (isLoggingIn) {
+          let t9;
+          if ($[14] !== handleLoginComplete) {
+            t9 = <ConsoleOAuthFlow onDone={handleLoginComplete} mode="login" forceLoginMethod="claudeai" />;
+            $[14] = handleLoginComplete;
+            $[15] = t9;
+          } else {
+            t9 = $[15];
+          }
+          return t9;
+        }
+        let t9;
+        if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+          t9 = <Box flexDirection="column"><Text dimColor={true}>Teleport requires a Claude.ai account.</Text><Text dimColor={true}>Your Claude Pro/Max subscription will be used by Claude Code.</Text></Box>;
+          $[16] = t9;
+        } else {
+          t9 = $[16];
+        }
+        let t10;
+        if ($[17] === Symbol.for("react.memo_cache_sentinel")) {
+          t10 = <Dialog title="Log in to Claude" onCancel={onCancel}>{t9}<Select options={[{
+              label: "Login with Claude account",
+              value: "login"
+            }, {
+              label: "Exit",
+              value: "exit"
+            }]} onChange={handleLoginDialogSelect} /></Dialog>;
+          $[17] = t10;
+        } else {
+          t10 = $[17];
+        }
+        return t10;
+      }
+  }
+}
+
+/**
+ * Gets current teleport errors that need to be resolved
+ * @returns Set of teleport error types that need to be handled
+ */
+function _temp() {
+  gracefulShutdownSync(0);
+}
+export async function getTeleportErrors(): Promise<Set<TeleportLocalErrorType>> {
+  const errors = new Set<TeleportLocalErrorType>();
+  const [needsLogin, isGitClean] = await Promise.all([checkNeedsClaudeAiLogin(), checkIsGitClean()]);
+  if (needsLogin) {
+    errors.add('needsLogin');
+  }
+  if (!isGitClean) {
+    errors.add('needsGitStash');
+  }
+  return errors;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","checkIsGitClean","checkNeedsClaudeAiLogin","gracefulShutdownSync","Box","Text","ConsoleOAuthFlow","Select","Dialog","TeleportStash","TeleportLocalErrorType","TeleportErrorProps","onComplete","errorsToIgnore","ReadonlySet","EMPTY_ERRORS_TO_IGNORE","Set","TeleportError","t0","$","_c","t1","undefined","currentError","setCurrentError","isLoggingIn","setIsLoggingIn","t2","currentErrors","getTeleportErrors","filteredErrors","Array","from","filter","error","has","size","checkErrors","t3","t4","onCancel","_temp","t5","handleLoginComplete","t6","Symbol","for","handleLoginWithClaudeAI","t7","value","handleLoginDialogSelect","t8","handleStashComplete","t9","t10","label","Promise","errors","needsLogin","isGitClean","all","add"],"sources":["TeleportError.tsx"],"sourcesContent":["import React, { useCallback, useEffect, useState } from 'react'\nimport {\n  checkIsGitClean,\n  checkNeedsClaudeAiLogin,\n} from 'src/utils/background/remote/preconditions.js'\nimport { gracefulShutdownSync } from 'src/utils/gracefulShutdown.js'\nimport { Box, Text } from '../ink.js'\nimport { ConsoleOAuthFlow } from './ConsoleOAuthFlow.js'\nimport { Select } from './CustomSelect/index.js'\nimport { Dialog } from './design-system/Dialog.js'\nimport { TeleportStash } from './TeleportStash.js'\n\nexport type TeleportLocalErrorType = 'needsLogin' | 'needsGitStash'\n\ntype TeleportErrorProps = {\n  onComplete: () => void\n  errorsToIgnore?: ReadonlySet<TeleportLocalErrorType>\n}\n\n// Module-level sentinel so the default parameter has stable identity.\n// Previously `= new Set()` created a fresh Set every render, which put\n// a new object in checkErrors' deps and caused the mount effect to\n// re-fire on every render.\nconst EMPTY_ERRORS_TO_IGNORE: ReadonlySet<TeleportLocalErrorType> = new Set()\n\nexport function TeleportError({\n  onComplete,\n  errorsToIgnore = EMPTY_ERRORS_TO_IGNORE,\n}: TeleportErrorProps): React.ReactNode {\n  const [currentError, setCurrentError] =\n    useState<TeleportLocalErrorType | null>(null)\n  const [isLoggingIn, setIsLoggingIn] = useState<boolean>(false)\n\n  // Check for errors on mount and when error resolution occurs\n  const checkErrors = useCallback(async () => {\n    const currentErrors = await getTeleportErrors()\n    const filteredErrors = new Set(\n      Array.from(currentErrors).filter(\n        (error: TeleportLocalErrorType) => !errorsToIgnore.has(error),\n      ),\n    )\n\n    // If no errors remain, call onComplete\n    if (filteredErrors.size === 0) {\n      onComplete()\n      return\n    }\n\n    // Set current error to handle (prioritize login over git)\n    if (filteredErrors.has('needsLogin')) {\n      setCurrentError('needsLogin')\n    } else if (filteredErrors.has('needsGitStash')) {\n      setCurrentError('needsGitStash')\n    }\n  }, [onComplete, errorsToIgnore])\n\n  // Check errors on mount\n  useEffect(() => {\n    void checkErrors()\n  }, [checkErrors])\n\n  const onCancel = useCallback(() => {\n    gracefulShutdownSync(0)\n  }, [])\n\n  const handleLoginComplete = useCallback(() => {\n    setIsLoggingIn(false)\n    void checkErrors()\n  }, [checkErrors])\n\n  const handleLoginWithClaudeAI = useCallback(() => {\n    setIsLoggingIn(true)\n  }, [setIsLoggingIn])\n\n  const handleLoginDialogSelect = useCallback(\n    (value: string) => {\n      if (value === 'login') {\n        handleLoginWithClaudeAI()\n      } else {\n        // User selected exit\n        onCancel()\n      }\n    },\n    [handleLoginWithClaudeAI, onCancel],\n  )\n\n  const handleStashComplete = useCallback(() => {\n    void checkErrors()\n  }, [checkErrors])\n\n  // Don't render anything if no current error (onComplete will be called)\n  if (!currentError) {\n    return null\n  }\n\n  switch (currentError) {\n    case 'needsGitStash':\n      return (\n        <TeleportStash\n          onStashAndContinue={handleStashComplete}\n          onCancel={onCancel}\n        />\n      )\n\n    case 'needsLogin': {\n      if (isLoggingIn) {\n        return (\n          <ConsoleOAuthFlow\n            onDone={handleLoginComplete}\n            mode=\"login\"\n            forceLoginMethod=\"claudeai\"\n          />\n        )\n      }\n\n      return (\n        <Dialog title=\"Log in to Claude\" onCancel={onCancel}>\n          <Box flexDirection=\"column\">\n            <Text dimColor>Teleport requires a Claude.ai account.</Text>\n            <Text dimColor>\n              Your Claude Pro/Max subscription will be used by Claude Code.\n            </Text>\n          </Box>\n          <Select\n            options={[\n              { label: 'Login with Claude account', value: 'login' },\n              { label: 'Exit', value: 'exit' },\n            ]}\n            onChange={handleLoginDialogSelect}\n          />\n        </Dialog>\n      )\n    }\n  }\n}\n\n/**\n * Gets current teleport errors that need to be resolved\n * @returns Set of teleport error types that need to be handled\n */\nexport async function getTeleportErrors(): Promise<\n  Set<TeleportLocalErrorType>\n> {\n  const errors = new Set<TeleportLocalErrorType>()\n\n  const [needsLogin, isGitClean] = await Promise.all([\n    checkNeedsClaudeAiLogin(),\n    checkIsGitClean(),\n  ])\n\n  if (needsLogin) {\n    errors.add('needsLogin')\n  }\n  if (!isGitClean) {\n    errors.add('needsGitStash')\n  }\n\n  return errors\n}\n"],"mappings":"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","ignoreList":[]}

package/components/TeleportProgress.tsx

@@ -0,0 +1,140 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import * as React from 'react';
+import { useState } from 'react';
+import type { Root } from '../ink.js';
+import { Box, Text, useAnimationFrame } from '../ink.js';
+import { AppStateProvider } from '../state/AppState.js';
+import { checkOutTeleportedSessionBranch, processMessagesForTeleportResume, type TeleportProgressStep, type TeleportResult, teleportResumeCodeSession } from '../utils/teleport.js';
+type Props = {
+  currentStep: TeleportProgressStep;
+  sessionId?: string;
+};
+const SPINNER_FRAMES = ['◐', '◓', '◑', '◒'];
+const STEPS: {
+  key: TeleportProgressStep;
+  label: string;
+}[] = [{
+  key: 'validating',
+  label: 'Validating session'
+}, {
+  key: 'fetching_logs',
+  label: 'Fetching session logs'
+}, {
+  key: 'fetching_branch',
+  label: 'Getting branch info'
+}, {
+  key: 'checking_out',
+  label: 'Checking out branch'
+}];
+export function TeleportProgress(t0) {
+  const $ = _c(16);
+  const {
+    currentStep,
+    sessionId
+  } = t0;
+  const [ref, time] = useAnimationFrame(100);
+  const frame = Math.floor(time / 100) % SPINNER_FRAMES.length;
+  let t1;
+  if ($[0] !== currentStep) {
+    t1 = s => s.key === currentStep;
+    $[0] = currentStep;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const currentStepIndex = STEPS.findIndex(t1);
+  const t2 = SPINNER_FRAMES[frame];
+  let t3;
+  if ($[2] !== t2) {
+    t3 = <Box marginBottom={1}><Text bold={true} color="claude">{t2} Teleporting session…</Text></Box>;
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  let t4;
+  if ($[4] !== sessionId) {
+    t4 = sessionId && <Box marginBottom={1}><Text dimColor={true}>{sessionId}</Text></Box>;
+    $[4] = sessionId;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== currentStepIndex || $[7] !== frame) {
+    t5 = STEPS.map((step, index) => {
+      const isComplete = index < currentStepIndex;
+      const isCurrent = index === currentStepIndex;
+      const isPending = index > currentStepIndex;
+      let icon;
+      let color;
+      if (isComplete) {
+        icon = figures.tick;
+        color = "green";
+      } else {
+        if (isCurrent) {
+          icon = SPINNER_FRAMES[frame];
+          color = "claude";
+        } else {
+          icon = figures.circle;
+          color = undefined;
+        }
+      }
+      return <Box key={step.key} flexDirection="row"><Box width={2}><Text color={color as never} dimColor={isPending}>{icon}</Text></Box><Text dimColor={isPending} bold={isCurrent}>{step.label}</Text></Box>;
+    });
+    $[6] = currentStepIndex;
+    $[7] = frame;
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  let t6;
+  if ($[9] !== t5) {
+    t6 = <Box flexDirection="column" marginLeft={2}>{t5}</Box>;
+    $[9] = t5;
+    $[10] = t6;
+  } else {
+    t6 = $[10];
+  }
+  let t7;
+  if ($[11] !== ref || $[12] !== t3 || $[13] !== t4 || $[14] !== t6) {
+    t7 = <Box ref={ref} flexDirection="column" paddingX={1} paddingY={1}>{t3}{t4}{t6}</Box>;
+    $[11] = ref;
+    $[12] = t3;
+    $[13] = t4;
+    $[14] = t6;
+    $[15] = t7;
+  } else {
+    t7 = $[15];
+  }
+  return t7;
+}
+
+/**
+ * Teleports to a remote session with progress UI rendered into the existing root.
+ * Fetches the session, checks out the branch, and returns the result.
+ */
+export async function teleportWithProgress(root: Root, sessionId: string): Promise<TeleportResult> {
+  // Capture the setState function from the rendered component
+  let setStep: (step: TeleportProgressStep) => void = () => {};
+  function TeleportProgressWrapper(): React.ReactNode {
+    const [step, _setStep] = useState<TeleportProgressStep>('validating');
+    setStep = _setStep;
+    return <TeleportProgress currentStep={step} sessionId={sessionId} />;
+  }
+  root.render(<AppStateProvider>
+      <TeleportProgressWrapper />
+    </AppStateProvider>);
+  const result = await teleportResumeCodeSession(sessionId, setStep);
+  setStep('checking_out');
+  const {
+    branchName,
+    branchError
+  } = await checkOutTeleportedSessionBranch(result.branch);
+  return {
+    messages: processMessagesForTeleportResume(result.log, branchError),
+    branchName
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useState","Root","Box","Text","useAnimationFrame","AppStateProvider","checkOutTeleportedSessionBranch","processMessagesForTeleportResume","TeleportProgressStep","TeleportResult","teleportResumeCodeSession","Props","currentStep","sessionId","SPINNER_FRAMES","STEPS","key","label","TeleportProgress","t0","$","_c","ref","time","frame","Math","floor","length","t1","s","currentStepIndex","findIndex","t2","t3","t4","t5","map","step","index","isComplete","isCurrent","isPending","icon","color","tick","circle","undefined","t6","t7","teleportWithProgress","root","Promise","setStep","TeleportProgressWrapper","ReactNode","_setStep","render","result","branchName","branchError","branch","messages","log"],"sources":["TeleportProgress.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { useState } from 'react'\nimport type { Root } from '../ink.js'\nimport { Box, Text, useAnimationFrame } from '../ink.js'\nimport { AppStateProvider } from '../state/AppState.js'\nimport {\n  checkOutTeleportedSessionBranch,\n  processMessagesForTeleportResume,\n  type TeleportProgressStep,\n  type TeleportResult,\n  teleportResumeCodeSession,\n} from '../utils/teleport.js'\n\ntype Props = {\n  currentStep: TeleportProgressStep\n  sessionId?: string\n}\n\nconst SPINNER_FRAMES = ['◐', '◓', '◑', '◒']\n\nconst STEPS: { key: TeleportProgressStep; label: string }[] = [\n  { key: 'validating', label: 'Validating session' },\n  { key: 'fetching_logs', label: 'Fetching session logs' },\n  { key: 'fetching_branch', label: 'Getting branch info' },\n  { key: 'checking_out', label: 'Checking out branch' },\n]\n\nexport function TeleportProgress({\n  currentStep,\n  sessionId,\n}: Props): React.ReactNode {\n  const [ref, time] = useAnimationFrame(100)\n  const frame = Math.floor(time / 100) % SPINNER_FRAMES.length\n\n  const currentStepIndex = STEPS.findIndex(s => s.key === currentStep)\n\n  return (\n    <Box ref={ref} flexDirection=\"column\" paddingX={1} paddingY={1}>\n      <Box marginBottom={1}>\n        <Text bold color=\"claude\">\n          {SPINNER_FRAMES[frame]} Teleporting session…\n        </Text>\n      </Box>\n\n      {sessionId && (\n        <Box marginBottom={1}>\n          <Text dimColor>{sessionId}</Text>\n        </Box>\n      )}\n\n      <Box flexDirection=\"column\" marginLeft={2}>\n        {STEPS.map((step, index) => {\n          const isComplete = index < currentStepIndex\n          const isCurrent = index === currentStepIndex\n          const isPending = index > currentStepIndex\n\n          let icon: string\n          let color: string | undefined\n\n          if (isComplete) {\n            icon = figures.tick\n            color = 'green'\n          } else if (isCurrent) {\n            icon = SPINNER_FRAMES[frame]!\n            color = 'claude'\n          } else {\n            icon = figures.circle\n            color = undefined\n          }\n\n          return (\n            <Box key={step.key} flexDirection=\"row\">\n              <Box width={2}>\n                <Text color={color as never} dimColor={isPending}>\n                  {icon}\n                </Text>\n              </Box>\n              <Text dimColor={isPending} bold={isCurrent}>\n                {step.label}\n              </Text>\n            </Box>\n          )\n        })}\n      </Box>\n    </Box>\n  )\n}\n\n/**\n * Teleports to a remote session with progress UI rendered into the existing root.\n * Fetches the session, checks out the branch, and returns the result.\n */\nexport async function teleportWithProgress(\n  root: Root,\n  sessionId: string,\n): Promise<TeleportResult> {\n  // Capture the setState function from the rendered component\n  let setStep: (step: TeleportProgressStep) => void = () => {}\n\n  function TeleportProgressWrapper(): React.ReactNode {\n    const [step, _setStep] = useState<TeleportProgressStep>('validating')\n    setStep = _setStep\n    return <TeleportProgress currentStep={step} sessionId={sessionId} />\n  }\n\n  root.render(\n    <AppStateProvider>\n      <TeleportProgressWrapper />\n    </AppStateProvider>,\n  )\n\n  const result = await teleportResumeCodeSession(sessionId, setStep)\n  setStep('checking_out')\n  const { branchName, branchError } = await checkOutTeleportedSessionBranch(\n    result.branch,\n  )\n  return {\n    messages: processMessagesForTeleportResume(result.log, branchError),\n    branchName,\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/components/TeleportRepoMismatchDialog.tsx

@@ -0,0 +1,104 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useCallback, useState } from 'react';
+import { Box, Text } from '../ink.js';
+import { getDisplayPath } from '../utils/file.js';
+import { removePathFromRepo, validateRepoAtPath } from '../utils/githubRepoPathMapping.js';
+import { Select } from './CustomSelect/index.js';
+import { Dialog } from './design-system/Dialog.js';
+import { Spinner } from './Spinner.js';
+type Props = {
+  targetRepo: string;
+  initialPaths: string[];
+  onSelectPath: (path: string) => void;
+  onCancel: () => void;
+};
+export function TeleportRepoMismatchDialog(t0) {
+  const $ = _c(18);
+  const {
+    targetRepo,
+    initialPaths,
+    onSelectPath,
+    onCancel
+  } = t0;
+  const [availablePaths, setAvailablePaths] = useState(initialPaths);
+  const [errorMessage, setErrorMessage] = useState(null);
+  const [validating, setValidating] = useState(false);
+  let t1;
+  if ($[0] !== availablePaths || $[1] !== onCancel || $[2] !== onSelectPath || $[3] !== targetRepo) {
+    t1 = async value => {
+      if (value === "cancel") {
+        onCancel();
+        return;
+      }
+      setValidating(true);
+      setErrorMessage(null);
+      const isValid = await validateRepoAtPath(value, targetRepo);
+      if (isValid) {
+        onSelectPath(value);
+        return;
+      }
+      removePathFromRepo(targetRepo, value);
+      const updatedPaths = availablePaths.filter(p => p !== value);
+      setAvailablePaths(updatedPaths);
+      setValidating(false);
+      setErrorMessage(`${getDisplayPath(value)} no longer contains the correct repository. Select another path.`);
+    };
+    $[0] = availablePaths;
+    $[1] = onCancel;
+    $[2] = onSelectPath;
+    $[3] = targetRepo;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const handleChange = t1;
+  let t2;
+  if ($[5] !== availablePaths) {
+    let t3;
+    if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+      t3 = {
+        label: "Cancel",
+        value: "cancel"
+      };
+      $[7] = t3;
+    } else {
+      t3 = $[7];
+    }
+    t2 = [...availablePaths.map(_temp), t3];
+    $[5] = availablePaths;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  const options = t2;
+  let t3;
+  if ($[8] !== availablePaths.length || $[9] !== errorMessage || $[10] !== handleChange || $[11] !== options || $[12] !== targetRepo || $[13] !== validating) {
+    t3 = availablePaths.length > 0 ? <><Box flexDirection="column" gap={1}>{errorMessage && <Text color="error">{errorMessage}</Text>}<Text>Open Claude Code in <Text bold={true}>{targetRepo}</Text>:</Text></Box>{validating ? <Box><Spinner /><Text> Validating repository…</Text></Box> : <Select options={options} onChange={value_0 => void handleChange(value_0)} />}</> : <Box flexDirection="column" gap={1}>{errorMessage && <Text color="error">{errorMessage}</Text>}<Text dimColor={true}>Run claude --teleport from a checkout of {targetRepo}</Text></Box>;
+    $[8] = availablePaths.length;
+    $[9] = errorMessage;
+    $[10] = handleChange;
+    $[11] = options;
+    $[12] = targetRepo;
+    $[13] = validating;
+    $[14] = t3;
+  } else {
+    t3 = $[14];
+  }
+  let t4;
+  if ($[15] !== onCancel || $[16] !== t3) {
+    t4 = <Dialog title="Teleport to Repo" onCancel={onCancel} color="background">{t3}</Dialog>;
+    $[15] = onCancel;
+    $[16] = t3;
+    $[17] = t4;
+  } else {
+    t4 = $[17];
+  }
+  return t4;
+}
+function _temp(path) {
+  return {
+    label: <Text>Use <Text bold={true}>{getDisplayPath(path)}</Text></Text>,
+    value: path
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useState","Box","Text","getDisplayPath","removePathFromRepo","validateRepoAtPath","Select","Dialog","Spinner","Props","targetRepo","initialPaths","onSelectPath","path","onCancel","TeleportRepoMismatchDialog","t0","$","_c","availablePaths","setAvailablePaths","errorMessage","setErrorMessage","validating","setValidating","t1","value","isValid","updatedPaths","filter","p","handleChange","t2","t3","Symbol","for","label","map","_temp","options","length","value_0","t4"],"sources":["TeleportRepoMismatchDialog.tsx"],"sourcesContent":["import React, { useCallback, useState } from 'react'\nimport { Box, Text } from '../ink.js'\nimport { getDisplayPath } from '../utils/file.js'\nimport {\n  removePathFromRepo,\n  validateRepoAtPath,\n} from '../utils/githubRepoPathMapping.js'\nimport { Select } from './CustomSelect/index.js'\nimport { Dialog } from './design-system/Dialog.js'\nimport { Spinner } from './Spinner.js'\n\ntype Props = {\n  targetRepo: string\n  initialPaths: string[]\n  onSelectPath: (path: string) => void\n  onCancel: () => void\n}\n\nexport function TeleportRepoMismatchDialog({\n  targetRepo,\n  initialPaths,\n  onSelectPath,\n  onCancel,\n}: Props): React.ReactNode {\n  const [availablePaths, setAvailablePaths] = useState<string[]>(initialPaths)\n  const [errorMessage, setErrorMessage] = useState<string | null>(null)\n  const [validating, setValidating] = useState(false)\n\n  const handleChange = useCallback(\n    async (value: string): Promise<void> => {\n      if (value === 'cancel') {\n        onCancel()\n        return\n      }\n\n      setValidating(true)\n      setErrorMessage(null)\n\n      const isValid = await validateRepoAtPath(value, targetRepo)\n\n      if (isValid) {\n        onSelectPath(value)\n        return\n      }\n\n      // Path is invalid - remove it from config and update state\n      removePathFromRepo(targetRepo, value)\n      const updatedPaths = availablePaths.filter(p => p !== value)\n      setAvailablePaths(updatedPaths)\n      setValidating(false)\n\n      setErrorMessage(\n        `${getDisplayPath(value)} no longer contains the correct repository. Select another path.`,\n      )\n    },\n    [targetRepo, availablePaths, onSelectPath, onCancel],\n  )\n\n  const options = [\n    ...availablePaths.map(path => ({\n      label: (\n        <Text>\n          Use <Text bold>{getDisplayPath(path)}</Text>\n        </Text>\n      ),\n      value: path,\n    })),\n    { label: 'Cancel', value: 'cancel' },\n  ]\n\n  return (\n    <Dialog title=\"Teleport to Repo\" onCancel={onCancel} color=\"background\">\n      {availablePaths.length > 0 ? (\n        <>\n          <Box flexDirection=\"column\" gap={1}>\n            {errorMessage && <Text color=\"error\">{errorMessage}</Text>}\n            <Text>\n              Open Claude Code in <Text bold>{targetRepo}</Text>:\n            </Text>\n          </Box>\n\n          {validating ? (\n            <Box>\n              <Spinner />\n              <Text> Validating repository…</Text>\n            </Box>\n          ) : (\n            <Select\n              options={options}\n              onChange={value => void handleChange(value)}\n            />\n          )}\n        </>\n      ) : (\n        <Box flexDirection=\"column\" gap={1}>\n          {errorMessage && <Text color=\"error\">{errorMessage}</Text>}\n          <Text dimColor>\n            Run claude --teleport from a checkout of {targetRepo}\n          </Text>\n        </Box>\n      )}\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}