Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Predicate from "effect/Predicate";
import { assert, describe, it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as TestClock from "effect/testing/TestClock";
import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
import * as DesktopUpdates from "./DesktopUpdates.ts";
import { flushCallbacks, makeHarness } from "./test-support/UpdatesHarness.ts";
describe("DesktopUpdates", () => {
it.effect("configures the updater and runs startup checks on the test clock", () => {
const harness = makeHarness();
return Effect.gen(function* () {
yield* Effect.scoped(
Effect.gen(function* () {
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
const state = yield* updates.getState;
assert.equal(state.enabled, true);
assert.equal(state.status, "idle");
assert.deepEqual(harness.feedUrls(), [
{ provider: "generic", url: "http://localhost:4141" },
]);
assert.equal(harness.listenerCount(), 6);
assert.equal(harness.checkCount(), 0);
yield* TestClock.adjust(Duration.millis(15_000));
assert.equal(harness.checkCount(), 1);
}),
);
assert.equal(harness.listenerCount(), 0);
}).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
});
it.effect("checks for newer releases after an update has been downloaded", () => {
const harness = makeHarness();
return Effect.scoped(
Effect.gen(function* () {
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
harness.emit("update-available", {
version: "1.2.4",
releaseNotes: "## What's changed\n- fix: queued update",
});
yield* flushCallbacks;
harness.emit("update-downloaded", { version: "1.2.4" });
yield* flushCallbacks;
const result = yield* updates.check("poll");
assert.isTrue(result.checked);
harness.emit("update-available", { version: "1.2.4" });
yield* flushCallbacks;
const unchangedState = yield* updates.getState;
assert.equal(unchangedState.status, "downloaded");
assert.equal(unchangedState.downloadedVersion, "1.2.4");
assert.deepEqual(unchangedState.releaseNotes, [
{ version: "1.2.4", items: ["fix: queued update"] },
]);
const nextResult = yield* updates.check("poll");
assert.isTrue(nextResult.checked);
harness.emit("update-available", { version: "1.2.5" });
yield* flushCallbacks;
const state = yield* updates.getState;
assert.equal(state.status, "available");
assert.equal(state.availableVersion, "1.2.5");
assert.isNull(state.downloadedVersion);
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
});
it.effect("does not persist an unchanged update channel as a user preference", () => {
const harness = makeHarness();
return Effect.scoped(
Effect.gen(function* () {
const settings = yield* DesktopAppSettings.DesktopAppSettings;
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
const state = yield* updates.setChannel("latest");
const persistedSettings = yield* settings.get;
assert.equal(state.channel, "latest");
assert.equal(persistedSettings.updateChannel, "latest");
assert.equal(persistedSettings.updateChannelConfiguredByUser, false);
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
});
it.effect("fails channel changes with a typed error while a check is in progress", () =>
Effect.gen(function* () {
const checkStarted = yield* Deferred.make<void>();
const releaseCheck = yield* Deferred.make<void>();
const harness = makeHarness({
checkForUpdates: Deferred.succeed(checkStarted, undefined).pipe(
Effect.andThen(Deferred.await(releaseCheck)),
),
});
yield* Effect.scoped(
Effect.gen(function* () {
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
const checkFiber = yield* updates.check("manual").pipe(Effect.forkScoped);
yield* Deferred.await(checkStarted);
const exit = yield* Effect.exit(updates.setChannel("latest"));
assert.equal(exit._tag, "Failure");
if (Predicate.isTagged(exit, "Failure")) {
const error = Cause.squash(exit.cause);
assert.instanceOf(error, DesktopUpdates.DesktopUpdateActionInProgressError);
assert.equal(error.action, "check");
assert.equal(error.requestedChannel, "latest");
}
yield* Deferred.succeed(releaseCheck, undefined);
yield* Fiber.join(checkFiber);
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
}),
);
});