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 NodeEvents from "node:events";
import { assert, describe, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import { DesktopTraceShutdown } from "./DesktopObservability.ts";
import * as Layer from "effect/Layer";
import * as Ref from "effect/Ref";
import type * as Electron from "electron";
import * as ElectronApp from "../electron/ElectronApp.ts";
import * as ElectronTheme from "../electron/ElectronTheme.ts";
import * as ElectronWindow from "../electron/ElectronWindow.ts";
import * as DesktopEnvironment from "./DesktopEnvironment.ts";
import * as DesktopLifecycle from "./DesktopLifecycle.ts";
import * as DesktopShutdown from "./DesktopShutdown.ts";
import * as DesktopState from "./DesktopState.ts";
import * as DesktopWindow from "../window/DesktopWindow.ts";
function makeElectronAppLayer(
appListeners: NodeEvents.EventEmitter,
quit: Effect.Effect<void> = Effect.void,
) {
const registerListener = (
eventName: string,
listener: Parameters<NodeEvents.EventEmitter["on"]>[1],
) =>
Effect.acquireRelease(
Effect.sync(() => {
appListeners.on(eventName, listener);
}),
() =>
Effect.sync(() => {
appListeners.removeListener(eventName, listener);
}),
).pipe(Effect.asVoid);
return Layer.succeed(ElectronApp.ElectronApp, {
metadata: Effect.die("unexpected metadata read"),
name: Effect.succeed("T3 Code"),
systemLocale: Effect.succeed("en-US"),
whenReady: Effect.void,
quit,
requestSingleInstanceLock: Effect.succeed(true),
exit: () => Effect.void,
relaunch: () => Effect.void,
setPath: () => Effect.void,
setName: () => Effect.void,
setAboutPanelOptions: () => Effect.void,
setAppUserModelId: () => Effect.void,
getAppMetrics: Effect.succeed([]),
isDefaultProtocolClient: () => Effect.succeed(false),
setAsDefaultProtocolClient: () => Effect.succeed(true),
setDesktopName: () => Effect.void,
setDockIcon: () => Effect.void,
appendCommandLineSwitch: () => Effect.void,
removeCommandLineSwitch: () => Effect.void,
onBeforeQuitForUpdate: (listener) => registerListener("before-quit-for-update", listener),
on: (eventName, listener) => registerListener(eventName, listener),
} satisfies ElectronApp.ElectronApp["Service"]);
}
const electronThemeLayer = Layer.succeed(ElectronTheme.ElectronTheme, {
shouldUseDarkColors: Effect.succeed(false),
setSource: () => Effect.void,
onUpdated: () => Effect.void,
});
function makeElectronWindowLayer(destroyAll: Effect.Effect<void> = Effect.void) {
return Layer.succeed(ElectronWindow.ElectronWindow, {
create: () => Effect.die("unexpected window creation"),
main: Effect.die("unexpected main window read"),
currentMainOrFirst: Effect.die("unexpected current window read"),
focusedMainOrFirst: Effect.die("unexpected focused window read"),
setMain: () => Effect.void,
clearMain: () => Effect.void,
reveal: () => Effect.void,
sendAll: () => Effect.void,
destroyAll,
syncAllAppearance: () => Effect.void,
});
}
function makeDesktopWindowLayer(
input: {
readonly activate?: Effect.Effect<void>;
readonly flushMainWindowBounds?: Effect.Effect<void>;
} = {},
) {
return Layer.succeed(DesktopWindow.DesktopWindow, {
createMain: Effect.die("unexpected window creation"),
ensureMain: Effect.die("unexpected window creation"),
revealOrCreateMain: Effect.die("unexpected window creation"),
activate: input.activate ?? Effect.void,
createMainIfBackendReady: Effect.void,
showConnectingSplash: Effect.void,
handleBackendReady: () => Effect.void,
handleBackendNotReady: Effect.void,
flushMainWindowBounds: input.flushMainWindowBounds ?? Effect.void,
dispatchMenuAction: () => Effect.void,
zoomMain: () => Effect.void,
syncAppearance: Effect.void,
});
}
describe("DesktopLifecycle", () => {
for (const platform of ["darwin", "win32", "linux"] satisfies ReadonlyArray<NodeJS.Platform>) {
it.effect(`lets the updater's quit event proceed on ${platform}`, () => {
const appListeners = new NodeEvents.EventEmitter();
const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
platform,
isDevelopment: false,
} as DesktopEnvironment.DesktopEnvironment["Service"]);
const layer = DesktopLifecycle.layer.pipe(
Layer.provideMerge(makeElectronAppLayer(appListeners)),
Layer.provideMerge(electronThemeLayer),
Layer.provideMerge(makeElectronWindowLayer()),
Layer.provideMerge(makeDesktopWindowLayer()),
Layer.provideMerge(environmentLayer),
Layer.provideMerge(DesktopShutdown.layer),
Layer.provideMerge(DesktopState.layer),
);
return Effect.scoped(
Effect.gen(function* () {
const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
yield* lifecycle.register;
appListeners.emit("before-quit-for-update");
let prevented = false;
const event = {
preventDefault: () => {
prevented = true;
},
} as Electron.Event;
appListeners.emit("before-quit", event);
assert.isFalse(
prevented,
"cancelling this event prevents the updater from completing its relaunch",
);
const state = yield* DesktopState.DesktopState;
assert.isTrue(yield* Ref.get(state.quitting));
}),
).pipe(Effect.provide(layer));
});
}
it.effect("keeps windows alive until shutdown acknowledgement", () =>
Effect.gen(function* () {
const appListeners = new NodeEvents.EventEmitter();
const shutdownRequested = yield* Deferred.make<void>();
const allowShutdown = yield* Deferred.make<void>();
const quitRequested = yield* Deferred.make<void>();
const events: string[] = [];
const quit = Effect.sync(() => {
events.push("quit");
}).pipe(Effect.andThen(Deferred.succeed(quitRequested, undefined)), Effect.asVoid);
const destroyAll = Effect.sync(() => {
events.push("destroy");
});
const flushMainWindowBounds = Effect.sync(() => {
events.push("flush");
});
const desktopShutdownLayer = Layer.succeed(DesktopShutdown.DesktopShutdown, {
request: Effect.sync(() => {
events.push("request");
}).pipe(Effect.andThen(Deferred.succeed(shutdownRequested, undefined)), Effect.asVoid),
awaitRequest: Deferred.await(shutdownRequested),
markComplete: Deferred.succeed(allowShutdown, undefined).pipe(Effect.asVoid),
awaitComplete: Deferred.await(allowShutdown),
isComplete: Deferred.isDone(allowShutdown),
});
const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
platform: "darwin",
isDevelopment: false,
} as DesktopEnvironment.DesktopEnvironment["Service"]);
const layer = DesktopLifecycle.layer.pipe(
Layer.provideMerge(makeElectronAppLayer(appListeners, quit)),
Layer.provideMerge(electronThemeLayer),
Layer.provideMerge(makeElectronWindowLayer(destroyAll)),
Layer.provideMerge(makeDesktopWindowLayer({ flushMainWindowBounds })),
Layer.provideMerge(environmentLayer),
Layer.provideMerge(desktopShutdownLayer),
Layer.provideMerge(DesktopState.layer),
);
yield* Effect.scoped(
Effect.gen(function* () {
const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
yield* lifecycle.register;
const event = { preventDefault: () => undefined } as Electron.Event;
appListeners.emit("before-quit", event);
yield* Deferred.await(shutdownRequested);
const eventsBeforeCleanup = [...events];
yield* Deferred.succeed(allowShutdown, undefined);
yield* Deferred.await(quitRequested);
assert.deepEqual(eventsBeforeCleanup, ["flush", "request"]);
assert.deepEqual(events, ["flush", "request", "destroy", "quit"]);
}),
).pipe(Effect.provide(layer));
}),
);
it.effect("allows native quit after shutdown setup fails", () =>
Effect.gen(function* () {
const appListeners = new NodeEvents.EventEmitter();
const quitRequested = yield* Deferred.make<void>();
const quit = Deferred.succeed(quitRequested, undefined).pipe(Effect.asVoid);
const layer = DesktopLifecycle.layer.pipe(
Layer.provideMerge(makeElectronAppLayer(appListeners, quit)),
Layer.provideMerge(electronThemeLayer),
Layer.provideMerge(makeElectronWindowLayer()),
Layer.provideMerge(
makeDesktopWindowLayer({
flushMainWindowBounds: Effect.die("bounds write failed"),
}),
),
Layer.provideMerge(
Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
platform: "darwin",
isDevelopment: false,
} as DesktopEnvironment.DesktopEnvironment["Service"]),
),
Layer.provideMerge(DesktopShutdown.layer),
Layer.provideMerge(DesktopState.layer),
);
yield* Effect.scoped(
Effect.gen(function* () {
const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
yield* lifecycle.register;
let prevented = false;
appListeners.emit("before-quit", {
preventDefault: () => {
prevented = true;
},
});
yield* Deferred.await(quitRequested);
assert.isTrue(prevented);
let retryPrevented = false;
appListeners.emit("before-quit", {
preventDefault: () => {
retryPrevented = true;
},
});
assert.isFalse(retryPrevented);
}),
).pipe(Effect.provide(layer));
}),
);
for (const destroyFails of [false, true]) {
it.effect(
`completes nested app shutdown before native quit (destroyFails=${destroyFails})`,
() =>
Effect.gen(function* () {
const appListeners = new NodeEvents.EventEmitter();
const registered = yield* Deferred.make<void>();
const boundsEntered = yield* Deferred.make<void>();
const allowBounds = yield* Deferred.make<void>();
const stopEntered = yield* Deferred.make<void>();
const allowStop = yield* Deferred.make<void>();
const closeEntered = yield* Deferred.make<void>();
const allowClose = yield* Deferred.make<void>();
const nativeQuit = yield* Deferred.make<void>();
const events: string[] = [];
const quit = Effect.sync(() => {
events.push("native-quit");
}).pipe(Effect.andThen(Deferred.succeed(nativeQuit, undefined)), Effect.asVoid);
const layer = Layer.mergeAll(
DesktopLifecycle.layer,
makeElectronAppLayer(appListeners, quit),
electronThemeLayer,
makeElectronWindowLayer(
Effect.sync(() => {
events.push("destroy");
if (destroyFails) throw new Error("invalid guest");
}),
),
makeDesktopWindowLayer({
flushMainWindowBounds: Effect.gen(function* () {
events.push("bounds");
yield* Deferred.succeed(boundsEntered, undefined);
yield* Deferred.await(allowBounds);
}),
}),
Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
platform: "linux",
isDevelopment: false,
} as DesktopEnvironment.DesktopEnvironment["Service"]),
DesktopShutdown.layer,
DesktopState.layer,
Layer.succeed(DesktopTraceShutdown, {
close: Effect.gen(function* () {
events.push("trace-close");
assert.isFalse(appListeners.listenerCount("before-quit") > 0);
yield* Deferred.succeed(closeEntered, undefined);
yield* Deferred.await(allowClose);
events.push("trace-ack");
}),
}),
Layer.effectDiscard(Effect.addFinalizer(() => Deferred.await(nativeQuit))),
);
const main = yield* Effect.scoped(
Effect.gen(function* () {
const shutdown = yield* DesktopShutdown.DesktopShutdown;
yield* Effect.addFinalizer(() =>
Effect.gen(function* () {
events.push("backend-stop");
yield* Deferred.succeed(stopEntered, undefined);
yield* Deferred.await(allowStop);
}),
);
const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
yield* lifecycle.register;
yield* Deferred.succeed(registered, undefined);
yield* shutdown.awaitRequest;
}),
).pipe(
Effect.withSpan("desktop.app"),
Effect.ensuring(DesktopShutdown.acknowledgeShutdown),
Effect.provide(layer),
Effect.forkChild,
);
yield* Deferred.await(registered);
let prevented = false;
appListeners.emit("before-quit", {
preventDefault: () => {
prevented = true;
},
});
yield* Deferred.await(boundsEntered);
assert.isTrue(prevented);
assert.isFalse(yield* Deferred.isDone(stopEntered));
yield* Deferred.succeed(allowBounds, undefined);
yield* Deferred.await(stopEntered);
const beforeBackendAcknowledgement = [...events];
assert.isFalse(yield* Deferred.isDone(closeEntered));
yield* Deferred.succeed(allowStop, undefined);
yield* Deferred.await(closeEntered);
const beforeTraceAcknowledgement = [...events];
assert.isFalse(yield* Deferred.isDone(nativeQuit));
yield* Deferred.succeed(allowClose, undefined);
yield* Deferred.await(nativeQuit);
yield* Fiber.join(main);
assert.deepEqual(beforeBackendAcknowledgement, ["bounds", "backend-stop"]);
assert.deepEqual(beforeTraceAcknowledgement, ["bounds", "backend-stop", "trace-close"]);
assert.deepEqual(events, [
"bounds",
"backend-stop",
"trace-close",
"trace-ack",
"destroy",
"native-quit",
]);
}),
);
}
it.effect("ignores app activation while quitting", () =>
Effect.gen(function* () {
const appListeners = new NodeEvents.EventEmitter();
let activationCount = 0;
const activate = Effect.sync(() => {
activationCount += 1;
});
const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
platform: "darwin",
isDevelopment: false,
} as DesktopEnvironment.DesktopEnvironment["Service"]);
const layer = DesktopLifecycle.layer.pipe(
Layer.provideMerge(makeElectronAppLayer(appListeners)),
Layer.provideMerge(electronThemeLayer),
Layer.provideMerge(makeElectronWindowLayer()),
Layer.provideMerge(makeDesktopWindowLayer({ activate })),
Layer.provideMerge(environmentLayer),
Layer.provideMerge(DesktopShutdown.layer),
Layer.provideMerge(DesktopState.layer),
);
yield* Effect.scoped(
Effect.gen(function* () {
const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
const state = yield* DesktopState.DesktopState;
yield* lifecycle.register;
yield* Ref.set(state.quitting, true);
appListeners.emit("activate");
assert.equal(activationCount, 0);
}),
).pipe(Effect.provide(layer));
}),
);
});