import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import type { DesktopUpdateState } from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as PlatformError from "effect/PlatformError";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts";
import * as DesktopConfig from "../app/DesktopConfig.ts";
import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
import * as ElectronUpdater from "../electron/ElectronUpdater.ts";
import * as ElectronWindow from "../electron/ElectronWindow.ts";
import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
import * as DesktopState from "../app/DesktopState.ts";
import * as DesktopUpdatePolicy from "./DesktopUpdatePolicy.ts";
import * as DesktopUpdates from "./DesktopUpdates.ts";
export const flushCallbacks = Effect.yieldNow;
export interface UpdatesHarnessOptions {
readonly checkForUpdates?: Effect.Effect<
void,
ElectronUpdater.ElectronUpdaterCheckForUpdatesError
>;
readonly beforeSetUpdateChannel?: Effect.Effect<void>;
readonly setUpdateChannelError?: DesktopAppSettings.DesktopSettingsWriteError;
readonly setDisableDifferentialDownload?: Effect.Effect<void>;
readonly downloadUpdate?: Effect.Effect<void>;
readonly quitAndInstall?: Effect.Effect<void, ElectronUpdater.ElectronUpdaterQuitAndInstallError>;
readonly stopBackend?: Effect.Effect<void>;
readonly startBackend?: Effect.Effect<void>;
readonly backendDesiredRunning?: boolean;
readonly backendInstances?: ReadonlyArray<DesktopBackendPool.DesktopBackendInstance>;
readonly env?: Record<string, string | undefined>;
readonly platform?: NodeJS.Platform;
readonly packageType?: string | undefined;
readonly installRecord?: string | undefined;
readonly policy?: DesktopUpdatePolicy.UpdatePolicy;
readonly appVersion?: string;
/** Starts from in-memory settings with this track saved, as after a restart. */
readonly savedChannel?: DesktopAppSettings.DesktopSettings["updateChannel"];
/** Adds a WSL backend beside the primary, as on a Windows host with WSL enabled. */
readonly wslBackend?: boolean;
}
export function makeHarness(options: UpdatesHarnessOptions = {}) {
let checkCount = 0;
let quitAndInstallCount = 0;
let downloadCount = 0;
let allowDowngrade = false;
const checkAllowedDowngrade: boolean[] = [];
let fullChangelog = false;
const feedUrls: ElectronUpdater.ElectronUpdaterFeedUrl[] = [];
const listeners = new Map<string, Set<(...args: readonly unknown[]) => void>>();
const sentStates: DesktopUpdateState[] = [];
const installSteps: string[] = [];
const addListener = (eventName: string, listener: (...args: readonly unknown[]) => void) => {
const eventListeners = listeners.get(eventName) ?? new Set();
eventListeners.add(listener);
listeners.set(eventName, eventListeners);
};
const removeListener = (eventName: string, listener: (...args: readonly unknown[]) => void) => {
const eventListeners = listeners.get(eventName);
if (!eventListeners) {
return;
}
eventListeners.delete(listener);
if (eventListeners.size === 0) {
listeners.delete(eventName);
}
};
const layerUpdater = Layer.succeed(ElectronUpdater.ElectronUpdater, {
setFeedURL: (options) =>
Effect.sync(() => {
feedUrls.push(options);
}),
setAutoDownload: () => Effect.void,
setAutoInstallOnAppQuit: () => Effect.void,
setChannel: () => Effect.void,
setAllowPrerelease: () => Effect.void,
allowDowngrade: Effect.sync(() => allowDowngrade),
setAllowDowngrade: (value) =>
Effect.sync(() => {
allowDowngrade = value;
}),
setFullChangelog: (value) =>
Effect.sync(() => {
fullChangelog = value;
}),
setDisableDifferentialDownload: () => options.setDisableDifferentialDownload ?? Effect.void,
checkForUpdates: Effect.sync(() => {
checkCount += 1;
checkAllowedDowngrade.push(allowDowngrade);
}).pipe(Effect.andThen(options.checkForUpdates ?? Effect.void)),
downloadUpdate: Effect.sync(() => {
downloadCount += 1;
}).pipe(Effect.andThen(options.downloadUpdate ?? Effect.void)),
quitAndInstall: () =>
Effect.sync(() => {
quitAndInstallCount += 1;
installSteps.push("quitAndInstall");
}).pipe(Effect.andThen(options.quitAndInstall ?? Effect.void)),
on: (eventName, listener) =>
Effect.acquireRelease(
Effect.sync(() => {
addListener(eventName, listener as unknown as (...args: readonly unknown[]) => void);
}),
() =>
Effect.sync(() => {
removeListener(eventName, listener as unknown as (...args: readonly unknown[]) => void);
}),
).pipe(Effect.asVoid),
} satisfies ElectronUpdater.ElectronUpdater["Service"]);
const layerWindow = Layer.succeed(ElectronWindow.ElectronWindow, {
create: () => Effect.die("unexpected BrowserWindow creation"),
main: Effect.succeedNone,
currentMainOrFirst: Effect.succeedNone,
focusedMainOrFirst: Effect.succeedNone,
setMain: () => Effect.void,
clearMain: () => Effect.void,
prepareReveal: () => Effect.succeed(false),
reveal: () => Effect.void,
sendAll: (_channel, state) =>
Effect.sync(() => {
sentStates.push(state as DesktopUpdateState);
}),
destroyAll: Effect.sync(() => {
installSteps.push("destroyAll");
}),
syncAllAppearance: () => Effect.void,
} satisfies ElectronWindow.ElectronWindow["Service"]);
let backendDesiredRunning = options.backendDesiredRunning ?? true;
const stubBackendInstance: DesktopBackendPool.DesktopBackendInstance = {
id: DesktopBackendPool.PRIMARY_INSTANCE_ID,
label: Effect.succeed("Windows"),
start: Effect.sync(() => {
backendDesiredRunning = true;
installSteps.push("startBackend");
}).pipe(Effect.andThen(options.startBackend ?? Effect.void)),
stop: () =>
Effect.sync(() => {
backendDesiredRunning = false;
}).pipe(Effect.andThen(options.stopBackend ?? Effect.void)),
currentConfig: Effect.succeedNone,
snapshot: Effect.sync(() => ({
desiredRunning: backendDesiredRunning,
ready: false,
activePid: Option.none(),
restartAttempt: 0,
restartScheduled: false,
})),
waitForReady: () => Effect.succeed(true),
};
const layerBackend = DesktopBackendPool.layerTest(
options.backendInstances ??
(options.wslBackend
? [
stubBackendInstance,
{
...stubBackendInstance,
id: DesktopBackendPool.BackendInstanceId("wsl:Ubuntu"),
label: Effect.succeed("Ubuntu"),
},
]
: [stubBackendInstance]),
);
const layerEnvironment = DesktopEnvironment.layer({
dirname: "/repo/apps/desktop/src",
homeDirectory: `/tmp/t3-desktop-updates-home-${process.pid}`,
platform: options.platform ?? "darwin",
processArch: "x64",
appVersion: options.appVersion ?? "1.2.3",
appPath: "/repo",
isPackaged: true,
resourcesPath: "/missing/resources",
runningUnderArm64Translation: false,
}).pipe(
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
DesktopConfig.layerTest({
T3CODE_HOME: `/tmp/t3-desktop-updates-test-${process.pid}`,
T3CODE_DESKTOP_MOCK_UPDATES: "true",
T3CODE_DESKTOP_MOCK_UPDATE_SERVER_PORT: "4141",
...options.env,
}),
),
),
);
let testSettings: DesktopAppSettings.DesktopSettings = {
...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
...(options.savedChannel === undefined
? {}
: { updateChannel: options.savedChannel, updateChannelConfiguredByUser: true }),
};
const setUpdateChannelError = options.setUpdateChannelError;
const layerSettings =
setUpdateChannelError || options.beforeSetUpdateChannel || options.savedChannel
? Layer.succeed(DesktopAppSettings.DesktopAppSettings, {
get: Effect.sync(() => testSettings),
load: Effect.sync(() => testSettings),
setMainWindowBounds: () => Effect.die("unexpected main window bounds update"),
setServerExposureMode: () => Effect.die("unexpected server exposure update"),
setTailscaleServe: () => Effect.die("unexpected Tailscale Serve update"),
setUpdateChannel: (channel) =>
setUpdateChannelError
? Effect.fail(setUpdateChannelError)
: (options.beforeSetUpdateChannel ?? Effect.void).pipe(
Effect.andThen(
Effect.sync(() => {
const changed = testSettings.updateChannel !== channel;
testSettings = {
...testSettings,
updateChannel: channel,
updateChannelConfiguredByUser: true,
};
return { settings: testSettings, changed };
}),
),
),
setWslBackendEnabled: () => Effect.die("unexpected WSL backend toggle"),
setWslDistro: () => Effect.die("unexpected WSL distro change"),
setLocalEnvironmentEnabled: () => Effect.die("unexpected local environment toggle"),
setWslOnly: () => Effect.die("unexpected WSL-only toggle"),
applyWslWindowsFallback: Effect.die("unexpected WSL Windows fallback"),
applyWslWindowsFallbackInMemory: Effect.die("unexpected WSL Windows fallback"),
} satisfies DesktopAppSettings.DesktopAppSettings["Service"])
: DesktopAppSettings.layer;
const updateRestartMarkers = new Set<string>();
const installRecords = new Map<string, string>();
let previousInstallRecord = options.installRecord;
const isInstallRecord = (path: string) =>
path.endsWith(DesktopUpdates.DESKTOP_UPDATE_INSTALL_RECORD_FILE);
const layerFileSystem = FileSystem.layerNoop({
readFileString: (path) => {
const installRecord = isInstallRecord(path)
? (installRecords.get(path) ?? previousInstallRecord)
: undefined;
if (installRecord !== undefined) return Effect.succeed(installRecord);
return path === "/missing/resources/package-type" && options.packageType !== undefined
? Effect.succeed(options.packageType)
: Effect.fail(
PlatformError.systemError({
module: "FileSystem",
method: "readFileString",
_tag: "NotFound",
pathOrDescriptor: path,
}),
);
},
makeDirectory: () => Effect.void,
writeFileString: (path, data) =>
Effect.sync(() => {
if (isInstallRecord(path)) installRecords.set(path, data);
else updateRestartMarkers.add(path);
}),
remove: (path) =>
Effect.sync(() => {
updateRestartMarkers.delete(path);
installRecords.delete(path);
if (isInstallRecord(path)) previousInstallRecord = undefined;
}),
});
const layer = DesktopUpdates.layer.pipe(
Layer.provide(layerFileSystem),
Layer.provide(DesktopUpdatePolicy.layerTest(options.policy)),
Layer.provideMerge(layerUpdater),
Layer.provideMerge(layerWindow),
Layer.provideMerge(layerBackend),
Layer.provideMerge(DesktopState.layer),
Layer.provideMerge(layerSettings),
Layer.provideMerge(
DesktopConfig.layerTest({
T3CODE_HOME: `/tmp/t3-desktop-updates-test-${process.pid}`,
T3CODE_DESKTOP_MOCK_UPDATES: "true",
T3CODE_DESKTOP_MOCK_UPDATE_SERVER_PORT: "4141",
...options.env,
}),
),
Layer.provideMerge(layerEnvironment),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
return {
layer,
checkCount: () => checkCount,
quitAndInstalls: () => quitAndInstallCount,
installSteps,
updateRestartMarkers,
installRecords,
previousInstallRecord: () => previousInstallRecord,
downloadCount: () => downloadCount,
feedUrls: (): ElectronUpdater.ElectronUpdaterFeedUrl[] => feedUrls,
fullChangelog: () => fullChangelog,
/** Whether each feed check could offer an older release, and the flag now. */
checkAllowedDowngrade,
allowDowngrade: () => allowDowngrade,
listenerCount: () =>
Array.from(listeners.values()).reduce(
(total, eventListeners) => total + eventListeners.size,
0,
),
sentStates,
emit: (eventName: string, payload?: unknown) => {
for (const listener of listeners.get(eventName) ?? []) {
listener(payload);
}
},
};
}