import { resolveStateDir } from "../config/paths.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { runCommandWithTimeout } from "../process/exec.js";

import { asDateTimestampMs, timestampMsToIsoString } from "../shared/number-coercion.js";

import { normalizeLowercaseStringOrEmpty } from "../shared/string-coerce.js";

import { VERSION } from "../version.js";

import { isTruthyEnvValue } from "./env.js";

return bucket % (Math.floor(params.jitterWindowMs) + 1);

}

function resolveUpdateCheckNowMs(valueMs: unknown): number {

return asDateTimestampMs(valueMs) ?? asDateTimestampMs(Date.now()) ?? 0;

}

function resolveUpdateCheckTimestamp(valueMs: unknown): string {

return (

timestampMsToIsoString(valueMs) ??

timestampMsToIsoString(resolveUpdateCheckNowMs(Date.now())) ??

new Date().toISOString()

);

}

function resolveStableAutoApplyAtMs(params: {

state: UpdateCheckState;

nextState: UpdateCheckState;

if (!matchesExisting) {

params.nextState.autoFirstSeenVersion = params.version;

params.nextState.autoFirstSeenTag = params.tag;

params.nextState.autoFirstSeenAt = new Date(params.nowMs).toISOString();

params.nextState.autoFirstSeenAt = resolveUpdateCheckTimestamp(params.nowMs);

} else {

params.nextState.autoFirstSeenVersion = params.state.autoFirstSeenVersion;

params.nextState.autoFirstSeenTag = params.state.autoFirstSeenTag;

params.nextState.autoFirstSeenAt = params.state.autoFirstSeenAt;

}

const firstSeenMs = params.nextState.autoFirstSeenAt

const parsedFirstSeenMs = params.nextState.autoFirstSeenAt

? Date.parse(params.nextState.autoFirstSeenAt)

: params.nowMs;

const firstSeenMs = Number.isFinite(parsedFirstSeenMs) ? parsedFirstSeenMs : params.nowMs;

const baseDelayMs = Math.max(0, params.stableDelayHours) * ONE_HOUR_MS;

const jitterWindowMs = Math.max(0, params.stableJitterHours) * ONE_HOUR_MS;

const jitterMs = resolveStableJitterMs({

const statePath = path.join(resolveStateDir(), UPDATE_CHECK_FILENAME);

const state = await readState(statePath);

const now = Date.now();

const rawNow = Date.now();

const now = resolveUpdateCheckNowMs(rawNow);

const rawNowIsValid = asDateTimestampMs(rawNow) !== undefined;

const lastCheckedAt = state.lastCheckedAt ? Date.parse(state.lastCheckedAt) : null;

if (shouldRunUpdateHints) {

const persistedAvailable = resolvePersistedUpdateAvailable(state);

const checkIntervalMs = shouldRunAutoUpdate

? resolveCheckIntervalMs(params.cfg)

: UPDATE_CHECK_INTERVAL_MS;

if (lastCheckedAt && Number.isFinite(lastCheckedAt)) {

if (rawNowIsValid && lastCheckedAt && Number.isFinite(lastCheckedAt)) {

if (now - lastCheckedAt < checkIntervalMs) {

return;

}

const nextState: UpdateCheckState = {

...state,

lastCheckedAt: new Date(now).toISOString(),

lastCheckedAt: resolveUpdateCheckTimestamp(now),

};

if (status.installKind !== "package") {

params.log.info("auto-update deferred (stable rollout window active)", {

version: resolved.version,

tag,

applyAfter: applyAfterMs ? new Date(applyAfterMs).toISOString() : undefined,

applyAfter: applyAfterMs ? resolveUpdateCheckTimestamp(applyAfterMs) : undefined,

});

} else if (recentAttemptForSameVersion) {

params.log.info("auto-update deferred (recent attempt exists)", {

});

} else {

nextState.autoLastAttemptVersion = resolved.version;

nextState.autoLastAttemptAt = new Date(now).toISOString();

nextState.autoLastAttemptAt = resolveUpdateCheckTimestamp(now);

const outcome = await runAuto({

channel,

timeoutMs: AUTO_UPDATE_COMMAND_TIMEOUT_MS,

root: root ?? undefined,

});

if (outcome.ok) {

nextState.autoLastSuccessVersion = resolved.version;

nextState.autoLastSuccessAt = new Date(now).toISOString();

nextState.autoLastSuccessAt = resolveUpdateCheckTimestamp(now);

params.log.info("auto-update applied", {

channel,

version: resolved.version,