Fix desktop updater declined-state handling

Rhys Sullivan committed 4 months ago

Commit 9f93d691 parent a968cc56 files · +310 −24Browse files

Unified · Split

6 files

apps/desktop/src/main/index.ts +78 −20
apps/desktop/src/main/updater-state.test.ts +102 −0
apps/desktop/src/main/updater-state.ts +108 −0
apps/desktop/src/shared/update.ts +1 −0
packages/react/src/components/update-card.tsx +20 −4
packages/react/src/hooks/desktop-update.ts +1 −0

   UPDATE_STATUS_CHANNEL,
   UPDATE_STATUS_GET_CHANNEL,
 } from "../shared/update";
+import {
+  planCompletedUpdateCheck,
+  planDownloadedUpdate,
+  planFatalAutoInstallOnQuit,
+  planUpdateCheck,
+  statusAfterUpdateError,
+  type UpdateCheckTrigger,
+} from "./updater-state";
 // Pin userData to a friendly app-name-scoped dir BEFORE app.ready so every
 // Electron-side consumer (electron-store, electron-log, window-state) lands
   // Crash-screen escape hatch: a recurring sidecar crash may already be
   // fixed upstream. Reuses the menu flow — staged updates prompt to install,
   // "no updates" / failures surface in their own dialogs.
-  ipcMain.handle("executor:updates:check", () => runUpdateCheck({ alertOnFail: true }));
+  ipcMain.handle("executor:updates:check", () =>
+    runUpdateCheck({ alertOnFail: true, trigger: "manual" }),
+  );
   ipcMain.handle(UPDATE_STATUS_GET_CHANNEL, (): DesktopUpdateStatus => updateStatus);
   ipcMain.handle(UPDATE_INSTALL_CHANNEL, async (): Promise<void> => {
     const version = "version" in updateStatus ? updateStatus.version : "";
     }
     // Stop the sidecar cleanly before Squirrel.Mac swaps the bundle, matching
     // the native dialog's restart path.
+    stopSupervisedMonitor();
     if (connection) {
       await stopConnection(connection);
       connection = null;
 // ──────────────────────────────────────────────────────────────────────
 let downloadedUpdateVersion: string | null = null;
+let declinedUpdateVersion: string | null = null;
 let updateDialogOpen = false;
 // Renderer-facing auto-update status. The web shell renders a desktop-native
       state === "available" ||
       state === "downloaded" ||
       state === "downloading" ||
+      state === "error" ||
       state === "installing"
     ) {
       if (state === "downloaded") downloadedUpdateVersion = version;
       setUpdateStatus(
-        state === "downloading" ? { state, version, percent: 100 } : { state, version },
+        state === "downloading"
+          ? { state, version, percent: 100 }
+          : state === "error"
+            ? { state, version, message: "Update failed" }
+            : { state, version },
       );
     }
   } catch (error) {
     if (response.response === 0) {
       // Stop the sidecar cleanly before Squirrel.Mac swaps the bundle. A
       // supervised daemon is left running — it's independent of this bundle.
+      stopSupervisedMonitor();
       if (connection) {
         await stopConnection(connection);
         connection = null;
       }
       autoUpdater.quitAndInstall(false, true);
+      return;
     }
+    declinedUpdateVersion = version;
   } finally {
     updateDialogOpen = false;
   }
     }
   });
   autoUpdater.on("update-downloaded", (info: UpdateInfo) => {
-    downloadedUpdateVersion = info.version;
+    const decision = planDownloadedUpdate({
-    setUpdateStatus({ state: "downloaded", version: info.version });
+      stagedVersion: downloadedUpdateVersion,
-    void promptInstallUpdate(info.version);
+      declinedVersion: declinedUpdateVersion,
+      incomingVersion: info.version,
+      trigger: "boot",
+    });
+    downloadedUpdateVersion = decision.stagedVersion;
+    declinedUpdateVersion = decision.declinedVersion;
+    setUpdateStatus(decision.status);
+    if (decision.promptVersion) void promptInstallUpdate(decision.promptVersion);
   });
   autoUpdater.on("error", (err: Error) => {
     log.warn("[updater] error", err);
+    setUpdateStatus(
+      statusAfterUpdateError(updateStatus, "Update failed. Check again from the menu."),
+    );
+    pendingUpdateVersion = null;
   });
   setInterval(() => {
-    if (downloadedUpdateVersion) return; // already staged; waiting on the user
+    void runUpdateCheck({ alertOnFail: false, trigger: "interval" });
-    void runUpdateCheck({ alertOnFail: false });
   }, UPDATE_POLL_INTERVAL_MS);
 };
 interface UpdateCheckOptions {
   readonly alertOnFail: boolean;
+  readonly trigger: UpdateCheckTrigger;
 }
