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":[]}

