diff --git a/packages/gui-plugins/src/updater/machine.test.ts b/packages/gui-plugins/src/updater/machine.test.ts index 4b780a6192a..43ad740893c 100644 --- a/packages/gui-plugins/src/updater/machine.test.ts +++ b/packages/gui-plugins/src/updater/machine.test.ts @@ -1,7 +1,17 @@ import { afterEach, describe, expect, test } from "bun:test" import { Effect, Exit, Scope } from "effect" import type { UpdaterState } from "@opencode/plugin/gui/updater" -import { make, type Dependencies } from "./machine" +import { + initUpdaterMachine, + make, + toUpdaterState, + transitionUpdater, + type Dependencies, + type UpdaterMachineEffect, + type UpdaterMachineEvent, + type UpdaterMachineState, + type UpdateTarget, +} from "./machine" const scopes: Scope.Closeable[] = [] @@ -15,8 +25,13 @@ afterEach(async () => { async function setup(input?: { currentVersion?: string ready?: { version: string } - /** The release each platform check finds, in order; the last one repeats. "offline" fails the check. */ + /** + * The release each platform check finds, in order; the last one repeats. "offline" fails the check, "none" finds + * nothing and "external:" finds an external download. + */ checks?: readonly string[] + /** Holds every check after the launch check until it resolves. */ + held?: Promise stage?: () => Promise install?: () => Promise external?: boolean @@ -31,18 +46,15 @@ async function setup(input?: { const dependencies: Dependencies = { currentVersion: input?.currentVersion ?? "1.0.0", platform: { - checkForUpdate: Effect.try({ - try: () => { - calls.push("check") - const version = checks[Math.min(cursor.check++, checks.length - 1)] ?? "2.0.0" + checkForUpdate: Effect.suspend(() => { + calls.push("check") + const launch = cursor.check === 0 + const result = found(checks[Math.min(cursor.check++, checks.length - 1)] ?? "2.0.0", !!input?.external) + const held = input?.held - if (version === "offline") throw new Error("offline") + if (launch || !held) return result - return input?.external - ? { mode: "external" as const, version, url: `https://files.test/${version}.dmg` } - : { mode: "restart" as const, version } - }, - catch: (error) => error, + return Effect.promise(() => held).pipe(Effect.andThen(result)) }), stageUpdate: (options) => Effect.tryPromise(async () => { @@ -97,9 +109,22 @@ async function setup(input?: { check: () => Effect.runPromise(updater.check), install: () => Effect.runPromise(updater.install), installFork: () => Effect.runFork(updater.install), + close: () => Effect.runPromise(Scope.close(scope, Exit.void)), } } +function found(next: string, external: boolean): Effect.Effect { + if (next === "offline") return Effect.fail(new Error("offline")) + + if (next === "none") return Effect.succeed(undefined) + const version = next.replace("external:", "") + + if (external || next.startsWith("external:")) + return Effect.succeed({ mode: "external", version, url: `https://files.test/${version}.dmg` }) + + return Effect.succeed({ mode: "restart", version }) +} + const tick = () => new Promise((resolve) => setTimeout(resolve, 0)) describe("updater", () => { @@ -318,4 +343,343 @@ describe("updater", () => { expect(attempts.count).toBe(2) expect(app.state()).toEqual({ status: "installing", version: "2.0.0" }) }) + + test("an external install shows installing at once, and a check meanwhile runs no second platform check", async () => { + const held = Promise.withResolvers() + const app = await setup({ external: true, held: held.promise }) + await app.start() + + const click = app.install() + expect(app.state()).toEqual({ status: "installing", version: "2.0.0" }) + expect(await app.check()).toEqual({ status: "installing", version: "2.0.0" }) + + held.resolve() + await click + expect(app.calls).toEqual(["check", "check", "external:https://files.test/2.0.0.dmg"]) + }) + + test("an install never restarts into a staged update that the final check replaced with a download", async () => { + const app = await setup({ checks: ["2.0.0", "external:2.1.0"] }) + await app.start() + + await app.install() + expect(app.calls).toEqual(["check", "download", "check"]) + expect(app.state()).toEqual({ status: "download-required", version: "2.1.0" }) + expect(app.getReady()).toBeUndefined() + }) + + test("an external install never opens a download that the final check withdrew", async () => { + const app = await setup({ external: true, checks: ["2.0.0", "none"] }) + await app.start() + + await expect(app.install()).rejects.toThrow("External installer is unavailable") + expect(app.calls).toEqual(["check", "check"]) + expect(app.state()).toEqual({ status: "up-to-date" }) + }) + + test("closing the updater settles every caller still waiting", async () => { + const app = await setup({ checks: ["2.0.0"], held: new Promise(() => {}) }) + await app.start() + + const checks = Promise.all([app.check(), app.check()]) + const click = app.install() + await app.close() + + expect(await checks).toEqual([ + { status: "installing", version: "2.0.0" }, + { status: "installing", version: "2.0.0" }, + ]) + await expect(click).rejects.toThrow("Updater stopped") + }) +}) + +const url = (version: string) => `https://files.test/${version}.dmg` + +function idle(input?: { canExternalInstall?: boolean; persistedVersion?: string }) { + return initUpdaterMachine({ + currentVersion: "1.0.0", + enabled: true, + canExternalInstall: input?.canExternalInstall ?? true, + persistedVersion: input?.persistedVersion, + }).state +} + +// Folds events the way the driver applies them and collects every effect. +function run(state: UpdaterMachineState, ...events: UpdaterMachineEvent[]) { + return events.reduce<{ state: UpdaterMachineState; effects: UpdaterMachineEffect[] }>( + (step, event) => { + const next = transitionUpdater(step.state, event) + + return { state: next.state, effects: [...step.effects, ...next.effects] } + }, + { state, effects: [] }, + ) +} + +// 2.0.0 staged after check attempt 1 and download attempt 2. +const ready = () => + run( + idle(), + { type: "check.requested", waiter: 1 }, + { type: "check.succeeded", attempt: 1, target: { mode: "restart", version: "2.0.0" } }, + { type: "stage.succeeded", attempt: 2 }, + ).state + +// 2.0.0 offered as an external download after check attempt 1. +const offered = (input?: { canExternalInstall?: boolean }) => + run( + idle(input), + { type: "check.requested", waiter: 1 }, + { type: "check.succeeded", attempt: 1, target: { mode: "external", version: "2.0.0", url: url("2.0.0") } }, + ).state + +const platformCalls = (effects: readonly UpdaterMachineEffect[]) => + effects.flatMap((effect) => (effect.type.startsWith("platform.") ? [effect.type] : [])) + +describe("transitionUpdater", () => { + test.each([ + { name: "disabled", input: { enabled: false }, state: { status: "disabled" }, effects: [] }, + { name: "clean launch", input: {}, state: { status: "idle", cached: undefined }, effects: [] }, + { + name: "launch after installing the persisted release", + input: { persistedVersion: "1.0.0" }, + state: { status: "idle", cached: undefined }, + effects: [{ type: "persistence.clear" }], + }, + { + name: "launch with a persisted release never installed", + input: { persistedVersion: "2.0.0" }, + state: { status: "idle", cached: "2.0.0" }, + effects: [], + }, + ])("init: $name", (row) => { + const init = initUpdaterMachine({ + currentVersion: "1.0.0", + enabled: true, + canExternalInstall: false, + persistedVersion: undefined, + ...row.input, + }) + + expect(init.state).toMatchObject(row.state) + expect(init.effects).toEqual(row.effects) + }) + + test("a stale release in the updater cache downloads the next one in full", () => { + const step = run( + idle({ persistedVersion: "2.0.0" }), + { type: "check.requested", waiter: 1 }, + { type: "check.succeeded", attempt: 1, target: { mode: "restart", version: "3.0.0" } }, + ) + + expect(step.effects.at(-1)).toEqual({ type: "platform.stage", attempt: 2, differential: false }) + }) + + test("an external install claims the updater at once; a check meanwhile answers without checking", () => { + const install = run(offered(), { type: "install.requested", waiter: 2 }) + expect(toUpdaterState(install.state)).toEqual({ status: "installing", version: "2.0.0" }) + expect(install.effects).toEqual([{ type: "platform.check", attempt: 2 }]) + + const check = run(install.state, { type: "check.requested", waiter: 3 }) + expect(check.effects).toEqual([ + { type: "checks.resolve", waiters: [3], state: { status: "installing", version: "2.0.0" } }, + ]) + }) + + test("an install adopts the silent check already running instead of starting another", () => { + const step = run(offered(), { type: "check.requested", waiter: 2 }, { type: "install.requested", waiter: 3 }) + + expect(platformCalls(step.effects)).toEqual(["platform.check"]) + expect(step.state).toMatchObject({ + status: "installing", + plan: { step: "checking", attempt: 2, checkWaiters: [2] }, + }) + }) + + test.each([ + { name: "its own check", events: [{ type: "install.requested", waiter: 3 }] }, + { + name: "an adopted silent check", + events: [ + { type: "check.requested", waiter: 4 }, + { type: "install.requested", waiter: 3 }, + ], + }, + ] satisfies { name: string; events: UpdaterMachineEvent[] }[])( + "a restart install that finds an external download offers it instead of restarting ($name)", + (row) => { + const step = run(ready(), ...row.events, { + type: "check.succeeded", + attempt: 3, + target: { mode: "external", version: "2.1.0", url: url("2.1.0") }, + }) + + expect(toUpdaterState(step.state)).toEqual({ status: "download-required", version: "2.1.0" }) + expect(platformCalls(step.effects)).toEqual(["platform.check"]) + expect(step.effects).toContainEqual({ type: "persistence.clear" }) + expect(step.effects).toContainEqual({ type: "installs.resolve", waiters: [3] }) + }, + ) + + test.each([ + { name: "withdrawn", target: undefined, state: { status: "up-to-date" } }, + { + name: "replaced by a restart release", + target: { mode: "restart", version: "2.1.0" }, + state: { status: "downloading", version: "2.1.0" }, + }, + ] satisfies { name: string; target: UpdateTarget | undefined; state: UpdaterState }[])( + "an external install never opens a download the final check $name", + (row) => { + const step = run( + offered(), + { type: "install.requested", waiter: 2 }, + { type: "check.succeeded", attempt: 2, target: row.target }, + ) + + expect(toUpdaterState(step.state)).toEqual(row.state) + expect(platformCalls(step.effects)).not.toContain("platform.external") + expect(step.effects).toContainEqual({ + type: "installs.reject", + waiters: [2], + failure: { kind: "external-unavailable" }, + }) + }, + ) + + test("an external install without an installer fails at once", () => { + const state = offered({ canExternalInstall: false }) + const step = transitionUpdater(state, { type: "install.requested", waiter: 2 }) + + expect(step.state).toBe(state) + expect(step.effects).toEqual([{ type: "installs.reject", waiters: [2], failure: { kind: "external-unavailable" } }]) + }) + + test("an install restarts into the staged release when downloading a newer one fails", () => { + const step = run( + ready(), + { type: "install.requested", waiter: 3 }, + { type: "check.succeeded", attempt: 3, target: { mode: "restart", version: "3.0.0" } }, + { type: "stage.failed", attempt: 4, message: "offline" }, + ) + + expect(step.state).toMatchObject({ status: "installing", plan: { version: "2.0.0", step: "restarting" } }) + expect(platformCalls(step.effects)).toEqual(["platform.check", "platform.stage", "platform.restart"]) + }) + + test("a restart handoff holds installing once the app quits, and returns to ready when it fails", () => { + const restarting = run( + ready(), + { type: "install.requested", waiter: 3 }, + { type: "check.succeeded", attempt: 3, target: undefined }, + ).state + + const quit = transitionUpdater(restarting, { type: "restart.succeeded", attempt: 4 }) + expect(toUpdaterState(quit.state)).toEqual({ status: "installing", version: "2.0.0" }) + expect(quit.effects).toEqual([{ type: "installs.resolve", waiters: [3] }]) + + const error = new Error("install failed") + const failed = transitionUpdater(restarting, { type: "restart.failed", attempt: 4, error }) + expect(toUpdaterState(failed.state)).toEqual({ status: "ready", version: "2.0.0" }) + expect(failed.effects).toEqual([{ type: "installs.reject", waiters: [3], failure: { kind: "error", error } }]) + }) + + test("an install or check while the app quits into the installer answers at once", () => { + const quitting = run( + ready(), + { type: "install.requested", waiter: 3 }, + { type: "check.succeeded", attempt: 3, target: undefined }, + { type: "restart.succeeded", attempt: 4 }, + ).state + + const install = transitionUpdater(quitting, { type: "install.requested", waiter: 5 }) + expect(install.state).toBe(quitting) + expect(install.effects).toEqual([{ type: "installs.resolve", waiters: [5] }]) + + const check = transitionUpdater(quitting, { type: "check.requested", waiter: 6 }) + expect(check.state).toBe(quitting) + expect(check.effects).toEqual([ + { type: "checks.resolve", waiters: [6], state: { status: "installing", version: "2.0.0" } }, + ]) + }) + + test.each([ + { name: "checking", state: () => run(idle(), { type: "check.requested", waiter: 1 }).state }, + { + name: "downloading", + state: () => + run( + idle(), + { type: "check.requested", waiter: 1 }, + { type: "check.succeeded", attempt: 1, target: { mode: "restart", version: "2.0.0" } }, + ).state, + }, + { name: "a silent refresh", state: () => run(ready(), { type: "check.requested", waiter: 2 }).state }, + { name: "an external refresh", state: () => run(offered(), { type: "check.requested", waiter: 2 }).state }, + { name: "an installation", state: () => run(ready(), { type: "install.requested", waiter: 2 }).state }, + ])("ignores results of a superseded attempt during $name", (row) => { + const state = row.state() + + const events: UpdaterMachineEvent[] = [ + { type: "check.succeeded", attempt: 99, target: undefined }, + { type: "check.failed", attempt: 99, message: "offline" }, + { type: "stage.succeeded", attempt: 99 }, + { type: "stage.failed", attempt: 99, message: "offline" }, + { type: "restart.succeeded", attempt: 99 }, + { type: "restart.failed", attempt: 99, error: new Error("failed") }, + { type: "external.succeeded", attempt: 99 }, + { type: "external.failed", attempt: 99, error: new Error("failed") }, + ] + + events.forEach((event) => { + const step = transitionUpdater(state, event) + expect(step.state).toBe(state) + expect(step.effects).toEqual([]) + }) + }) + + test("a caller that stops waiting leaves the check running for the others", () => { + const step = run( + idle(), + { type: "check.requested", waiter: 1 }, + { type: "check.requested", waiter: 2 }, + { type: "waiter.cancelled", waiter: 1 }, + { type: "check.succeeded", attempt: 1, target: undefined }, + ) + + expect(step.effects).toEqual([ + { type: "platform.check", attempt: 1 }, + { type: "persistence.clear" }, + { type: "checks.resolve", waiters: [2], state: { status: "up-to-date" } }, + ]) + }) + + test("disposing cancels the running attempt, settles every caller and ignores later events", () => { + const installing = run(ready(), { type: "check.requested", waiter: 2 }, { type: "install.requested", waiter: 3 }) + const disposed = transitionUpdater(installing.state, { type: "disposed" }) + + expect(disposed.effects).toEqual([ + { type: "attempt.cancel", attempt: 3 }, + { type: "installs.reject", waiters: [3], failure: { kind: "disposed" } }, + { type: "checks.resolve", waiters: [2], state: { status: "installing", version: "2.0.0" } }, + ]) + expect(transitionUpdater(disposed.state, { type: "check.succeeded", attempt: 3, target: undefined }).state).toBe( + disposed.state, + ) + expect(transitionUpdater(disposed.state, { type: "install.requested", waiter: 4 }).effects).toEqual([ + { type: "installs.reject", waiters: [4], failure: { kind: "disposed" } }, + ]) + }) + + test("disposing leaves a restart handoff to ApplicationLifecycle", () => { + const restarting = run( + ready(), + { type: "install.requested", waiter: 3 }, + { type: "check.succeeded", attempt: 3, target: undefined }, + ).state + + expect(transitionUpdater(restarting, { type: "disposed" }).effects).toEqual([ + { type: "installs.reject", waiters: [3], failure: { kind: "disposed" } }, + ]) + }) }) diff --git a/packages/gui-plugins/src/updater/machine.ts b/packages/gui-plugins/src/updater/machine.ts index 31e2a16d473..a89b9854a7a 100644 --- a/packages/gui-plugins/src/updater/machine.ts +++ b/packages/gui-plugins/src/updater/machine.ts @@ -1,7 +1,7 @@ -import { Deferred, Effect, Exit, Fiber, Match } from "effect" +import { Cause, Deferred, Effect, Exit, Fiber } from "effect" import type { UpdaterState } from "@opencode/plugin/gui/updater" -type UpdateTarget = +export type UpdateTarget = | { readonly mode: "restart"; readonly version: string } | { readonly mode: "external"; readonly version: string; readonly url: string } @@ -26,227 +26,185 @@ export type Dependencies = { readonly changed: (state: UpdaterState) => void } -/** The update state machine. Fibers it forks belong to the caller's scope. */ +// Ceilings for platform calls that can hang on a stalled socket (macOS waits for Squirrel's `update-downloaded`). +// The restart handoff has none here: ApplicationLifecycle bounds stopping and resuming the plugins, and +// `installAndRestart` bounds the handoff itself. +const CHECK_TIMEOUT_MS = 60_000 + +const STAGE_TIMEOUT_MS = 60 * 60_000 + +const EXTERNAL_TIMEOUT_MS = 30_000 + +/** Runs the update machine. Fibers it forks belong to the caller's scope; closing it settles every caller. */ export const make = Effect.fn("Updater.make")(function* (dependencies: Dependencies) { const runFork = Effect.runForkWith(yield* Effect.context()) - let state: UpdaterState = dependencies.platform ? { status: "idle" } : { status: "disabled" } - let pending: Deferred.Deferred | undefined - let installing: Deferred.Deferred | undefined + const platform = dependencies.platform + const persisted = platform ? yield* dependencies.persistence.get : undefined - const transition = (next: UpdaterState) => { - runFork(Effect.logInfo("updater state changed", { from: state.status, to: next.status })) - state = next - dependencies.changed(state) + const init = initUpdaterMachine({ + currentVersion: dependencies.currentVersion, + enabled: !!platform, + canExternalInstall: !!platform?.externalInstall, + persistedVersion: persisted?.version, + }) - return state + const current = { state: init.state, view: toUpdaterState(init.state) } + const queue: UpdaterMachineEvent[] = [] + const checks = new Map>() + const installs = new Map>() + const attempts = new Map>() + const issued = { waiter: 0 } + + // Effects run in order, each isolated, so one that throws never stops the events and effects after it. + const isolate = (run: () => void) => + void Promise.try(run).catch((error) => + runFork(Effect.logError("updater effect failed", { message: String(error) })), + ) + + // An event dispatched while another applies (a platform call that settles synchronously) waits its turn. + const dispatch = (event: UpdaterMachineEvent) => { + queue.push(event) + + if (queue.length > 1) return + + for (const next of queue) isolate(() => apply(next)) + queue.length = 0 } - // electron-updater builds NSIS deltas against the installer of the running version but reads the "old" blockmap from - // the last download. Once a release is staged without installing, the two no longer match and every later delta fails - // its checksum before falling back to a full download, so remember which release the cache holds and skip the attempt. - let downloaded: string | undefined - let target: UpdateTarget | undefined + const apply = (event: UpdaterMachineEvent) => { + const step = transitionUpdater(current.state, event) + current.state = step.state + const view = toUpdaterState(step.state) - const stage = (platform: Platform, version: string) => - Effect.gen(function* () { - if (downloaded) - yield* Effect.logInfo("skipping differential download, updater cache is stale", { - current: dependencies.currentVersion, - staged: downloaded, - version, - }) - yield* platform.stageUpdate({ differential: !downloaded }) - downloaded = version - yield* dependencies.persistence.set({ version }) - }) - - const findAndStage = (platform: Platform) => - Effect.gen(function* () { - yield* Effect.sync(() => transition({ status: "checking" })) - const next = yield* platform.checkForUpdate - - if (!next || (next.mode === "restart" && next.version === dependencies.currentVersion)) { - yield* dependencies.persistence.clear - - return transition({ status: "up-to-date" }) - } - - target = next - - if (next.mode === "external") { - yield* dependencies.persistence.clear - - return transition({ status: "download-required", version: next.version }) - } - - transition({ status: "downloading", version: next.version }) - yield* stage(platform, next.version) - - return transition({ status: "ready", version: next.version }) - }).pipe( - Effect.catch((error) => - Effect.sync(() => - transition({ status: "error", message: error instanceof Error ? error.message : String(error) }), - ), - ), - ) - - const refreshStaged = (platform: Platform, staged: string) => - Effect.gen(function* () { - const next = yield* platform.checkForUpdate - - if (!next) return state - target = next - - if (next.mode === "external") { - yield* dependencies.persistence.clear - - return transition({ status: "download-required", version: next.version }) - } - - if (next.version === staged || next.version === dependencies.currentVersion) return state - yield* stage(platform, next.version) - - return transition({ status: installing ? "installing" : "ready", version: next.version }) - }).pipe( - Effect.catch((error) => - Effect.sync(() => { - runFork( - Effect.logWarning("updater refresh failed, keeping staged update", { - staged, - message: error instanceof Error ? error.message : String(error), - }), - ) - - return state - }), - ), - ) - - const refreshExternal = (platform: Platform) => - Effect.gen(function* () { - const next = yield* platform.checkForUpdate - - if (!next || next.mode !== "external") return state - target = next - - if (state.status === "download-required" && state.version === next.version) return state - - return transition({ status: "download-required", version: next.version }) - }).pipe( - Effect.catch((error) => - Effect.sync(() => { - runFork( - Effect.logWarning("external updater refresh failed, keeping download available", { - message: error instanceof Error ? error.message : String(error), - }), - ) - - return state - }), - ), - ) - - const check = Effect.suspend(() => { - const platform = dependencies.platform - - if (!platform || state.status === "installing") return Effect.succeed(state) - - if (pending) return Deferred.await(pending) - const deferred = Deferred.makeUnsafe() - pending = deferred - - const update = Match.value(state).pipe( - Match.when({ status: "ready" }, (ready) => refreshStaged(platform, ready.version)), - Match.when({ status: "download-required" }, () => refreshExternal(platform)), - Match.orElse(() => findAndStage(platform)), - ) - - return update.pipe( - Effect.tap((result) => Deferred.succeed(deferred, result)), - Effect.ensuring(Effect.sync(() => (pending = undefined))), - ) - }) - - const install = Effect.suspend(() => { - if (installing) return Deferred.await(installing) - const platform = dependencies.platform - - if (!platform) return Effect.fail(new Error("Update is not ready to install")) - - if (state.status === "download-required") { - const staged = state.version - const deferred = Deferred.makeUnsafe() - installing = deferred - - return Effect.gen(function* () { - yield* pending ? Deferred.await(pending) : refreshExternal(platform) - - if (!target || target.mode !== "external" || !platform.externalInstall) - return yield* Effect.fail(new Error("External installer is unavailable")) - transition({ status: "installing", version: target.version }) - - return yield* platform.externalInstall(target.url) - }).pipe( - Effect.exit, - Effect.flatMap((exit) => - Deferred.done(deferred, exit).pipe( - Effect.andThen( - Effect.sync(() => { - installing = undefined - - if (state.status === "installing") - transition({ status: "download-required", version: target?.version ?? staged }) - }), - ), - Effect.andThen(Deferred.await(deferred)), - ), - ), - ) + if (step.state.status !== "disposed" && !sameView(current.view, view)) { + runFork(Effect.logInfo("updater state changed", { from: current.view.status, to: view.status })) + current.view = view + isolate(() => dependencies.changed(view)) } - if (state.status !== "ready") return Effect.fail(new Error("Update is not ready to install")) - const staged = state.version - transition({ status: "installing", version: staged }) - const deferred = Deferred.makeUnsafe() - installing = deferred + step.effects.forEach((effect) => isolate(() => perform(effect))) + } - return Effect.gen(function* () { - yield* pending ? Deferred.await(pending) : refreshStaged(platform, staged) - yield* dependencies.restart(platform.installAndRestart) + const perform = (effect: UpdaterMachineEffect) => { + if (effect.type === "checks.resolve") + return effect.waiters.forEach((waiter) => settle(checks, waiter, Exit.succeed({ ...effect.state }))) - // The app is quitting into the installer. - return yield* Effect.never - }).pipe( - Effect.exit, - Effect.flatMap((exit) => - Deferred.done(deferred, exit).pipe( - Effect.andThen( - Effect.sync(() => { - installing = undefined + if (effect.type === "installs.resolve") + return effect.waiters.forEach((waiter) => settle(installs, waiter, Exit.void)) - if (Exit.isFailure(exit) && state.status === "installing") { - transition({ status: "ready", version: state.version }) - } - }), - ), - Effect.andThen(Deferred.await(deferred)), + if (effect.type === "installs.reject") + return effect.waiters.forEach((waiter) => settle(installs, waiter, Exit.fail(failureToError(effect.failure)))) + + if (effect.type === "persistence.set") + return void runFork(dependencies.persistence.set({ version: effect.version })) + + if (effect.type === "persistence.clear") return void runFork(dependencies.persistence.clear) + + if (effect.type === "log") { + const log = effect.level === "info" ? Effect.logInfo : Effect.logWarning + + return void runFork(log(effect.message, effect.data)) + } + + if (effect.type === "attempt.cancel") { + attempts.get(effect.attempt)?.interruptUnsafe() + + return void attempts.delete(effect.attempt) + } + + // Only an enabled machine, which has a platform, starts platform work. + if (!platform) return + const attempt = effect.attempt + + if (effect.type === "platform.check") + return track( + attempt, + bounded(platform.checkForUpdate, CHECK_TIMEOUT_MS, "Update check timed out"), + (target) => ({ type: "check.succeeded", attempt, target }), + (error) => ({ type: "check.failed", attempt, message: error.message }), + ) + + if (effect.type === "platform.stage") + return track( + attempt, + bounded( + platform.stageUpdate({ differential: effect.differential }), + STAGE_TIMEOUT_MS, + "Update download timed out", ), + () => ({ type: "stage.succeeded", attempt }), + (error) => ({ type: "stage.failed", attempt, message: error.message }), + ) + + if (effect.type === "platform.restart") + return track( + attempt, + dependencies.restart(platform.installAndRestart), + () => ({ type: "restart.succeeded", attempt }), + (error) => ({ type: "restart.failed", attempt, error }), + ) + + track( + attempt, + bounded( + platform.externalInstall?.(effect.url) ?? Effect.fail(failureToError({ kind: "external-unavailable" })), + EXTERNAL_TIMEOUT_MS, + "External installer did not open", ), + () => ({ type: "external.succeeded", attempt }), + (error) => ({ type: "external.failed", attempt, error }), ) - }) + } - const start = Effect.gen(function* () { - const ready = yield* dependencies.persistence.get + // Platform work runs in its own fiber, never a caller's, so a caller that goes away leaves it running for the rest. + const track = ( + attempt: number, + work: Effect.Effect, + succeeded: (value: A) => UpdaterMachineEvent, + failed: (error: Error) => UpdaterMachineEvent, + ) => { + const fiber = runFork(work) + attempts.set(attempt, fiber) + fiber.addObserver((exit) => { + attempts.delete(attempt) - if (ready?.version === dependencies.currentVersion) yield* dependencies.persistence.clear + if (Exit.isSuccess(exit)) return dispatch(succeeded(exit.value)) - // Any other persisted target was downloaded by an earlier launch and never installed, so its blockmap is cached. - if (ready && ready.version !== dependencies.currentVersion) downloaded = ready.version - yield* check - }) + // A cancelled attempt reports nothing; the machine already moved on. + if (Cause.hasInterruptsOnly(exit.cause)) return + const error = Cause.squash(exit.cause) + dispatch(failed(error instanceof Error ? error : new Error(String(error)))) + }) + } - const starting = yield* start.pipe(Effect.forkScoped) + const request = ( + waiters: Map>, + type: "check.requested" | "install.requested", + ) => + Effect.suspend(() => { + issued.waiter += 1 + const waiter = issued.waiter + const deferred = Deferred.makeUnsafe() + waiters.set(waiter, deferred) + // Claims the work before returning, so the state is already `installing` on the caller's next line. + dispatch({ type, waiter }) + + return Deferred.await(deferred).pipe( + Effect.onInterrupt(() => + Effect.sync(() => { + waiters.delete(waiter) + dispatch({ type: "waiter.cancelled", waiter }) + }), + ), + ) + }) + + const check = request(checks, "check.requested").pipe(Effect.orDie) + const install = request(installs, "install.requested") + + init.effects.forEach(perform) + yield* Effect.addFinalizer(() => Effect.sync(() => dispatch({ type: "disposed" }))) + const starting = yield* check.pipe(Effect.forkScoped) yield* Effect.gen(function* () { yield* Effect.sleep("10 minutes") yield* check @@ -255,7 +213,707 @@ export const make = Effect.fn("Updater.make")(function* (dependencies: Dependenc return { check, install, - state: () => state, + state: () => current.view, started: Fiber.join(starting).pipe(Effect.orDie), } }) + +function settle(waiters: Map>, waiter: number, exit: Exit.Exit) { + const deferred = waiters.get(waiter) + waiters.delete(waiter) + + if (deferred) Deferred.doneUnsafe(deferred, exit) +} + +function bounded(work: Effect.Effect, duration: number, message: string) { + return work.pipe(Effect.timeoutOrElse({ duration, orElse: () => Effect.fail(new Error(message)) })) +} + +function failureToError(failure: UpdaterFailure) { + if (failure.kind === "not-ready") return new Error("Update is not ready to install") + + if (failure.kind === "external-unavailable") return new Error("External installer is unavailable") + + if (failure.kind === "disposed") return new Error("Updater stopped") + + return failure.error +} + +function sameView(a: UpdaterState, b: UpdaterState) { + return a.status === b.status && viewDetail(a) === viewDetail(b) +} + +function viewDetail(view: UpdaterState) { + if (view.status === "error") return view.message + + if ( + view.status === "downloading" || + view.status === "ready" || + view.status === "download-required" || + view.status === "installing" + ) + return view.version + + return undefined +} + +/** A silent check, then maybe a download of a newer release, while a staged update stays installable. */ +export type StagedRefresh = + | { readonly step: "checking"; readonly attempt: number; readonly checkWaiters: readonly number[] } + | { + readonly step: "staging" + readonly attempt: number + readonly nextVersion: string + readonly checkWaiters: readonly number[] + } + +/** A silent check while an external download stays offered. */ +export type ExternalRefresh = { readonly attempt: number; readonly checkWaiters: readonly number[] } + +/** + * The step an installation is at. A restart checks for a newer release, may stage it, then hands off to + * `ApplicationLifecycle.restart`; `quitting` holds once the app quits into the installer. An external install checks + * that its download is still current, then opens it. + */ +export type InstallingPlan = + | (StagedRefresh & { readonly mode: "restart"; readonly version: string }) + | { readonly mode: "restart"; readonly version: string; readonly step: "restarting"; readonly attempt: number } + | { readonly mode: "restart"; readonly version: string; readonly step: "quitting" } + | { + readonly mode: "external" + readonly version: string + readonly url: string + readonly step: "checking" + readonly attempt: number + readonly checkWaiters: readonly number[] + } + | { + readonly mode: "external" + readonly version: string + readonly url: string + readonly step: "opening" + readonly attempt: number + } + +type Meta = { + readonly currentVersion: string + readonly canExternalInstall: boolean + /** The last attempt id issued; a result for any other attempt is stale. */ + readonly issued: number + /** + * The release electron-updater's cache holds, from an earlier download that was never installed. electron-updater + * builds NSIS deltas against the running version's installer but reads the "old" blockmap from the last download, so + * while this is set every delta would fail its checksum: download in full instead. + */ + readonly cached: string | undefined +} + +/** + * The updater's lifecycle. Callers waiting on a check or an install are listed by waiter id in the phase that will + * answer them; `issued` and each phase's `attempt` fence platform results. + */ +export type UpdaterMachineState = + | { readonly status: "disabled" } + | (Meta & { readonly status: "idle" }) + | (Meta & { readonly status: "checking"; readonly attempt: number; readonly checkWaiters: readonly number[] }) + | (Meta & { + readonly status: "downloading" + readonly attempt: number + readonly version: string + readonly checkWaiters: readonly number[] + }) + | (Meta & { readonly status: "up-to-date" }) + | (Meta & { readonly status: "ready"; readonly version: string; readonly refresh?: StagedRefresh }) + | (Meta & { + readonly status: "download-required" + readonly version: string + readonly url: string + readonly refresh?: ExternalRefresh + }) + | (Meta & { + readonly status: "installing" + readonly plan: InstallingPlan + readonly installWaiters: readonly number[] + }) + | (Meta & { readonly status: "error"; readonly message: string }) + | { readonly status: "disposed"; readonly last: UpdaterState } + +type Active = Exclude + +export type UpdaterMachineEvent = + | { readonly type: "check.requested"; readonly waiter: number } + | { readonly type: "install.requested"; readonly waiter: number } + | { readonly type: "waiter.cancelled"; readonly waiter: number } + | { readonly type: "check.succeeded"; readonly attempt: number; readonly target: UpdateTarget | undefined } + | { readonly type: "check.failed"; readonly attempt: number; readonly message: string } + | { readonly type: "stage.succeeded"; readonly attempt: number } + | { readonly type: "stage.failed"; readonly attempt: number; readonly message: string } + | { readonly type: "restart.succeeded"; readonly attempt: number } + | { readonly type: "restart.failed"; readonly attempt: number; readonly error: Error } + | { readonly type: "external.succeeded"; readonly attempt: number } + | { readonly type: "external.failed"; readonly attempt: number; readonly error: Error } + | { readonly type: "disposed" } + +type Settled = Extract + +export type UpdaterFailure = + | { readonly kind: "not-ready" } + | { readonly kind: "external-unavailable" } + | { readonly kind: "disposed" } + | { readonly kind: "error"; readonly error: Error } + +export type UpdaterMachineEffect = + | { readonly type: "platform.check"; readonly attempt: number } + | { readonly type: "platform.stage"; readonly attempt: number; readonly differential: boolean } + | { readonly type: "platform.restart"; readonly attempt: number } + | { readonly type: "platform.external"; readonly attempt: number; readonly url: string } + | { readonly type: "attempt.cancel"; readonly attempt: number } + | { readonly type: "persistence.set"; readonly version: string } + | { readonly type: "persistence.clear" } + | { readonly type: "checks.resolve"; readonly waiters: readonly number[]; readonly state: UpdaterState } + | { readonly type: "installs.resolve"; readonly waiters: readonly number[] } + | { readonly type: "installs.reject"; readonly waiters: readonly number[]; readonly failure: UpdaterFailure } + | { + readonly type: "log" + readonly level: "info" | "warning" + readonly message: string + readonly data: Readonly> + } + +export type UpdaterMachineTransition = { + readonly state: UpdaterMachineState + readonly effects: readonly UpdaterMachineEffect[] +} + +export function initUpdaterMachine(input: { + readonly currentVersion: string + readonly enabled: boolean + readonly canExternalInstall: boolean + /** The release an earlier launch staged. */ + readonly persistedVersion: string | undefined +}): UpdaterMachineTransition { + if (!input.enabled) return { state: { status: "disabled" }, effects: [] } + const installed = input.persistedVersion === input.currentVersion + + return { + state: { + status: "idle", + currentVersion: input.currentVersion, + canExternalInstall: input.canExternalInstall, + issued: 0, + // Any other persisted release was downloaded by an earlier launch and never installed, so its blockmap is cached. + cached: installed ? undefined : input.persistedVersion, + }, + effects: installed ? [{ type: "persistence.clear" }] : [], + } +} + +export function transitionUpdater(state: UpdaterMachineState, event: UpdaterMachineEvent): UpdaterMachineTransition { + if (state.status === "disposed") return afterDispose(state, event) + + if (event.type === "disposed") return dispose(state) + + if (state.status === "disabled") return disabled(state, event) + + if (event.type === "check.requested") return checkRequested(state, event.waiter) + + if (event.type === "install.requested") return installRequested(state, event.waiter) + + if (event.type === "waiter.cancelled") return waiterCancelled(state, event.waiter) + + if (event.attempt !== activeAttempt(state)) return unchanged(state) + + return settled(state, event) +} + +/** What windows see. Always a fresh object. */ +export function toUpdaterState(state: UpdaterMachineState): UpdaterState { + if (state.status === "disposed") return { ...state.last } + + if (state.status === "downloading" || state.status === "ready" || state.status === "download-required") + return { status: state.status, version: state.version } + + if (state.status === "installing") return { status: "installing", version: state.plan.version } + + if (state.status === "error") return { status: "error", message: state.message } + + return { status: state.status } +} + +function afterDispose(state: Extract, event: UpdaterMachineEvent) { + if (event.type === "check.requested") return withChecks(state, [event.waiter]) + + if (event.type === "install.requested") + return unchanged(state, [rejectInstalls([event.waiter], { kind: "disposed" })]) + + return unchanged(state) +} + +// Platform work still running is cancelled and every caller hears now. The restart handoff is ApplicationLifecycle's +// to settle, so it is left running. +function dispose(state: Exclude): UpdaterMachineTransition { + const last = toUpdaterState(state) + + if (state.status === "disabled") return { state: { status: "disposed", last }, effects: [] } + const attempt = activeAttempt(state) + const cancel = attempt === undefined || restarting(state) ? [] : [{ type: "attempt.cancel" as const, attempt }] + const installs = state.status === "installing" ? state.installWaiters : [] + + return withChecks({ status: "disposed", last }, checkWaitersOf(state), [ + ...cancel, + ...(installs.length > 0 ? [rejectInstalls(installs, { kind: "disposed" })] : []), + ]) +} + +function disabled(state: Extract, event: UpdaterMachineEvent) { + if (event.type === "check.requested") return withChecks(state, [event.waiter]) + + if (event.type === "install.requested") + return unchanged(state, [rejectInstalls([event.waiter], { kind: "not-ready" })]) + + return unchanged(state) +} + +function checkRequested(state: Active, waiter: number): UpdaterMachineTransition { + const attempt = state.issued + 1 + + if (state.status === "idle" || state.status === "up-to-date" || state.status === "error") + return { + state: { ...meta(state), issued: attempt, status: "checking", attempt, checkWaiters: [waiter] }, + effects: [{ type: "platform.check", attempt }], + } + + if (state.status === "checking" || state.status === "downloading") + return unchanged({ ...state, checkWaiters: [...state.checkWaiters, waiter] }) + + // A staged or offered update stays on screen while a silent check runs; later checks join it. + if (state.status === "ready" || state.status === "download-required") { + if (state.refresh) return unchanged(withRefreshWaiters(state, [...state.refresh.checkWaiters, waiter])) + + return { + state: + state.status === "ready" + ? { ...state, issued: attempt, refresh: { step: "checking", attempt, checkWaiters: [waiter] } } + : { ...state, issued: attempt, refresh: { attempt, checkWaiters: [waiter] } }, + effects: [{ type: "platform.check", attempt }], + } + } + + // An installation is underway: report it without checking again. + return withChecks(state, [waiter]) +} + +// The installation claims the updater in the same event, so a check that starts meanwhile never runs a second +// platform check. A silent check or download already running becomes the installation's own. +function installRequested(state: Active, waiter: number): UpdaterMachineTransition { + // The app is already quitting into the installer, and nothing settles this step again: answer at once. + if (state.status === "installing" && state.plan.step === "quitting") + return unchanged(state, [{ type: "installs.resolve", waiters: [waiter] }]) + + if (state.status === "installing") return unchanged({ ...state, installWaiters: [...state.installWaiters, waiter] }) + + const attempt = state.issued + 1 + + if (state.status === "ready") { + if (state.refresh) + return unchanged({ + ...meta(state), + status: "installing", + plan: { ...state.refresh, mode: "restart", version: state.version }, + installWaiters: [waiter], + }) + + return { + state: { + ...meta(state), + issued: attempt, + status: "installing", + plan: { mode: "restart", version: state.version, step: "checking", attempt, checkWaiters: [] }, + installWaiters: [waiter], + }, + effects: [{ type: "platform.check", attempt }], + } + } + + if (state.status !== "download-required") return unchanged(state, [rejectInstalls([waiter], { kind: "not-ready" })]) + + if (!state.canExternalInstall) return unchanged(state, [rejectInstalls([waiter], { kind: "external-unavailable" })]) + const plan = { mode: "external", version: state.version, url: state.url, step: "checking" } as const + + if (state.refresh) + return unchanged({ + ...meta(state), + status: "installing", + plan: { ...plan, attempt: state.refresh.attempt, checkWaiters: state.refresh.checkWaiters }, + installWaiters: [waiter], + }) + + return { + state: { + ...meta(state), + issued: attempt, + status: "installing", + plan: { ...plan, attempt, checkWaiters: [] }, + installWaiters: [waiter], + }, + effects: [{ type: "platform.check", attempt }], + } +} + +// A caller that stops waiting leaves the shared work running for everyone else. +function waiterCancelled(state: Active, waiter: number): UpdaterMachineTransition { + if (state.status === "checking" || state.status === "downloading") { + const checkWaiters = without(state.checkWaiters, waiter) + + return unchanged(checkWaiters === state.checkWaiters ? state : { ...state, checkWaiters }) + } + + if ((state.status === "ready" || state.status === "download-required") && state.refresh) { + const checkWaiters = without(state.refresh.checkWaiters, waiter) + + return unchanged(checkWaiters === state.refresh.checkWaiters ? state : withRefreshWaiters(state, checkWaiters)) + } + + if (state.status !== "installing") return unchanged(state) + const installWaiters = without(state.installWaiters, waiter) + const checks = checkWaitersOf(state) + const checkWaiters = without(checks, waiter) + + if (installWaiters === state.installWaiters && checkWaiters === checks) return unchanged(state) + + return unchanged({ + ...state, + plan: "checkWaiters" in state.plan ? { ...state.plan, checkWaiters } : state.plan, + installWaiters, + }) +} + +function settled(state: Active, event: Settled): UpdaterMachineTransition { + if (state.status === "checking") { + if (event.type === "check.succeeded") return discovered(state, event.target, state.checkWaiters) + + if (event.type === "check.failed") + return withChecks({ ...meta(state), status: "error", message: event.message }, state.checkWaiters) + } + + if (state.status === "downloading") { + if (event.type === "stage.succeeded") + return withChecks( + { ...meta(state), cached: state.version, status: "ready", version: state.version }, + state.checkWaiters, + [{ type: "persistence.set", version: state.version }], + ) + + if (event.type === "stage.failed") + return withChecks({ ...meta(state), status: "error", message: event.message }, state.checkWaiters) + } + + if (state.status === "ready" && state.refresh) return refreshSettled(state, state.refresh, event) + + if (state.status === "download-required" && state.refresh) { + if (event.type === "check.succeeded") return discovered(state, event.target, state.refresh.checkWaiters) + + if (event.type === "check.failed") + return withChecks({ ...state, refresh: undefined }, state.refresh.checkWaiters, [ + externalRefreshFailed(event.message), + ]) + } + + if (state.status === "installing" && state.plan.mode === "restart") return restartSettled(state, state.plan, event) + + if (state.status === "installing" && state.plan.mode === "external") return externalSettled(state, state.plan, event) + + return unchanged(state) +} + +function refreshSettled( + state: Extract, + refresh: StagedRefresh, + event: Settled, +): UpdaterMachineTransition { + const ready = { ...state, refresh: undefined } + + if (refresh.step === "checking" && event.type === "check.succeeded") { + if (keepsStaged(state, state.version, event.target)) return withChecks(ready, refresh.checkWaiters) + + if (event.target?.mode !== "restart") return discovered(state, event.target, refresh.checkWaiters) + const attempt = state.issued + 1 + + return { + state: { + ...state, + issued: attempt, + refresh: { step: "staging", attempt, nextVersion: event.target.version, checkWaiters: refresh.checkWaiters }, + }, + effects: stageEffects(state, attempt, event.target.version), + } + } + + if (refresh.step === "staging" && event.type === "stage.succeeded") + return withChecks({ ...ready, cached: refresh.nextVersion, version: refresh.nextVersion }, refresh.checkWaiters, [ + { type: "persistence.set", version: refresh.nextVersion }, + ]) + + if (event.type === "check.failed" || event.type === "stage.failed") + return withChecks(ready, refresh.checkWaiters, [stagedRefreshFailed(state.version, event.message)]) + + return unchanged(state) +} + +// The installation hands off only for a release it keeps or has just staged. A check that finds an external +// download instead cancels the restart, so the app never quits into a superseded staged update. +function restartSettled( + state: Extract, + plan: Extract, + event: Settled, +): UpdaterMachineTransition { + if (plan.step === "checking" && event.type === "check.succeeded") { + if (keepsStaged(state, plan.version, event.target)) return restart(state, plan.version, plan.checkWaiters) + + if (event.target?.mode === "external") { + const next = discovered(state, event.target, plan.checkWaiters) + + return { + state: next.state, + effects: [...next.effects, { type: "installs.resolve", waiters: state.installWaiters }], + } + } + + const nextVersion = event.target?.version ?? plan.version + const attempt = state.issued + 1 + + return { + state: { + ...state, + issued: attempt, + plan: { + mode: "restart", + version: plan.version, + step: "staging", + attempt, + nextVersion, + checkWaiters: plan.checkWaiters, + }, + }, + effects: stageEffects(state, attempt, nextVersion), + } + } + + // The staged release still installs when the last-minute check or download fails. + if ( + (plan.step === "checking" && event.type === "check.failed") || + (plan.step === "staging" && event.type === "stage.failed") + ) + return restart(state, plan.version, plan.checkWaiters, [stagedRefreshFailed(plan.version, event.message)]) + + if (plan.step === "staging" && event.type === "stage.succeeded") + return restart({ ...state, cached: plan.nextVersion }, plan.nextVersion, plan.checkWaiters, [ + { type: "persistence.set", version: plan.nextVersion }, + ]) + + if (plan.step === "restarting" && event.type === "restart.succeeded") + return unchanged( + { ...state, plan: { mode: "restart", version: plan.version, step: "quitting" }, installWaiters: [] }, + [{ type: "installs.resolve", waiters: state.installWaiters }], + ) + + // ApplicationLifecycle resumed the other plugins before rejecting, so the user can retry. + if (plan.step === "restarting" && event.type === "restart.failed") + return unchanged({ ...meta(state), status: "ready", version: plan.version }, [ + rejectInstalls(state.installWaiters, { kind: "error", error: event.error }), + ]) + + return unchanged(state) +} + +// The external installer opens the current download only. Once it opened, or failed to, the download stays offered: +// the app keeps running, so the user can open it again. +function externalSettled( + state: Extract, + plan: Extract, + event: Settled, +): UpdaterMachineTransition { + if (plan.step === "checking" && event.type === "check.succeeded") { + if (event.target?.mode === "external") return open(state, event.target.version, event.target.url, plan.checkWaiters) + const next = discovered(state, event.target, plan.checkWaiters) + + return { + state: next.state, + effects: [...next.effects, rejectInstalls(state.installWaiters, { kind: "external-unavailable" })], + } + } + + if (plan.step === "checking" && event.type === "check.failed") + return open(state, plan.version, plan.url, plan.checkWaiters, [externalRefreshFailed(event.message)]) + + const offered = { ...meta(state), status: "download-required" as const, version: plan.version, url: plan.url } + + if (plan.step === "opening" && event.type === "external.succeeded") + return unchanged(offered, [{ type: "installs.resolve", waiters: state.installWaiters }]) + + if (plan.step === "opening" && event.type === "external.failed") + return unchanged(offered, [rejectInstalls(state.installWaiters, { kind: "error", error: event.error })]) + + return unchanged(state) +} + +// What a fresh check found when no staged update is kept. +function discovered(state: Active, target: UpdateTarget | undefined, checkWaiters: readonly number[]) { + if (!target || (target.mode === "restart" && target.version === state.currentVersion)) + return withChecks({ ...meta(state), status: "up-to-date" }, checkWaiters, [{ type: "persistence.clear" }]) + + if (target.mode === "external") + return withChecks( + { ...meta(state), status: "download-required", version: target.version, url: target.url }, + checkWaiters, + [{ type: "persistence.clear" }], + ) + const attempt = state.issued + 1 + + return { + state: { ...meta(state), issued: attempt, status: "downloading", attempt, version: target.version, checkWaiters }, + effects: stageEffects(state, attempt, target.version), + } satisfies UpdaterMachineTransition +} + +function restart( + state: Extract, + version: string, + checkWaiters: readonly number[], + effects: readonly UpdaterMachineEffect[] = [], +): UpdaterMachineTransition { + const attempt = state.issued + 1 + + return withChecks( + { ...state, issued: attempt, plan: { mode: "restart", version, step: "restarting", attempt } }, + checkWaiters, + [...effects, { type: "platform.restart", attempt }], + ) +} + +function open( + state: Extract, + version: string, + url: string, + checkWaiters: readonly number[], + effects: readonly UpdaterMachineEffect[] = [], +): UpdaterMachineTransition { + const attempt = state.issued + 1 + + return withChecks( + { ...state, issued: attempt, plan: { mode: "external", version, url, step: "opening", attempt } }, + checkWaiters, + [...effects, { type: "platform.external", attempt, url }], + ) +} + +function keepsStaged(state: Active, staged: string, target: UpdateTarget | undefined) { + return ( + !target || (target.mode === "restart" && (target.version === staged || target.version === state.currentVersion)) + ) +} + +function stageEffects(state: Active, attempt: number, version: string): UpdaterMachineEffect[] { + const stage = { type: "platform.stage", attempt, differential: !state.cached } as const + + if (!state.cached) return [stage] + + return [ + { + type: "log", + level: "info", + message: "skipping differential download, updater cache is stale", + data: { current: state.currentVersion, staged: state.cached, version }, + }, + stage, + ] +} + +function activeAttempt(state: Active) { + if (state.status === "checking" || state.status === "downloading") return state.attempt + + if (state.status === "ready" || state.status === "download-required") return state.refresh?.attempt + + if (state.status === "installing" && state.plan.step !== "quitting") return state.plan.attempt + + return undefined +} + +function restarting(state: Active) { + return state.status === "installing" && state.plan.step === "restarting" +} + +function checkWaitersOf(state: Active): readonly number[] { + if (state.status === "checking" || state.status === "downloading") return state.checkWaiters + + if (state.status === "ready" || state.status === "download-required") return state.refresh?.checkWaiters ?? [] + + if (state.status === "installing" && "checkWaiters" in state.plan) return state.plan.checkWaiters + + return [] +} + +function withRefreshWaiters( + state: Extract, + checkWaiters: readonly number[], +): UpdaterMachineState { + if (state.status === "ready" && state.refresh) return { ...state, refresh: { ...state.refresh, checkWaiters } } + + if (state.status === "download-required" && state.refresh) + return { ...state, refresh: { ...state.refresh, checkWaiters } } + + return state +} + +function meta(state: Active): Meta { + return { + currentVersion: state.currentVersion, + canExternalInstall: state.canExternalInstall, + issued: state.issued, + cached: state.cached, + } +} + +function stagedRefreshFailed(staged: string, message: string): UpdaterMachineEffect { + return { + type: "log", + level: "warning", + message: "updater refresh failed, keeping staged update", + data: { staged, message }, + } +} + +function externalRefreshFailed(message: string): UpdaterMachineEffect { + return { + type: "log", + level: "warning", + message: "external updater refresh failed, keeping download available", + data: { message }, + } +} + +function rejectInstalls(waiters: readonly number[], failure: UpdaterFailure): UpdaterMachineEffect { + return { type: "installs.reject", waiters, failure } +} + +function without(waiters: readonly number[], waiter: number) { + return waiters.includes(waiter) ? waiters.filter((item) => item !== waiter) : waiters +} + +// Answers `waiters` with what the next state shows, after the transition's other effects. +function withChecks( + state: UpdaterMachineState, + waiters: readonly number[], + effects: readonly UpdaterMachineEffect[] = [], +): UpdaterMachineTransition { + if (waiters.length === 0) return { state, effects } + + return { state, effects: [...effects, { type: "checks.resolve", waiters, state: toUpdaterState(state) }] } +} + +function unchanged( + state: UpdaterMachineState, + effects: readonly UpdaterMachineEffect[] = [], +): UpdaterMachineTransition { + return { state, effects } +} diff --git a/packages/gui-plugins/src/updater/main.ts b/packages/gui-plugins/src/updater/main.ts index ec47ce9213b..80434662796 100644 --- a/packages/gui-plugins/src/updater/main.ts +++ b/packages/gui-plugins/src/updater/main.ts @@ -100,7 +100,11 @@ const setup: Plugin.MainSetup = async (ctx) => { }), ) - if (response.response === 0) yield* updater.install + // A failed install returns the updater to ready, so the user can retry from the menu. + if (response.response === 0) + yield* updater.install.pipe( + Effect.catch((error) => Effect.logWarning("update install failed", { message: error.message })), + ) }) ctx.add(