isUpdating: boolean;

onChangeIsUpdating: (isUpdating: boolean) => void;

onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void;

autoUpdaterResult: AutoUpdaterResult | null;

showSuccessMessage: boolean;

verbose: boolean;

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>;