-const runUpdateCheck = async ({ alertOnFail }: UpdateCheckOptions) => {
+type UpdateCheckResult = {
+  readonly isUpdateAvailable?: boolean;
+  readonly updateInfo?: { readonly version?: string };
+};
+const runUpdateCheck = async ({ alertOnFail, trigger }: UpdateCheckOptions) => {
   if (!app.isPackaged) {
     if (alertOnFail) {
       await dialog.showMessageBox({
     }
     return;
   }
-  if (downloadedUpdateVersion) {
+  const checkPlan = planUpdateCheck({ stagedVersion: downloadedUpdateVersion, trigger });
-    await promptInstallUpdate(downloadedUpdateVersion);
+  if (!checkPlan.check) return;
-    return;
-  }
   // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: surface network/update failures only when the user asked
   try {
-    const result = await autoUpdater.checkForUpdates();
+    const result = (await autoUpdater.checkForUpdates()) as UpdateCheckResult | null;
     const newer = result?.isUpdateAvailable === true;
+    const promptAfterCheck = planCompletedUpdateCheck({
+      stagedVersion: checkPlan.promptVersionAfterCheck,
+      trigger,
+      updateAvailable: newer,
+      availableVersion:
+        typeof result?.updateInfo?.version === "string" ? result.updateInfo.version : null,
+    }).promptVersion;
+    if (promptAfterCheck) {
+      await promptInstallUpdate(promptAfterCheck);
+      return;
+    }
     if (!alertOnFail) return;
     if (newer) return; // 'update-downloaded' handler will fire the install dialog
     await dialog.showMessageBox({
     });
   } catch (error) {
     log.warn("[updater] check failed", error);
+    setUpdateStatus(
+      statusAfterUpdateError(updateStatus, "Update failed. Check again from the menu."),
+    );
     if (!alertOnFail) return;
     await dialog.showMessageBox({
       type: "error",
     // Install whatever finishes downloading by the time the user quits the
     // failure dialog; if it downloads while the dialog is open, the regular
     // 'update-downloaded' prompt offers an immediate restart instead.
-    autoUpdater.autoInstallOnAppQuit = true;
+    const autoInstallPlan = planFatalAutoInstallOnQuit({
-    void runUpdateCheck({ alertOnFail: false });
+      packaged: true,
+      retryAfterReset: false,
+    });
+    if (autoInstallPlan.enableDuringFailure) autoUpdater.autoInstallOnAppQuit = true;
+    void runUpdateCheck({ alertOnFail: false, trigger: "boot" });
   }
   // oxlint-disable-next-line executor/no-instanceof-error, executor/no-unknown-error-message -- boundary: sidecar startup failures arrive as plain Node errors and render in a native dialog
   const detail = error instanceof Error ? (error.stack ?? error.message) : String(error);
   // Damaged executor state (failed migration, corrupt SQLite) makes startup
   // fail forever — updating can't fix it. Offer the move-aside reset and one
   // immediate retry. Returns true when boot should be attempted again.
-  if (response === 1 && (await confirmResetState())) {
+  const retryAfterReset = response === 1 && (await confirmResetState());
+  const autoInstallPlan = planFatalAutoInstallOnQuit({
+    packaged: app.isPackaged,
+    retryAfterReset,
+  });
+  if (retryAfterReset) {
+    if (autoInstallPlan.restoreAfterRecovery) autoUpdater.autoInstallOnAppQuit = false;
     const { backupDir } = resetExecutorState();
     await announceBackup(backupDir);
     return true;
       { role: "about" },
       {
         label: "Check for Updates…",
-        click: () => void runUpdateCheck({ alertOnFail: true }),
+        click: () => void runUpdateCheck({ alertOnFail: true, trigger: "manual" }),
       },
       {
         label: "Export Diagnostics…",
     // A crashing sidecar may be a broken release — quietly stage any
     // available update so the install prompt appears on its own (same
     // self-heal as the fatal startup path).
-    void runUpdateCheck({ alertOnFail: false });
+    void runUpdateCheck({ alertOnFail: false, trigger: "boot" });
   });
   // Prefer an OS-supervised daemon: attach to one that's running, kick one
   // that's installed, or offer to install on first run. Quitting the app then
       try {
         await createWindow(supervised);
         armSupervisedMonitor();
-        void runUpdateCheck({ alertOnFail: false });
+        void runUpdateCheck({ alertOnFail: false, trigger: "boot" });
         return;
       } catch (error) {
         log.warn("Failed to load supervised daemon; falling back to managed sidecar", error);
   // Check at boot. If an update is available, autoDownload pulls it and
   // the 'update-downloaded' handler fires the install dialog. Silent on
   // no-update / failure so we don't bother users on every launch.
-  void runUpdateCheck({ alertOnFail: false });
+  void runUpdateCheck({ alertOnFail: false, trigger: "boot" });
 };
 if (ensureSingleInstance()) {

apps/desktop/src/main/updater-state.test.ts+102−0

@@ -0,0 +1,102 @@
	1	import { describe, expect, it } from "@effect/vitest";
	2	import {
	3	planCompletedUpdateCheck,
	4	planDownloadedUpdate,
	5	planFatalAutoInstallOnQuit,
	6	planUpdateCheck,
	7	statusAfterUpdateError,
	8	} from "./updater-state";
	9
	10	describe("updater state decisions", () => {
	11	it("auto-prompts when a newer version arrives after the staged version was declined", () => {
	12	const decision = planDownloadedUpdate({
	13	stagedVersion: "1.5.27",
	14	declinedVersion: "1.5.27",
	15	incomingVersion: "1.5.28",
	16	trigger: "interval",
	17	});
	18
	19	expect(decision).toEqual({
	20	stagedVersion: "1.5.28",
	21	declinedVersion: "1.5.27",
	22	status: { state: "downloaded", version: "1.5.28" },
	23	promptVersion: "1.5.28",
	24	});
	25	});
	26
	27	it("keeps interval checks running without re-prompting the same declined version", () => {
	28	const check = planUpdateCheck({
	29	stagedVersion: "1.5.27",
	30	trigger: "interval",
	31	});
	32	const downloaded = planDownloadedUpdate({
	33	stagedVersion: "1.5.27",
	34	declinedVersion: "1.5.27",
	35	incomingVersion: "1.5.27",
	36	trigger: "interval",
	37	});
	38
	39	expect(check).toEqual({ check: true, promptVersionAfterCheck: null });
	40	expect(downloaded.promptVersion).toBeNull();
	41	});
	42
	43	it("manual checks re-check first and then re-prompt the staged version if no newer version wins", () => {
	44	const check = planUpdateCheck({
	45	stagedVersion: "1.5.27",
	46	trigger: "manual",
	47	});
	48	const completedWithoutNewer = planCompletedUpdateCheck({
	49	stagedVersion: check.promptVersionAfterCheck,
	50	trigger: "manual",
	51	updateAvailable: false,
	52	availableVersion: null,
	53	});
	54	const completedWithNewer = planCompletedUpdateCheck({
	55	stagedVersion: check.promptVersionAfterCheck,
	56	trigger: "manual",
	57	updateAvailable: true,
	58	availableVersion: "1.5.28",
	59	});
	60
	61	expect(check.check).toBe(true);
	62	expect(completedWithoutNewer.promptVersion).toBe("1.5.27");
	63	expect(completedWithNewer.promptVersion).toBeNull();
	64	});
	65
	66	it("moves active update failures to error while idle failures stay idle", () => {
	67	expect(
	68	statusAfterUpdateError(
	69	{ state: "downloading", version: "1.5.27", percent: 42 },
	70	"Download failed",
	71	),
	72	).toEqual({
	73	state: "error",
	74	version: "1.5.27",
	75	message: "Download failed",
	76	});
	77	expect(statusAfterUpdateError({ state: "idle" }, "Download failed")).toEqual({
	78	state: "idle",
	79	});
	80	});
	81
	82	it("restores autoInstallOnAppQuit only when the fatal path recovers", () => {
	83	expect(
	84	planFatalAutoInstallOnQuit({
	85	packaged: true,
	86	retryAfterReset: true,
	87	}),
	88	).toEqual({
	89	enableDuringFailure: true,
	90	restoreAfterRecovery: true,
	91	});
	92	expect(
	93	planFatalAutoInstallOnQuit({
	94	packaged: true,
	95	retryAfterReset: false,
	96	}),
	97	).toEqual({
	98	enableDuringFailure: true,
	99	restoreAfterRecovery: false,
	100	});
	101	});
	102	});

apps/desktop/src/main/updater-state.ts+108−0

@@ -0,0 +1,108 @@
	1	import type { DesktopUpdateStatus } from "../shared/update";
	2
	3	export type UpdateCheckTrigger = "boot" \| "interval" \| "manual";
	4
	5	export interface UpdateCheckPlan {
	6	readonly check: boolean;
	7	readonly promptVersionAfterCheck: string \| null;
	8	}
	9
	10	export interface CompletedUpdateCheckInput {
	11	readonly stagedVersion: string \| null;
	12	readonly trigger: UpdateCheckTrigger;
	13	readonly updateAvailable: boolean;
	14	readonly availableVersion: string \| null;
	15	}
	16
	17	export interface DownloadedUpdateInput {
	18	readonly stagedVersion: string \| null;
	19	readonly declinedVersion: string \| null;
	20	readonly incomingVersion: string;
	21	readonly trigger: UpdateCheckTrigger;
	22	}
	23
	24	export interface DownloadedUpdatePlan {
	25	readonly stagedVersion: string;
	26	readonly declinedVersion: string \| null;
	27	readonly status: DesktopUpdateStatus;
	28	readonly promptVersion: string \| null;
	29	}
	30
	31	const parseVersionParts = (version: string): readonly number[] \| null => {
	32	const core = version.trim().split(/[+-]/, 1)[0];
	33	if (!core) return null;
	34	const parts = core.split(".").map((part) => Number.parseInt(part, 10));
	35	return parts.every((part) => Number.isInteger(part) && part >= 0) ? parts : null;
	36	};
	37
	38	export const compareUpdateVersions = (left: string, right: string): number \| null => {
	39	const leftParts = parseVersionParts(left);
	40	const rightParts = parseVersionParts(right);
	41	if (!leftParts \|\| !rightParts) return null;
	42	const length = Math.max(leftParts.length, rightParts.length);
	43	for (let index = 0; index < length; index += 1) {
	44	const l = leftParts[index] ?? 0;
	45	const r = rightParts[index] ?? 0;
	46	if (l !== r) return l > r ? 1 : -1;
	47	}
	48	return 0;
	49	};
	50
	51	const isNewerUpdateVersion = (incomingVersion: string, declinedVersion: string): boolean => {
	52	const comparison = compareUpdateVersions(incomingVersion, declinedVersion);
	53	return comparison === null ? incomingVersion !== declinedVersion : comparison > 0;
	54	};
	55
	56	export const planUpdateCheck = (input: {
	57	readonly stagedVersion: string \| null;
	58	readonly trigger: UpdateCheckTrigger;
	59	}): UpdateCheckPlan => ({
	60	check: true,
	61	promptVersionAfterCheck: input.trigger === "manual" ? input.stagedVersion : null,
	62	});
	63
	64	export const planCompletedUpdateCheck = (
	65	input: CompletedUpdateCheckInput,
	66	): { readonly promptVersion: string \| null } => {
	67	if (input.trigger !== "manual" \|\| !input.stagedVersion) return { promptVersion: null };
	68	if (!input.updateAvailable) return { promptVersion: input.stagedVersion };
	69	if (!input.availableVersion) return { promptVersion: null };
	70	const comparison = compareUpdateVersions(input.availableVersion, input.stagedVersion);
	71	if (comparison === null) {
	72	return {
	73	promptVersion: input.availableVersion === input.stagedVersion ? input.stagedVersion : null,
	74	};
	75	}
	76	return { promptVersion: comparison <= 0 ? input.stagedVersion : null };
	77	};
	78
	79	export const planDownloadedUpdate = (input: DownloadedUpdateInput): DownloadedUpdatePlan => {
	80	const prompt =
	81	input.trigger === "manual" \|\|
	82	!input.declinedVersion \|\|
	83	isNewerUpdateVersion(input.incomingVersion, input.declinedVersion);
	84	return {
	85	stagedVersion: input.incomingVersion,
	86	declinedVersion: input.declinedVersion,
	87	status: { state: "downloaded", version: input.incomingVersion },
	88	promptVersion: prompt ? input.incomingVersion : null,
	89	};
	90	};
	91
	92	export const statusAfterUpdateError = (
	93	status: DesktopUpdateStatus,
	94	message: string,
	95	): DesktopUpdateStatus => {
	96	if (status.state === "available" \|\| status.state === "downloading" \|\| status.state === "error") {
	97	return { state: "error", version: status.version, message };
	98	}
	99	return status;
	100	};
	101
	102	export const planFatalAutoInstallOnQuit = (input: {
	103	readonly packaged: boolean;
	104	readonly retryAfterReset: boolean;
	105	}): { readonly enableDuringFailure: boolean; readonly restoreAfterRecovery: boolean } => ({
	106	enableDuringFailure: input.packaged,
	107	restoreAfterRecovery: input.packaged && input.retryAfterReset,
	108	});

apps/desktop/src/shared/update.ts+1−0

@@ -13,6 +13,7 @@ export type DesktopUpdateStatus = · 12 unmodified lines
13	\| { readonly state: "available"; readonly version: string }	13	\| { readonly state: "available"; readonly version: string }
14	\| { readonly state: "downloading"; readonly version: string; readonly percent: number }	14	\| { readonly state: "downloading"; readonly version: string; readonly percent: number }
15	\| { readonly state: "downloaded"; readonly version: string }	15	\| { readonly state: "downloaded"; readonly version: string }
		16	\| { readonly state: "error"; readonly version: string; readonly message: string }
16	\| { readonly state: "installing"; readonly version: string };	17	\| { readonly state: "installing"; readonly version: string };
17		18
18	/** Push channel: main → renderer, whenever the update status changes. */	19	/** Push channel: main → renderer, whenever the update status changes. */

packages/react/src/components/update-card.tsx+20−4

 // ── Card chrome ──────────────────────────────────────────────────────────
-/** The bordered card with the download glyph + "Update available" + version.
+/** The bordered card with the download glyph + title + version.
  *  Each variant supplies its own action as children. */
-function UpdateCardShell(props: { version: string | null; children?: React.ReactNode }) {
+function UpdateCardShell(props: {
+  title?: string;
+  version: string | null;
+  children?: React.ReactNode;
+}) {
   return (
     <div className="mx-2 mb-2 rounded-xl border border-primary/25 bg-primary/[0.06] p-3">
       <div className="flex items-center gap-2">
           </svg>
         </div>
         <div className="min-w-0">
-          <p className="text-xs font-semibold text-foreground">Update available</p>
+          <p className="text-xs font-semibold text-foreground">
+            {props.title ?? "Update available"}
+          </p>
           {props.version && <p className="text-sm text-muted-foreground">v{props.version}</p>}
         </div>
       </div>
     if (status.state === "installing") {
       return <p className="mt-2.5 text-xs text-muted-foreground">Restarting…</p>;
     }
+    if (status.state === "error") {
+      return <p className="mt-2.5 text-xs text-muted-foreground">{status.message}</p>;
+    }
     return null;
   })();
-  return <UpdateCardShell version={version}>{action}</UpdateCardShell>;
+  return (
+    <UpdateCardShell
+      title={status.state === "error" ? "Update failed" : undefined}
+      version={version}
+    >
+      {action}
+    </UpdateCardShell>
+  );
 }
 // ── SidebarUpdateCard (the only export the shells consume) ────────────────

packages/react/src/hooks/desktop-update.ts+1−0

@@ -12,6 +12,7 @@ export type DesktopUpdateStatus = · 11 unmodified lines
12	\| { readonly state: "available"; readonly version: string }	12	\| { readonly state: "available"; readonly version: string }
13	\| { readonly state: "downloading"; readonly version: string; readonly percent: number }	13	\| { readonly state: "downloading"; readonly version: string; readonly percent: number }
14	\| { readonly state: "downloaded"; readonly version: string }	14	\| { readonly state: "downloaded"; readonly version: string }
		15	\| { readonly state: "error"; readonly version: string; readonly message: string }
15	\| { readonly state: "installing"; readonly version: string };	16	\| { readonly state: "installing"; readonly version: string };
16		17
17	type DesktopUpdateBridge = {	18	type DesktopUpdateBridge = {