@xelauvas/xela-cli 0.1.0

package/src/components/AutoUpdater.tsx

@@ -0,0 +1,198 @@
+import * as React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { useInterval } from 'usehooks-ts';
+import { useUpdateNotification } from '../hooks/useUpdateNotification.js';
+import { Box, Text } from '../ink.js';
+import { type AutoUpdaterResult, getLatestVersion, getMaxVersion, type InstallStatus, installGlobalPackage, shouldSkipVersion } from '../utils/autoUpdater.js';
+import { getGlobalConfig, isAutoUpdaterDisabled } from '../utils/config.js';
+import { logForDebugging } from '../utils/debug.js';
+import { getCurrentInstallationType } from '../utils/doctorDiagnostic.js';
+import { installOrUpdateClaudePackage, localInstallationExists } from '../utils/localInstaller.js';
+import { removeInstalledSymlink } from '../utils/nativeInstaller/index.js';
+import { gt, gte } from '../utils/semver.js';
+import { getInitialSettings } from '../utils/settings/settings.js';
+type Props = {
+  isUpdating: boolean;
+  onChangeIsUpdating: (isUpdating: boolean) => void;
+  onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void;
+  autoUpdaterResult: AutoUpdaterResult | null;
+  showSuccessMessage: boolean;
+  verbose: boolean;
+};
+export function AutoUpdater({
+  isUpdating,
+  onChangeIsUpdating,
+  onAutoUpdaterResult,
+  autoUpdaterResult,
+  showSuccessMessage,
+  verbose
+}: Props): React.ReactNode {
+  const [versions, setVersions] = useState<{
+    global?: string | null;
+    latest?: string | null;
+  }>({});
+  const [hasLocalInstall, setHasLocalInstall] = useState(false);
+  const updateSemver = useUpdateNotification(autoUpdaterResult?.version);
+  useEffect(() => {
+    void localInstallationExists().then(setHasLocalInstall);
+  }, []);
+
+  // Track latest isUpdating value in a ref so the memoized checkForUpdates
+  // callback always sees the current value. Without this, the 30-minute
+  // interval fires with a stale closure where isUpdating is false, allowing
+  // a concurrent installGlobalPackage() to run while one is already in
+  // progress.
+  const isUpdatingRef = useRef(isUpdating);
+  isUpdatingRef.current = isUpdating;
+  const checkForUpdates = React.useCallback(async () => {
+    if (isUpdatingRef.current) {
+      return;
+    }
+    if ("production" === 'test' || "production" === 'development') {
+      logForDebugging('AutoUpdater: Skipping update check in test/dev environment');
+      return;
+    }
+    const currentVersion = MACRO.VERSION;
+    const channel = getInitialSettings()?.autoUpdatesChannel ?? 'latest';
+    let latestVersion = await getLatestVersion(channel);
+    const isDisabled = isAutoUpdaterDisabled();
+
+    // Check if max version is set (server-side kill switch for auto-updates)
+    const maxVersion = await getMaxVersion();
+    if (maxVersion && latestVersion && gt(latestVersion, maxVersion)) {
+      logForDebugging(`AutoUpdater: maxVersion ${maxVersion} is set, capping update from ${latestVersion} to ${maxVersion}`);
+      if (gte(currentVersion, maxVersion)) {
+        logForDebugging(`AutoUpdater: current version ${currentVersion} is already at or above maxVersion ${maxVersion}, skipping update`);
+        setVersions({
+          global: currentVersion,
+          latest: latestVersion
+        });
+        return;
+      }
+      latestVersion = maxVersion;
+    }
+    setVersions({
+      global: currentVersion,
+      latest: latestVersion
+    });
+
+    // Check if update needed and perform update
+    if (!isDisabled && currentVersion && latestVersion && !gte(currentVersion, latestVersion) && !shouldSkipVersion(latestVersion)) {
+      const startTime = Date.now();
+      onChangeIsUpdating(true);
+
+      // Remove native installer symlink since we're using JS-based updates
+      // But only if user hasn't migrated to native installation
+      const config = getGlobalConfig();
+      if (config.installMethod !== 'native') {
+        await removeInstalledSymlink();
+      }
+
+      // Detect actual running installation type
+      const installationType = await getCurrentInstallationType();
+      logForDebugging(`AutoUpdater: Detected installation type: ${installationType}`);
+
+      // Skip update for development builds
+      if (installationType === 'development') {
+        logForDebugging('AutoUpdater: Cannot auto-update development build');
+        onChangeIsUpdating(false);
+        return;
+      }
+
+      // Choose the appropriate update method based on what's actually running
+      let installStatus: InstallStatus;
+      let updateMethod: 'local' | 'global';
+      if (installationType === 'npm-local') {
+        // Use local update for local installations
+        logForDebugging('AutoUpdater: Using local update method');
+        updateMethod = 'local';
+        installStatus = await installOrUpdateClaudePackage(channel);
+      } else if (installationType === 'npm-global') {
+        // Use global update for global installations
+        logForDebugging('AutoUpdater: Using global update method');
+        updateMethod = 'global';
+        installStatus = await installGlobalPackage();
+      } else if (installationType === 'native') {
+        // This shouldn't happen - native should use NativeAutoUpdater
+        logForDebugging('AutoUpdater: Unexpected native installation in non-native updater');
+        onChangeIsUpdating(false);
+        return;
+      } else {
+        // Fallback to config-based detection for unknown types
+        logForDebugging(`AutoUpdater: Unknown installation type, falling back to config`);
+        const isMigrated = config.installMethod === 'local';
+        updateMethod = isMigrated ? 'local' : 'global';
+        if (isMigrated) {
+          installStatus = await installOrUpdateClaudePackage(channel);
+        } else {
+          installStatus = await installGlobalPackage();
+        }
+      }
+      onChangeIsUpdating(false);
+      if (installStatus === 'success') {
+        logEvent('tengu_auto_updater_success', {
+          fromVersion: currentVersion as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          toVersion: latestVersion as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          durationMs: Date.now() - startTime,
+          wasMigrated: updateMethod === 'local',
+          installationType: installationType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+      } else {
+        logEvent('tengu_auto_updater_fail', {
+          fromVersion: currentVersion as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          attemptedVersion: latestVersion as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          status: installStatus as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          durationMs: Date.now() - startTime,
+          wasMigrated: updateMethod === 'local',
+          installationType: installationType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+      }
+      onAutoUpdaterResult({
+        version: latestVersion,
+        status: installStatus
+      });
+    }
+    // isUpdating intentionally omitted from deps; we read isUpdatingRef
+    // instead so the guard is always current without changing callback
+    // identity (which would re-trigger the initial-check useEffect below).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // biome-ignore lint/correctness/useExhaustiveDependencies: isUpdating read via ref
+  }, [onAutoUpdaterResult]);
+
+  // Initial check
+  useEffect(() => {
+    void checkForUpdates();
+  }, [checkForUpdates]);
+
+  // Check every 30 minutes
+  useInterval(checkForUpdates, 30 * 60 * 1000);
+  if (!autoUpdaterResult?.version && (!versions.global || !versions.latest)) {
+    return null;
+  }
+  if (!autoUpdaterResult?.version && !isUpdating) {
+    return null;
+  }
+  return <Box flexDirection="row" gap={1}>
+      {verbose && <Text dimColor wrap="truncate">
+          globalVersion: {versions.global} &middot; latestVersion:{' '}
+          {versions.latest}
+        </Text>}
+      {isUpdating ? <>
+          <Box>
+            <Text color="text" dimColor wrap="truncate">
+              Auto-updating…
+            </Text>
+          </Box>
+        </> : autoUpdaterResult?.status === 'success' && showSuccessMessage && updateSemver && <Text color="success" wrap="truncate">
+            ✓ Update installed · Restart to apply
+          </Text>}
+      {(autoUpdaterResult?.status === 'install_failed' || autoUpdaterResult?.status === 'no_permissions') && <Text color="error" wrap="truncate">
+          ✗ Auto-update failed &middot; Try <Text bold>claude doctor</Text> or{' '}
+          <Text bold>
+            {hasLocalInstall ? `cd ~/.claude/local && npm update ${MACRO.PACKAGE_URL}` : `npm i -g ${MACRO.PACKAGE_URL}`}
+          </Text>
+        </Text>}
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","useInterval","useUpdateNotification","Box","Text","AutoUpdaterResult","getLatestVersion","getMaxVersion","InstallStatus","installGlobalPackage","shouldSkipVersion","getGlobalConfig","isAutoUpdaterDisabled","logForDebugging","getCurrentInstallationType","installOrUpdateClaudePackage","localInstallationExists","removeInstalledSymlink","gt","gte","getInitialSettings","Props","isUpdating","onChangeIsUpdating","onAutoUpdaterResult","autoUpdaterResult","showSuccessMessage","verbose","AutoUpdater","ReactNode","versions","setVersions","global","latest","hasLocalInstall","setHasLocalInstall","updateSemver","version","then","isUpdatingRef","current","checkForUpdates","useCallback","currentVersion","MACRO","VERSION","channel","autoUpdatesChannel","latestVersion","isDisabled","maxVersion","startTime","Date","now","config","installMethod","installationType","installStatus","updateMethod","isMigrated","fromVersion","toVersion","durationMs","wasMigrated","attemptedVersion","status","PACKAGE_URL"],"sources":["AutoUpdater.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useRef, useState } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { useInterval } from 'usehooks-ts'\nimport { useUpdateNotification } from '../hooks/useUpdateNotification.js'\nimport { Box, Text } from '../ink.js'\nimport {\n  type AutoUpdaterResult,\n  getLatestVersion,\n  getMaxVersion,\n  type InstallStatus,\n  installGlobalPackage,\n  shouldSkipVersion,\n} from '../utils/autoUpdater.js'\nimport { getGlobalConfig, isAutoUpdaterDisabled } from '../utils/config.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { getCurrentInstallationType } from '../utils/doctorDiagnostic.js'\nimport {\n  installOrUpdateClaudePackage,\n  localInstallationExists,\n} from '../utils/localInstaller.js'\nimport { removeInstalledSymlink } from '../utils/nativeInstaller/index.js'\nimport { gt, gte } from '../utils/semver.js'\nimport { getInitialSettings } from '../utils/settings/settings.js'\n\ntype Props = {\n  isUpdating: boolean\n  onChangeIsUpdating: (isUpdating: boolean) => void\n  onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void\n  autoUpdaterResult: AutoUpdaterResult | null\n  showSuccessMessage: boolean\n  verbose: boolean\n}\n\nexport function AutoUpdater({\n  isUpdating,\n  onChangeIsUpdating,\n  onAutoUpdaterResult,\n  autoUpdaterResult,\n  showSuccessMessage,\n  verbose,\n}: Props): React.ReactNode {\n  const [versions, setVersions] = useState<{\n    global?: string | null\n    latest?: string | null\n  }>({})\n  const [hasLocalInstall, setHasLocalInstall] = useState(false)\n  const updateSemver = useUpdateNotification(autoUpdaterResult?.version)\n\n  useEffect(() => {\n    void localInstallationExists().then(setHasLocalInstall)\n  }, [])\n\n  // Track latest isUpdating value in a ref so the memoized checkForUpdates\n  // callback always sees the current value. Without this, the 30-minute\n  // interval fires with a stale closure where isUpdating is false, allowing\n  // a concurrent installGlobalPackage() to run while one is already in\n  // progress.\n  const isUpdatingRef = useRef(isUpdating)\n  isUpdatingRef.current = isUpdating\n\n  const checkForUpdates = React.useCallback(async () => {\n    if (isUpdatingRef.current) {\n      return\n    }\n\n    if (\n      \"production\" === 'test' ||\n      \"production\" === 'development'\n    ) {\n      logForDebugging(\n        'AutoUpdater: Skipping update check in test/dev environment',\n      )\n      return\n    }\n\n    const currentVersion = MACRO.VERSION\n    const channel = getInitialSettings()?.autoUpdatesChannel ?? 'latest'\n    let latestVersion = await getLatestVersion(channel)\n    const isDisabled = isAutoUpdaterDisabled()\n\n    // Check if max version is set (server-side kill switch for auto-updates)\n    const maxVersion = await getMaxVersion()\n    if (maxVersion && latestVersion && gt(latestVersion, maxVersion)) {\n      logForDebugging(\n        `AutoUpdater: maxVersion ${maxVersion} is set, capping update from ${latestVersion} to ${maxVersion}`,\n      )\n      if (gte(currentVersion, maxVersion)) {\n        logForDebugging(\n          `AutoUpdater: current version ${currentVersion} is already at or above maxVersion ${maxVersion}, skipping update`,\n        )\n        setVersions({ global: currentVersion, latest: latestVersion })\n        return\n      }\n      latestVersion = maxVersion\n    }\n\n    setVersions({ global: currentVersion, latest: latestVersion })\n\n    // Check if update needed and perform update\n    if (\n      !isDisabled &&\n      currentVersion &&\n      latestVersion &&\n      !gte(currentVersion, latestVersion) &&\n      !shouldSkipVersion(latestVersion)\n    ) {\n      const startTime = Date.now()\n      onChangeIsUpdating(true)\n\n      // Remove native installer symlink since we're using JS-based updates\n      // But only if user hasn't migrated to native installation\n      const config = getGlobalConfig()\n      if (config.installMethod !== 'native') {\n        await removeInstalledSymlink()\n      }\n\n      // Detect actual running installation type\n      const installationType = await getCurrentInstallationType()\n      logForDebugging(\n        `AutoUpdater: Detected installation type: ${installationType}`,\n      )\n\n      // Skip update for development builds\n      if (installationType === 'development') {\n        logForDebugging('AutoUpdater: Cannot auto-update development build')\n        onChangeIsUpdating(false)\n        return\n      }\n\n      // Choose the appropriate update method based on what's actually running\n      let installStatus: InstallStatus\n      let updateMethod: 'local' | 'global'\n\n      if (installationType === 'npm-local') {\n        // Use local update for local installations\n        logForDebugging('AutoUpdater: Using local update method')\n        updateMethod = 'local'\n        installStatus = await installOrUpdateClaudePackage(channel)\n      } else if (installationType === 'npm-global') {\n        // Use global update for global installations\n        logForDebugging('AutoUpdater: Using global update method')\n        updateMethod = 'global'\n        installStatus = await installGlobalPackage()\n      } else if (installationType === 'native') {\n        // This shouldn't happen - native should use NativeAutoUpdater\n        logForDebugging(\n          'AutoUpdater: Unexpected native installation in non-native updater',\n        )\n        onChangeIsUpdating(false)\n        return\n      } else {\n        // Fallback to config-based detection for unknown types\n        logForDebugging(\n          `AutoUpdater: Unknown installation type, falling back to config`,\n        )\n        const isMigrated = config.installMethod === 'local'\n        updateMethod = isMigrated ? 'local' : 'global'\n\n        if (isMigrated) {\n          installStatus = await installOrUpdateClaudePackage(channel)\n        } else {\n          installStatus = await installGlobalPackage()\n        }\n      }\n\n      onChangeIsUpdating(false)\n\n      if (installStatus === 'success') {\n        logEvent('tengu_auto_updater_success', {\n          fromVersion:\n            currentVersion as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          toVersion:\n            latestVersion as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          durationMs: Date.now() - startTime,\n          wasMigrated: updateMethod === 'local',\n          installationType:\n            installationType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n      } else {\n        logEvent('tengu_auto_updater_fail', {\n          fromVersion:\n            currentVersion as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          attemptedVersion:\n            latestVersion as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          status:\n            installStatus as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          durationMs: Date.now() - startTime,\n          wasMigrated: updateMethod === 'local',\n          installationType:\n            installationType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n      }\n\n      onAutoUpdaterResult({\n        version: latestVersion,\n        status: installStatus,\n      })\n    }\n    // isUpdating intentionally omitted from deps; we read isUpdatingRef\n    // instead so the guard is always current without changing callback\n    // identity (which would re-trigger the initial-check useEffect below).\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    // biome-ignore lint/correctness/useExhaustiveDependencies: isUpdating read via ref\n  }, [onAutoUpdaterResult])\n\n  // Initial check\n  useEffect(() => {\n    void checkForUpdates()\n  }, [checkForUpdates])\n\n  // Check every 30 minutes\n  useInterval(checkForUpdates, 30 * 60 * 1000)\n\n  if (!autoUpdaterResult?.version && (!versions.global || !versions.latest)) {\n    return null\n  }\n\n  if (!autoUpdaterResult?.version && !isUpdating) {\n    return null\n  }\n\n  return (\n    <Box flexDirection=\"row\" gap={1}>\n      {verbose && (\n        <Text dimColor wrap=\"truncate\">\n          globalVersion: {versions.global} &middot; latestVersion:{' '}\n          {versions.latest}\n        </Text>\n      )}\n      {isUpdating ? (\n        <>\n          <Box>\n            <Text color=\"text\" dimColor wrap=\"truncate\">\n              Auto-updating…\n            </Text>\n          </Box>\n        </>\n      ) : (\n        autoUpdaterResult?.status === 'success' &&\n        showSuccessMessage &&\n        updateSemver && (\n          <Text color=\"success\" wrap=\"truncate\">\n            ✓ Update installed · Restart to apply\n          </Text>\n        )\n      )}\n      {(autoUpdaterResult?.status === 'install_failed' ||\n        autoUpdaterResult?.status === 'no_permissions') && (\n        <Text color=\"error\" wrap=\"truncate\">\n          ✗ Auto-update failed &middot; Try <Text bold>claude doctor</Text> or{' '}\n          <Text bold>\n            {hasLocalInstall\n              ? `cd ~/.claude/local && npm update ${MACRO.PACKAGE_URL}`\n              : `npm i -g ${MACRO.PACKAGE_URL}`}\n          </Text>\n        </Text>\n      )}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/AutoUpdaterWrapper.tsx

@@ -0,0 +1,91 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import * as React from 'react';
+import type { AutoUpdaterResult } from '../utils/autoUpdater.js';
+import { isAutoUpdaterDisabled } from '../utils/config.js';
+import { logForDebugging } from '../utils/debug.js';
+import { getCurrentInstallationType } from '../utils/doctorDiagnostic.js';
+import { AutoUpdater } from './AutoUpdater.js';
+import { NativeAutoUpdater } from './NativeAutoUpdater.js';
+import { PackageManagerAutoUpdater } from './PackageManagerAutoUpdater.js';
+type Props = {
+  isUpdating: boolean;
+  onChangeIsUpdating: (isUpdating: boolean) => void;
+  onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void;
+  autoUpdaterResult: AutoUpdaterResult | null;
+  showSuccessMessage: boolean;
+  verbose: boolean;
+};
+export function AutoUpdaterWrapper(t0) {
+  const $ = _c(17);
+  const {
+    isUpdating,
+    onChangeIsUpdating,
+    onAutoUpdaterResult,
+    autoUpdaterResult,
+    showSuccessMessage,
+    verbose
+  } = t0;
+  const [useNativeInstaller, setUseNativeInstaller] = React.useState(null);
+  const [isPackageManager, setIsPackageManager] = React.useState(null);
+  let t1;
+  let t2;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => {
+      const checkInstallation = async function checkInstallation() {
+        if (feature("SKIP_DETECTION_WHEN_AUTOUPDATES_DISABLED") && isAutoUpdaterDisabled()) {
+          logForDebugging("AutoUpdaterWrapper: Skipping detection, auto-updates disabled");
+          return;
+        }
+        const installationType = await getCurrentInstallationType();
+        logForDebugging(`AutoUpdaterWrapper: Installation type: ${installationType}`);
+        setUseNativeInstaller(installationType === "native");
+        setIsPackageManager(installationType === "package-manager");
+      };
+      checkInstallation();
+    };
+    t2 = [];
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t1 = $[0];
+    t2 = $[1];
+  }
+  React.useEffect(t1, t2);
+  if (useNativeInstaller === null || isPackageManager === null) {
+    return null;
+  }
+  if (isPackageManager) {
+    let t3;
+    if ($[2] !== autoUpdaterResult || $[3] !== isUpdating || $[4] !== onAutoUpdaterResult || $[5] !== onChangeIsUpdating || $[6] !== showSuccessMessage || $[7] !== verbose) {
+      t3 = <PackageManagerAutoUpdater verbose={verbose} onAutoUpdaterResult={onAutoUpdaterResult} autoUpdaterResult={autoUpdaterResult} isUpdating={isUpdating} onChangeIsUpdating={onChangeIsUpdating} showSuccessMessage={showSuccessMessage} />;
+      $[2] = autoUpdaterResult;
+      $[3] = isUpdating;
+      $[4] = onAutoUpdaterResult;
+      $[5] = onChangeIsUpdating;
+      $[6] = showSuccessMessage;
+      $[7] = verbose;
+      $[8] = t3;
+    } else {
+      t3 = $[8];
+    }
+    return t3;
+  }
+  const Updater = useNativeInstaller ? NativeAutoUpdater : AutoUpdater;
+  let t3;
+  if ($[9] !== Updater || $[10] !== autoUpdaterResult || $[11] !== isUpdating || $[12] !== onAutoUpdaterResult || $[13] !== onChangeIsUpdating || $[14] !== showSuccessMessage || $[15] !== verbose) {
+    t3 = <Updater verbose={verbose} onAutoUpdaterResult={onAutoUpdaterResult} autoUpdaterResult={autoUpdaterResult} isUpdating={isUpdating} onChangeIsUpdating={onChangeIsUpdating} showSuccessMessage={showSuccessMessage} />;
+    $[9] = Updater;
+    $[10] = autoUpdaterResult;
+    $[11] = isUpdating;
+    $[12] = onAutoUpdaterResult;
+    $[13] = onChangeIsUpdating;
+    $[14] = showSuccessMessage;
+    $[15] = verbose;
+    $[16] = t3;
+  } else {
+    t3 = $[16];
+  }
+  return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","AutoUpdaterResult","isAutoUpdaterDisabled","logForDebugging","getCurrentInstallationType","AutoUpdater","NativeAutoUpdater","PackageManagerAutoUpdater","Props","isUpdating","onChangeIsUpdating","onAutoUpdaterResult","autoUpdaterResult","showSuccessMessage","verbose","AutoUpdaterWrapper","t0","$","_c","useNativeInstaller","setUseNativeInstaller","useState","isPackageManager","setIsPackageManager","t1","t2","Symbol","for","checkInstallation","installationType","useEffect","t3","Updater"],"sources":["AutoUpdaterWrapper.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport type { AutoUpdaterResult } from '../utils/autoUpdater.js'\nimport { isAutoUpdaterDisabled } from '../utils/config.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { getCurrentInstallationType } from '../utils/doctorDiagnostic.js'\nimport { AutoUpdater } from './AutoUpdater.js'\nimport { NativeAutoUpdater } from './NativeAutoUpdater.js'\nimport { PackageManagerAutoUpdater } from './PackageManagerAutoUpdater.js'\n\ntype Props = {\n  isUpdating: boolean\n  onChangeIsUpdating: (isUpdating: boolean) => void\n  onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void\n  autoUpdaterResult: AutoUpdaterResult | null\n  showSuccessMessage: boolean\n  verbose: boolean\n}\n\nexport function AutoUpdaterWrapper({\n  isUpdating,\n  onChangeIsUpdating,\n  onAutoUpdaterResult,\n  autoUpdaterResult,\n  showSuccessMessage,\n  verbose,\n}: Props): React.ReactNode {\n  const [useNativeInstaller, setUseNativeInstaller] = React.useState<\n    boolean | null\n  >(null)\n  const [isPackageManager, setIsPackageManager] = React.useState<\n    boolean | null\n  >(null)\n\n  React.useEffect(() => {\n    async function checkInstallation() {\n      // Skip installation type detection if auto-updates are disabled (ant-only)\n      // This avoids potentially slow package manager detection (spawnSync calls)\n      if (\n        feature('SKIP_DETECTION_WHEN_AUTOUPDATES_DISABLED') &&\n        isAutoUpdaterDisabled()\n      ) {\n        logForDebugging(\n          'AutoUpdaterWrapper: Skipping detection, auto-updates disabled',\n        )\n        return\n      }\n\n      const installationType = await getCurrentInstallationType()\n      logForDebugging(\n        `AutoUpdaterWrapper: Installation type: ${installationType}`,\n      )\n      setUseNativeInstaller(installationType === 'native')\n      setIsPackageManager(installationType === 'package-manager')\n    }\n\n    void checkInstallation()\n  }, [])\n\n  // Don't render until we know the installation type\n  if (useNativeInstaller === null || isPackageManager === null) {\n    return null\n  }\n\n  if (isPackageManager) {\n    return (\n      <PackageManagerAutoUpdater\n        verbose={verbose}\n        onAutoUpdaterResult={onAutoUpdaterResult}\n        autoUpdaterResult={autoUpdaterResult}\n        isUpdating={isUpdating}\n        onChangeIsUpdating={onChangeIsUpdating}\n        showSuccessMessage={showSuccessMessage}\n      />\n    )\n  }\n\n  const Updater = useNativeInstaller ? NativeAutoUpdater : AutoUpdater\n\n  return (\n    <Updater\n      verbose={verbose}\n      onAutoUpdaterResult={onAutoUpdaterResult}\n      autoUpdaterResult={autoUpdaterResult}\n      isUpdating={isUpdating}\n      onChangeIsUpdating={onChangeIsUpdating}\n      showSuccessMessage={showSuccessMessage}\n    />\n  )\n}\n"],"mappings":";AAAA,SAASA,OAAO,QAAQ,YAAY;AACpC,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,cAAcC,iBAAiB,QAAQ,yBAAyB;AAChE,SAASC,qBAAqB,QAAQ,oBAAoB;AAC1D,SAASC,eAAe,QAAQ,mBAAmB;AACnD,SAASC,0BAA0B,QAAQ,8BAA8B;AACzE,SAASC,WAAW,QAAQ,kBAAkB;AAC9C,SAASC,iBAAiB,QAAQ,wBAAwB;AAC1D,SAASC,yBAAyB,QAAQ,gCAAgC;AAE1E,KAAKC,KAAK,GAAG;EACXC,UAAU,EAAE,OAAO;EACnBC,kBAAkB,EAAE,CAACD,UAAU,EAAE,OAAO,EAAE,GAAG,IAAI;EACjDE,mBAAmB,EAAE,CAACC,iBAAiB,EAAEX,iBAAiB,EAAE,GAAG,IAAI;EACnEW,iBAAiB,EAAEX,iBAAiB,GAAG,IAAI;EAC3CY,kBAAkB,EAAE,OAAO;EAC3BC,OAAO,EAAE,OAAO;AAClB,CAAC;AAED,OAAO,SAAAC,mBAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAA4B;IAAAT,UAAA;IAAAC,kBAAA;IAAAC,mBAAA;IAAAC,iBAAA;IAAAC,kBAAA;IAAAC;EAAA,IAAAE,EAO3B;EACN,OAAAG,kBAAA,EAAAC,qBAAA,IAAoDpB,KAAK,CAAAqB,QAAS,CAEhE,IAAI,CAAC;EACP,OAAAC,gBAAA,EAAAC,mBAAA,IAAgDvB,KAAK,CAAAqB,QAAS,CAE5D,IAAI,CAAC;EAAA,IAAAG,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAR,CAAA,QAAAS,MAAA,CAAAC,GAAA;IAESH,EAAA,GAAAA,CAAA;MACd,MAAAI,iBAAA,kBAAAA,kBAAA;QAGE,IACE7B,OAAO,CAAC,0CACc,CAAC,IAAvBG,qBAAqB,CAAC,CAAC;UAEvBC,eAAe,CACb,+DACF,CAAC;UAAA;QAAA;QAIH,MAAA0B,gBAAA,GAAyB,MAAMzB,0BAA0B,CAAC,CAAC;QAC3DD,eAAe,CACb,0CAA0C0B,gBAAgB,EAC5D,CAAC;QACDT,qBAAqB,CAACS,gBAAgB,KAAK,QAAQ,CAAC;QACpDN,mBAAmB,CAACM,gBAAgB,KAAK,iBAAiB,CAAC;MAAA,CAC5D;MAEID,iBAAiB,CAAC,CAAC;IAAA,CACzB;IAAEH,EAAA,KAAE;IAAAR,CAAA,MAAAO,EAAA;IAAAP,CAAA,MAAAQ,EAAA;EAAA;IAAAD,EAAA,GAAAP,CAAA;IAAAQ,EAAA,GAAAR,CAAA;EAAA;EAvBLjB,KAAK,CAAA8B,SAAU,CAACN,EAuBf,EAAEC,EAAE,CAAC;EAGN,IAAIN,kBAAkB,KAAK,IAAiC,IAAzBG,gBAAgB,KAAK,IAAI;IAAA,OACnD,IAAI;EAAA;EAGb,IAAIA,gBAAgB;IAAA,IAAAS,EAAA;IAAA,IAAAd,CAAA,QAAAL,iBAAA,IAAAK,CAAA,QAAAR,UAAA,IAAAQ,CAAA,QAAAN,mBAAA,IAAAM,CAAA,QAAAP,kBAAA,IAAAO,CAAA,QAAAJ,kBAAA,IAAAI,CAAA,QAAAH,OAAA;MAEhBiB,EAAA,IAAC,yBAAyB,CACfjB,OAAO,CAAPA,QAAM,CAAC,CACKH,mBAAmB,CAAnBA,oBAAkB,CAAC,CACrBC,iBAAiB,CAAjBA,kBAAgB,CAAC,CACxBH,UAAU,CAAVA,WAAS,CAAC,CACFC,kBAAkB,CAAlBA,mBAAiB,CAAC,CAClBG,kBAAkB,CAAlBA,mBAAiB,CAAC,GACtC;MAAAI,CAAA,MAAAL,iBAAA;MAAAK,CAAA,MAAAR,UAAA;MAAAQ,CAAA,MAAAN,mBAAA;MAAAM,CAAA,MAAAP,kBAAA;MAAAO,CAAA,MAAAJ,kBAAA;MAAAI,CAAA,MAAAH,OAAA;MAAAG,CAAA,MAAAc,EAAA;IAAA;MAAAA,EAAA,GAAAd,CAAA;IAAA;IAAA,OAPFc,EAOE;EAAA;EAIN,MAAAC,OAAA,GAAgBb,kBAAkB,GAAlBb,iBAAoD,GAApDD,WAAoD;EAAA,IAAA0B,EAAA;EAAA,IAAAd,CAAA,QAAAe,OAAA,IAAAf,CAAA,SAAAL,iBAAA,IAAAK,CAAA,SAAAR,UAAA,IAAAQ,CAAA,SAAAN,mBAAA,IAAAM,CAAA,SAAAP,kBAAA,IAAAO,CAAA,SAAAJ,kBAAA,IAAAI,CAAA,SAAAH,OAAA;IAGlEiB,EAAA,IAAC,OAAO,CACGjB,OAAO,CAAPA,QAAM,CAAC,CACKH,mBAAmB,CAAnBA,oBAAkB,CAAC,CACrBC,iBAAiB,CAAjBA,kBAAgB,CAAC,CACxBH,UAAU,CAAVA,WAAS,CAAC,CACFC,kBAAkB,CAAlBA,mBAAiB,CAAC,CAClBG,kBAAkB,CAAlBA,mBAAiB,CAAC,GACtC;IAAAI,CAAA,MAAAe,OAAA;IAAAf,CAAA,OAAAL,iBAAA;IAAAK,CAAA,OAAAR,UAAA;IAAAQ,CAAA,OAAAN,mBAAA;IAAAM,CAAA,OAAAP,kBAAA;IAAAO,CAAA,OAAAJ,kBAAA;IAAAI,CAAA,OAAAH,OAAA;IAAAG,CAAA,OAAAc,EAAA;EAAA;IAAAA,EAAA,GAAAd,CAAA;EAAA;EAAA,OAPFc,EAOE;AAAA","ignoreList":[]}

package/src/components/AwsAuthStatusBox.tsx

@@ -0,0 +1,82 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useEffect, useState } from 'react';
+import { Box, Link, Text } from '../ink.js';
+import { type AwsAuthStatus, AwsAuthStatusManager } from '../utils/awsAuthStatusManager.js';
+const URL_RE = /https?:\/\/\S+/;
+export function AwsAuthStatusBox() {
+  const $ = _c(11);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = AwsAuthStatusManager.getInstance().getStatus();
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const [status, setStatus] = useState(t0);
+  let t1;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => {
+      const unsubscribe = AwsAuthStatusManager.getInstance().subscribe(setStatus);
+      return unsubscribe;
+    };
+    t2 = [];
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  if (!status.isAuthenticating && !status.error && status.output.length === 0) {
+    return null;
+  }
+  if (!status.isAuthenticating && !status.error) {
+    return null;
+  }
+  let t3;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = <Text bold={true} color="permission">Cloud Authentication</Text>;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  let t4;
+  if ($[4] !== status.output) {
+    t4 = status.output.length > 0 && <Box flexDirection="column" marginTop={1}>{status.output.slice(-5).map(_temp)}</Box>;
+    $[4] = status.output;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== status.error) {
+    t5 = status.error && <Box marginTop={1}><Text color="error">{status.error}</Text></Box>;
+    $[6] = status.error;
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  let t6;
+  if ($[8] !== t4 || $[9] !== t5) {
+    t6 = <Box flexDirection="column" borderStyle="round" borderColor="permission" paddingX={1} marginY={1}>{t3}{t4}{t5}</Box>;
+    $[8] = t4;
+    $[9] = t5;
+    $[10] = t6;
+  } else {
+    t6 = $[10];
+  }
+  return t6;
+}
+function _temp(line, index) {
+  const m = line.match(URL_RE);
+  if (!m) {
+    return <Text key={index} dimColor={true}>{line}</Text>;
+  }
+  const url = m[0];
+  const start = m.index ?? 0;
+  const before = line.slice(0, start);
+  const after = line.slice(start + url.length);
+  return <Text key={index} dimColor={true}>{before}<Link url={url}>{url}</Link>{after}</Text>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/components/BaseTextInput.tsx

@@ -0,0 +1,136 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { renderPlaceholder } from '../hooks/renderPlaceholder.js';
+import { usePasteHandler } from '../hooks/usePasteHandler.js';
+import { useDeclaredCursor } from '../ink/hooks/use-declared-cursor.js';
+import { Ansi, Box, Text, useInput } from '../ink.js';
+import type { BaseInputState, BaseTextInputProps } from '../types/textInputTypes.js';
+import type { TextHighlight } from '../utils/textHighlighting.js';
+import { HighlightedInput } from './PromptInput/ShimmeredInput.js';
+type BaseTextInputComponentProps = BaseTextInputProps & {
+  inputState: BaseInputState;
+  children?: React.ReactNode;
+  terminalFocus: boolean;
+  highlights?: TextHighlight[];
+  invert?: (text: string) => string;
+  hidePlaceholderText?: boolean;
+};
+
+/**
+ * A base component for text inputs that handles rendering and basic input
+ */
+export function BaseTextInput(t0) {
+  const $ = _c(14);
+  const {
+    inputState,
+    children,
+    terminalFocus,
+    invert,
+    hidePlaceholderText,
+    ...props
+  } = t0;
+  const {
+    onInput,
+    renderedValue,
+    cursorLine,
+    cursorColumn
+  } = inputState;
+  const t1 = Boolean(props.focus && props.showCursor && terminalFocus);
+  let t2;
+  if ($[0] !== cursorColumn || $[1] !== cursorLine || $[2] !== t1) {
+    t2 = {
+      line: cursorLine,
+      column: cursorColumn,
+      active: t1
+    };
+    $[0] = cursorColumn;
+    $[1] = cursorLine;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const cursorRef = useDeclaredCursor(t2);
+  const {
+    wrappedOnInput,
+    isPasting: t3
+  } = usePasteHandler({
+    onPaste: props.onPaste,
+    onInput: (input, key) => {
+      if (isPasting && key.return) {
+        return;
+      }
+      onInput(input, key);
+    },
+    onImagePaste: props.onImagePaste
+  });
+  const isPasting = t3;
+  const {
+    onIsPastingChange
+  } = props;
+  React.useEffect(() => {
+    if (onIsPastingChange) {
+      onIsPastingChange(isPasting);
+    }
+  }, [isPasting, onIsPastingChange]);
+  const {
+    showPlaceholder,
+    renderedPlaceholder
+  } = renderPlaceholder({
+    placeholder: props.placeholder,
+    value: props.value,
+    showCursor: props.showCursor,
+    focus: props.focus,
+    terminalFocus,
+    invert,
+    hidePlaceholderText
+  });
+  useInput(wrappedOnInput, {
+    isActive: props.focus
+  });
+  const commandWithoutArgs = props.value && props.value.trim().indexOf(" ") === -1 || props.value && props.value.endsWith(" ");
+  const showArgumentHint = Boolean(props.argumentHint && props.value && commandWithoutArgs && props.value.startsWith("/"));
+  const cursorFiltered = props.showCursor && props.highlights ? props.highlights.filter(h => h.dimColor || props.cursorOffset < h.start || props.cursorOffset >= h.end) : props.highlights;
+  const {
+    viewportCharOffset,
+    viewportCharEnd
+  } = inputState;
+  const filteredHighlights = cursorFiltered && viewportCharOffset > 0 ? cursorFiltered.filter(h_0 => h_0.end > viewportCharOffset && h_0.start < viewportCharEnd).map(h_1 => ({
+    ...h_1,
+    start: Math.max(0, h_1.start - viewportCharOffset),
+    end: h_1.end - viewportCharOffset
+  })) : cursorFiltered;
+  const hasHighlights = filteredHighlights && filteredHighlights.length > 0;
+  if (hasHighlights) {
+    return <Box ref={cursorRef}><HighlightedInput text={renderedValue} highlights={filteredHighlights} />{showArgumentHint && <Text dimColor={true}>{props.value?.endsWith(" ") ? "" : " "}{props.argumentHint}</Text>}{children}</Box>;
+  }
+  const T0 = Box;
+  const T1 = Text;
+  const t4 = "truncate-end";
+  const t5 = showPlaceholder && props.placeholderElement ? props.placeholderElement : showPlaceholder && renderedPlaceholder ? <Ansi>{renderedPlaceholder}</Ansi> : <Ansi>{renderedValue}</Ansi>;
+  const t6 = showArgumentHint && <Text dimColor={true}>{props.value?.endsWith(" ") ? "" : " "}{props.argumentHint}</Text>;
+  let t7;
+  if ($[4] !== T1 || $[5] !== children || $[6] !== props || $[7] !== t5 || $[8] !== t6) {
+    t7 = <T1 wrap={t4} dimColor={props.dimColor}>{t5}{t6}{children}</T1>;
+    $[4] = T1;
+    $[5] = children;
+    $[6] = props;
+    $[7] = t5;
+    $[8] = t6;
+    $[9] = t7;
+  } else {
+    t7 = $[9];
+  }
+  let t8;
+  if ($[10] !== T0 || $[11] !== cursorRef || $[12] !== t7) {
+    t8 = <T0 ref={cursorRef}>{t7}</T0>;
+    $[10] = T0;
+    $[11] = cursorRef;
+    $[12] = t7;
+    $[13] = t8;
+  } else {
+    t8 = $[13];
+  }
+  return t8;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","renderPlaceholder","usePasteHandler","useDeclaredCursor","Ansi","Box","Text","useInput","BaseInputState","BaseTextInputProps","TextHighlight","HighlightedInput","BaseTextInputComponentProps","inputState","children","ReactNode","terminalFocus","highlights","invert","text","hidePlaceholderText","BaseTextInput","t0","$","_c","props","onInput","renderedValue","cursorLine","cursorColumn","t1","Boolean","focus","showCursor","t2","line","column","active","cursorRef","wrappedOnInput","isPasting","t3","onPaste","input","key","return","onImagePaste","onIsPastingChange","useEffect","showPlaceholder","renderedPlaceholder","placeholder","value","isActive","commandWithoutArgs","trim","indexOf","endsWith","showArgumentHint","argumentHint","startsWith","cursorFiltered","filter","h","dimColor","cursorOffset","start","end","viewportCharOffset","viewportCharEnd","filteredHighlights","h_0","map","h_1","Math","max","hasHighlights","length","T0","T1","t4","t5","placeholderElement","t6","t7","t8"],"sources":["BaseTextInput.tsx"],"sourcesContent":["import React from 'react'\nimport { renderPlaceholder } from '../hooks/renderPlaceholder.js'\nimport { usePasteHandler } from '../hooks/usePasteHandler.js'\nimport { useDeclaredCursor } from '../ink/hooks/use-declared-cursor.js'\nimport { Ansi, Box, Text, useInput } from '../ink.js'\nimport type {\n  BaseInputState,\n  BaseTextInputProps,\n} from '../types/textInputTypes.js'\nimport type { TextHighlight } from '../utils/textHighlighting.js'\nimport { HighlightedInput } from './PromptInput/ShimmeredInput.js'\n\ntype BaseTextInputComponentProps = BaseTextInputProps & {\n  inputState: BaseInputState\n  children?: React.ReactNode\n  terminalFocus: boolean\n  highlights?: TextHighlight[]\n  invert?: (text: string) => string\n  hidePlaceholderText?: boolean\n}\n\n/**\n * A base component for text inputs that handles rendering and basic input\n */\nexport function BaseTextInput({\n  inputState,\n  children,\n  terminalFocus,\n  invert,\n  hidePlaceholderText,\n  ...props\n}: BaseTextInputComponentProps): React.ReactNode {\n  const { onInput, renderedValue, cursorLine, cursorColumn } = inputState\n\n  // Park the native terminal cursor at the input caret. Terminal emulators\n  // position IME preedit text at the physical cursor, and screen readers /\n  // screen magnifiers track it — so parking here makes CJK input appear\n  // inline and lets accessibility tools follow the input. The Box ref below\n  // is the yoga layout origin; (cursorLine, cursorColumn) is relative to it.\n  // Only active when the input is focused, showing its cursor, and the\n  // terminal itself has focus.\n  const cursorRef = useDeclaredCursor({\n    line: cursorLine,\n    column: cursorColumn,\n    active: Boolean(props.focus && props.showCursor && terminalFocus),\n  })\n\n  const { wrappedOnInput, isPasting } = usePasteHandler({\n    onPaste: props.onPaste,\n    onInput: (input, key) => {\n      // Prevent Enter key from triggering submission during paste\n      if (isPasting && key.return) {\n        return\n      }\n      onInput(input, key)\n    },\n    onImagePaste: props.onImagePaste,\n  })\n\n  // Notify parent when paste state changes\n  const { onIsPastingChange } = props\n  React.useEffect(() => {\n    if (onIsPastingChange) {\n      onIsPastingChange(isPasting)\n    }\n  }, [isPasting, onIsPastingChange])\n\n  const { showPlaceholder, renderedPlaceholder } = renderPlaceholder({\n    placeholder: props.placeholder,\n    value: props.value,\n    showCursor: props.showCursor,\n    focus: props.focus,\n    terminalFocus,\n    invert,\n    hidePlaceholderText,\n  })\n\n  useInput(wrappedOnInput, { isActive: props.focus })\n\n  // Show argument hint only when we have a value and the hint is provided\n  // Only show the argument hint when:\n  // 1. We have a hint to show\n  // 2. We have a command typed (value is not empty)\n  // 3. The command doesn't have arguments yet (no text after the space)\n  // 4. We're actually typing a command (the value starts with /)\n  const commandWithoutArgs =\n    (props.value && props.value.trim().indexOf(' ') === -1) ||\n    (props.value && props.value.endsWith(' '))\n\n  const showArgumentHint = Boolean(\n    props.argumentHint &&\n      props.value &&\n      commandWithoutArgs &&\n      props.value.startsWith('/'),\n  )\n\n  // Filter out highlights that contain the cursor position\n  const cursorFiltered =\n    props.showCursor && props.highlights\n      ? props.highlights.filter(\n          h =>\n            h.dimColor ||\n            props.cursorOffset < h.start ||\n            props.cursorOffset >= h.end,\n        )\n      : props.highlights\n\n  // Adjust highlights for viewport windowing: highlight positions reference the\n  // full input text, but renderedValue only contains the windowed subset.\n  const { viewportCharOffset, viewportCharEnd } = inputState\n  const filteredHighlights =\n    cursorFiltered && viewportCharOffset > 0\n      ? cursorFiltered\n          .filter(h => h.end > viewportCharOffset && h.start < viewportCharEnd)\n          .map(h => ({\n            ...h,\n            start: Math.max(0, h.start - viewportCharOffset),\n            end: h.end - viewportCharOffset,\n          }))\n      : cursorFiltered\n\n  const hasHighlights = filteredHighlights && filteredHighlights.length > 0\n\n  if (hasHighlights) {\n    return (\n      <Box ref={cursorRef}>\n        <HighlightedInput\n          text={renderedValue}\n          highlights={filteredHighlights}\n        />\n        {showArgumentHint && (\n          <Text dimColor>\n            {props.value?.endsWith(' ') ? '' : ' '}\n            {props.argumentHint}\n          </Text>\n        )}\n        {children}\n      </Box>\n    )\n  }\n\n  return (\n    <Box ref={cursorRef}>\n      <Text wrap=\"truncate-end\" dimColor={props.dimColor}>\n        {showPlaceholder && props.placeholderElement ? (\n          props.placeholderElement\n        ) : showPlaceholder && renderedPlaceholder ? (\n          <Ansi>{renderedPlaceholder}</Ansi>\n        ) : (\n          <Ansi>{renderedValue}</Ansi>\n        )}\n        {showArgumentHint && (\n          <Text dimColor>\n            {props.value?.endsWith(' ') ? '' : ' '}\n            {props.argumentHint}\n          </Text>\n        )}\n        {children}\n      </Text>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}