refactor: unify restart gating and update availability sync

2026-05-08 17:08:27 +00:00 · 2026-02-19 10:00:27 +01:00
parent 18179fc2c1
commit b4dbe03298
25 changed files with 288 additions and 41 deletions
--- a/src/infra/update-startup.test.ts
+++ b/src/infra/update-startup.test.ts
@@ -49,6 +49,8 @@ describe("update-startup", () => {
  let checkUpdateStatus: (typeof import("./update-check.js"))["checkUpdateStatus"];
  let resolveNpmChannelTag: (typeof import("./update-check.js"))["resolveNpmChannelTag"];
  let runGatewayUpdateCheck: (typeof import("./update-startup.js"))["runGatewayUpdateCheck"];
+  let getUpdateAvailable: (typeof import("./update-startup.js"))["getUpdateAvailable"];
+  let resetUpdateAvailableStateForTest: (typeof import("./update-startup.js"))["resetUpdateAvailableStateForTest"];
  let loaded = false;

  beforeAll(async () => {
@@ -77,9 +79,14 @@ describe("update-startup", () => {
    if (!loaded) {
      ({ resolveOpenClawPackageRoot } = await import("./openclaw-root.js"));
      ({ checkUpdateStatus, resolveNpmChannelTag } = await import("./update-check.js"));
-      ({ runGatewayUpdateCheck } = await import("./update-startup.js"));
+      ({ runGatewayUpdateCheck, getUpdateAvailable, resetUpdateAvailableStateForTest } =
+        await import("./update-startup.js"));
      loaded = true;
    }
+    vi.mocked(resolveOpenClawPackageRoot).mockReset();
+    vi.mocked(checkUpdateStatus).mockReset();
+    vi.mocked(resolveNpmChannelTag).mockReset();
+    resetUpdateAvailableStateForTest();
  });

  afterEach(async () => {
@@ -99,6 +106,7 @@ describe("update-startup", () => {
    } else {
      delete process.env.VITEST;
    }
+    resetUpdateAvailableStateForTest();
  });

  afterAll(async () => {
@@ -133,6 +141,8 @@ describe("update-startup", () => {
    const parsed = JSON.parse(await fs.readFile(statePath, "utf-8")) as {
      lastNotifiedVersion?: string;
      lastNotifiedTag?: string;
+      lastAvailableVersion?: string;
+      lastAvailableTag?: string;
    };
    return { log, parsed };
  }
@@ -144,6 +154,7 @@ describe("update-startup", () => {
      expect.stringContaining("update available (latest): v2.0.0"),
    );
    expect(parsed.lastNotifiedVersion).toBe("2.0.0");
+    expect(parsed.lastAvailableVersion).toBe("2.0.0");
  });

  it("uses latest when beta tag is older than release", async () => {
@@ -155,6 +166,87 @@ describe("update-startup", () => {
    expect(parsed.lastNotifiedTag).toBe("latest");
  });

+  it("hydrates cached update from persisted state during throttle window", async () => {
+    const statePath = path.join(tempDir, "update-check.json");
+    await fs.writeFile(
+      statePath,
+      JSON.stringify(
+        {
+          lastCheckedAt: new Date(Date.now()).toISOString(),
+          lastAvailableVersion: "2.0.0",
+          lastAvailableTag: "latest",
+        },
+        null,
+        2,
+      ),
+      "utf-8",
+    );
+
+    const onUpdateAvailableChange = vi.fn();
+    await runGatewayUpdateCheck({
+      cfg: { update: { channel: "stable" } },
+      log: { info: vi.fn() },
+      isNixMode: false,
+      allowInTests: true,
+      onUpdateAvailableChange,
+    });
+
+    expect(vi.mocked(checkUpdateStatus)).not.toHaveBeenCalled();
+    expect(onUpdateAvailableChange).toHaveBeenCalledWith({
+      currentVersion: "1.0.0",
+      latestVersion: "2.0.0",
+      channel: "latest",
+    });
+    expect(getUpdateAvailable()).toEqual({
+      currentVersion: "1.0.0",
+      latestVersion: "2.0.0",
+      channel: "latest",
+    });
+  });
+
+  it("emits update change callback when update state clears", async () => {
+    vi.mocked(resolveOpenClawPackageRoot).mockResolvedValue("/opt/openclaw");
+    vi.mocked(checkUpdateStatus).mockResolvedValue({
+      root: "/opt/openclaw",
+      installKind: "package",
+      packageManager: "npm",
+    } satisfies UpdateCheckResult);
+    vi.mocked(resolveNpmChannelTag)
+      .mockResolvedValueOnce({
+        tag: "latest",
+        version: "2.0.0",
+      })
+      .mockResolvedValueOnce({
+        tag: "latest",
+        version: "1.0.0",
+      });
+
+    const onUpdateAvailableChange = vi.fn();
+    await runGatewayUpdateCheck({
+      cfg: { update: { channel: "stable" } },
+      log: { info: vi.fn() },
+      isNixMode: false,
+      allowInTests: true,
+      onUpdateAvailableChange,
+    });
+    vi.setSystemTime(new Date("2026-01-18T11:00:00Z"));
+    await runGatewayUpdateCheck({
+      cfg: { update: { channel: "stable" } },
+      log: { info: vi.fn() },
+      isNixMode: false,
+      allowInTests: true,
+      onUpdateAvailableChange,
+    });
+
+    expect(onUpdateAvailableChange).toHaveBeenNthCalledWith(1, {
+      currentVersion: "1.0.0",
+      latestVersion: "2.0.0",
+      channel: "latest",
+    });
+    expect(onUpdateAvailableChange).toHaveBeenNthCalledWith(2, null);
+    expect(getUpdateAvailable()).toBeNull();
+  });
+
  it("skips update check when disabled in config", async () => {
    const log = { info: vi.fn() };

--- a/src/infra/update-startup.ts
+++ b/src/infra/update-startup.ts
@@ -12,9 +12,11 @@ type UpdateCheckState = {
  lastCheckedAt?: string;
  lastNotifiedVersion?: string;
  lastNotifiedTag?: string;
+  lastAvailableVersion?: string;
+  lastAvailableTag?: string;
 };

-type UpdateAvailable = {
+export type UpdateAvailable = {
  currentVersion: string;
  latestVersion: string;
  channel: string;
@@ -26,6 +28,10 @@ export function getUpdateAvailable(): UpdateAvailable | null {
  return updateAvailableCache;
 }

+export function resetUpdateAvailableStateForTest(): void {
+  updateAvailableCache = null;
+}
+
 const UPDATE_CHECK_FILENAME = "update-check.json";
 const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;

@@ -54,11 +60,54 @@ async function writeState(statePath: string, state: UpdateCheckState): Promise<v
  await fs.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
 }

+function sameUpdateAvailable(a: UpdateAvailable | null, b: UpdateAvailable | null): boolean {
+  if (a === b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  return (
+    a.currentVersion === b.currentVersion &&
+    a.latestVersion === b.latestVersion &&
+    a.channel === b.channel
+  );
+}
+
+function setUpdateAvailableCache(params: {
+  next: UpdateAvailable | null;
+  onUpdateAvailableChange?: (updateAvailable: UpdateAvailable | null) => void;
+}): void {
+  if (sameUpdateAvailable(updateAvailableCache, params.next)) {
+    return;
+  }
+  updateAvailableCache = params.next;
+  params.onUpdateAvailableChange?.(params.next);
+}
+
+function resolvePersistedUpdateAvailable(state: UpdateCheckState): UpdateAvailable | null {
+  const latestVersion = state.lastAvailableVersion?.trim();
+  if (!latestVersion) {
+    return null;
+  }
+  const cmp = compareSemverStrings(VERSION, latestVersion);
+  if (cmp == null || cmp >= 0) {
+    return null;
+  }
+  const channel = state.lastAvailableTag?.trim() || DEFAULT_PACKAGE_CHANNEL;
+  return {
+    currentVersion: VERSION,
+    latestVersion,
+    channel,
+  };
+}
+
 export async function runGatewayUpdateCheck(params: {
  cfg: ReturnType<typeof loadConfig>;
  log: { info: (msg: string, meta?: Record<string, unknown>) => void };
  isNixMode: boolean;
  allowInTests?: boolean;
+  onUpdateAvailableChange?: (updateAvailable: UpdateAvailable | null) => void;
 }): Promise<void> {
  if (shouldSkipCheck(Boolean(params.allowInTests))) {
    return;
@@ -74,6 +123,11 @@ export async function runGatewayUpdateCheck(params: {
  const state = await readState(statePath);
  const now = Date.now();
  const lastCheckedAt = state.lastCheckedAt ? Date.parse(state.lastCheckedAt) : null;
+  const persistedAvailable = resolvePersistedUpdateAvailable(state);
+  setUpdateAvailableCache({
+    next: persistedAvailable,
+    onUpdateAvailableChange: params.onUpdateAvailableChange,
+  });
  if (lastCheckedAt && Number.isFinite(lastCheckedAt)) {
    if (now - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS) {
      return;
@@ -98,6 +152,12 @@ export async function runGatewayUpdateCheck(params: {
  };

  if (status.installKind !== "package") {
+    delete nextState.lastAvailableVersion;
+    delete nextState.lastAvailableTag;
+    setUpdateAvailableCache({
+      next: null,
+      onUpdateAvailableChange: params.onUpdateAvailableChange,
+    });
    await writeState(statePath, nextState);
    return;
  }
@@ -112,11 +172,17 @@ export async function runGatewayUpdateCheck(params: {

  const cmp = compareSemverStrings(VERSION, resolved.version);
  if (cmp != null && cmp < 0) {
-    updateAvailableCache = {
+    const nextAvailable: UpdateAvailable = {
      currentVersion: VERSION,
      latestVersion: resolved.version,
      channel: tag,
    };
+    setUpdateAvailableCache({
+      next: nextAvailable,
+      onUpdateAvailableChange: params.onUpdateAvailableChange,
+    });
+    nextState.lastAvailableVersion = resolved.version;
+    nextState.lastAvailableTag = tag;
    const shouldNotify =
      state.lastNotifiedVersion !== resolved.version || state.lastNotifiedTag !== tag;
    if (shouldNotify) {
@@ -126,6 +192,13 @@ export async function runGatewayUpdateCheck(params: {
      nextState.lastNotifiedVersion = resolved.version;
      nextState.lastNotifiedTag = tag;
    }
+  } else {
+    delete nextState.lastAvailableVersion;
+    delete nextState.lastAvailableTag;
+    setUpdateAvailableCache({
+      next: null,
+      onUpdateAvailableChange: params.onUpdateAvailableChange,
+    });
  }

  await writeState(statePath, nextState);
@@ -135,6 +208,7 @@ export function scheduleGatewayUpdateCheck(params: {
  cfg: ReturnType<typeof loadConfig>;
  log: { info: (msg: string, meta?: Record<string, unknown>) => void };
  isNixMode: boolean;
+  onUpdateAvailableChange?: (updateAvailable: UpdateAvailable | null) => void;
 }): void {
  void runGatewayUpdateCheck(params).catch(() => {});
 }