Skip to content

Commit de22df2

Browse files
authored
Merge branch 'main' into fix/claude-agent-usage-guardrails
2 parents 4f1c602 + f708f63 commit de22df2

120 files changed

Lines changed: 7424 additions & 2406 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.
Lines changed: 187 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
import { assert, describe, it } from "@effect/vitest";
2+
import * as Deferred from "effect/Deferred";
23
import * as Effect from "effect/Effect";
34
import * as Layer from "effect/Layer";
45
import * as Ref from "effect/Ref";
@@ -7,91 +8,110 @@ import type * as Electron from "electron";
78

89
import * as ElectronApp from "../electron/ElectronApp.ts";
910
import * as ElectronTheme from "../electron/ElectronTheme.ts";
11+
import * as ElectronWindow from "../electron/ElectronWindow.ts";
1012
import * as DesktopEnvironment from "./DesktopEnvironment.ts";
1113
import * as DesktopLifecycle from "./DesktopLifecycle.ts";
1214
import * as DesktopShutdown from "./DesktopShutdown.ts";
1315
import * as DesktopState from "./DesktopState.ts";
1416
import * as DesktopWindow from "../window/DesktopWindow.ts";
1517

18+
function makeElectronAppLayer(
19+
appListeners: Map<string, (...args: readonly unknown[]) => void>,
20+
quit: Effect.Effect<void> = Effect.void,
21+
) {
22+
const registerListener = (eventName: string, listener: (...args: readonly unknown[]) => void) =>
23+
Effect.acquireRelease(
24+
Effect.sync(() => {
25+
appListeners.set(eventName, listener);
26+
}),
27+
() =>
28+
Effect.sync(() => {
29+
appListeners.delete(eventName);
30+
}),
31+
).pipe(Effect.asVoid);
32+
33+
return Layer.succeed(ElectronApp.ElectronApp, {
34+
metadata: Effect.die("unexpected metadata read"),
35+
name: Effect.succeed("T3 Code"),
36+
systemLocale: Effect.succeed("en-US"),
37+
whenReady: Effect.void,
38+
quit,
39+
exit: () => Effect.void,
40+
relaunch: () => Effect.void,
41+
setPath: () => Effect.void,
42+
setName: () => Effect.void,
43+
setAboutPanelOptions: () => Effect.void,
44+
setAppUserModelId: () => Effect.void,
45+
getAppMetrics: Effect.succeed([]),
46+
isDefaultProtocolClient: () => Effect.succeed(false),
47+
setAsDefaultProtocolClient: () => Effect.succeed(true),
48+
setDesktopName: () => Effect.void,
49+
setDockIcon: () => Effect.void,
50+
appendCommandLineSwitch: () => Effect.void,
51+
removeCommandLineSwitch: () => Effect.void,
52+
onBeforeQuitForUpdate: (listener) => registerListener("before-quit-for-update", listener),
53+
on: (eventName, listener) =>
54+
registerListener(eventName, listener as unknown as (...args: readonly unknown[]) => void),
55+
} satisfies ElectronApp.ElectronApp["Service"]);
56+
}
57+
58+
const electronThemeLayer = Layer.succeed(ElectronTheme.ElectronTheme, {
59+
shouldUseDarkColors: Effect.succeed(false),
60+
setSource: () => Effect.void,
61+
onUpdated: () => Effect.void,
62+
});
63+
64+
function makeElectronWindowLayer(destroyAll: Effect.Effect<void> = Effect.void) {
65+
return Layer.succeed(ElectronWindow.ElectronWindow, {
66+
create: () => Effect.die("unexpected window creation"),
67+
main: Effect.die("unexpected main window read"),
68+
currentMainOrFirst: Effect.die("unexpected current window read"),
69+
focusedMainOrFirst: Effect.die("unexpected focused window read"),
70+
setMain: () => Effect.void,
71+
clearMain: () => Effect.void,
72+
reveal: () => Effect.void,
73+
sendAll: () => Effect.void,
74+
destroyAll,
75+
syncAllAppearance: () => Effect.void,
76+
});
77+
}
78+
79+
function makeDesktopWindowLayer(
80+
input: {
81+
readonly activate?: Effect.Effect<void>;
82+
readonly flushMainWindowBounds?: Effect.Effect<void>;
83+
} = {},
84+
) {
85+
return Layer.succeed(DesktopWindow.DesktopWindow, {
86+
createMain: Effect.die("unexpected window creation"),
87+
ensureMain: Effect.die("unexpected window creation"),
88+
revealOrCreateMain: Effect.die("unexpected window creation"),
89+
activate: input.activate ?? Effect.void,
90+
createMainIfBackendReady: Effect.void,
91+
showConnectingSplash: Effect.void,
92+
handleBackendReady: () => Effect.void,
93+
handleBackendNotReady: Effect.void,
94+
flushMainWindowBounds: input.flushMainWindowBounds ?? Effect.void,
95+
dispatchMenuAction: () => Effect.void,
96+
zoomMain: () => Effect.void,
97+
syncAppearance: Effect.void,
98+
});
99+
}
100+
16101
describe("DesktopLifecycle", () => {
17102
for (const platform of ["darwin", "win32", "linux"] satisfies ReadonlyArray<NodeJS.Platform>) {
18103
it.effect(`lets the updater's quit event proceed on ${platform}`, () => {
19104
const appListeners = new Map<string, (...args: readonly unknown[]) => void>();
20-
21-
const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, {
22-
metadata: Effect.die("unexpected metadata read"),
23-
name: Effect.succeed("T3 Code"),
24-
systemLocale: Effect.succeed("en-US"),
25-
whenReady: Effect.void,
26-
quit: Effect.void,
27-
exit: () => Effect.void,
28-
relaunch: () => Effect.void,
29-
setPath: () => Effect.void,
30-
setName: () => Effect.void,
31-
setAboutPanelOptions: () => Effect.void,
32-
setAppUserModelId: () => Effect.void,
33-
getAppMetrics: Effect.succeed([]),
34-
isDefaultProtocolClient: () => Effect.succeed(false),
35-
setAsDefaultProtocolClient: () => Effect.succeed(true),
36-
setDesktopName: () => Effect.void,
37-
setDockIcon: () => Effect.void,
38-
appendCommandLineSwitch: () => Effect.void,
39-
removeCommandLineSwitch: () => Effect.void,
40-
onBeforeQuitForUpdate: (listener) =>
41-
Effect.acquireRelease(
42-
Effect.sync(() => {
43-
appListeners.set("before-quit-for-update", listener);
44-
}),
45-
() =>
46-
Effect.sync(() => {
47-
appListeners.delete("before-quit-for-update");
48-
}),
49-
).pipe(Effect.asVoid),
50-
on: (eventName, listener) =>
51-
Effect.acquireRelease(
52-
Effect.sync(() => {
53-
appListeners.set(
54-
eventName,
55-
listener as unknown as (...args: readonly unknown[]) => void,
56-
);
57-
}),
58-
() =>
59-
Effect.sync(() => {
60-
appListeners.delete(eventName);
61-
}),
62-
).pipe(Effect.asVoid),
63-
} satisfies ElectronApp.ElectronApp["Service"]);
64-
65-
const electronThemeLayer = Layer.succeed(ElectronTheme.ElectronTheme, {
66-
shouldUseDarkColors: Effect.succeed(false),
67-
setSource: () => Effect.void,
68-
onUpdated: () => Effect.void,
69-
});
70-
71-
const desktopWindowLayer = Layer.succeed(DesktopWindow.DesktopWindow, {
72-
createMain: Effect.die("unexpected window creation"),
73-
ensureMain: Effect.die("unexpected window creation"),
74-
revealOrCreateMain: Effect.die("unexpected window creation"),
75-
activate: Effect.void,
76-
createMainIfBackendReady: Effect.void,
77-
showConnectingSplash: Effect.void,
78-
handleBackendReady: () => Effect.void,
79-
handleBackendNotReady: Effect.void,
80-
flushMainWindowBounds: Effect.void,
81-
dispatchMenuAction: () => Effect.void,
82-
zoomMain: () => Effect.void,
83-
syncAppearance: Effect.void,
84-
});
85-
86105
const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
87106
platform,
88107
isDevelopment: false,
89108
} as DesktopEnvironment.DesktopEnvironment["Service"]);
90109

91110
const layer = DesktopLifecycle.layer.pipe(
92-
Layer.provideMerge(electronAppLayer),
111+
Layer.provideMerge(makeElectronAppLayer(appListeners)),
93112
Layer.provideMerge(electronThemeLayer),
94-
Layer.provideMerge(desktopWindowLayer),
113+
Layer.provideMerge(makeElectronWindowLayer()),
114+
Layer.provideMerge(makeDesktopWindowLayer()),
95115
Layer.provideMerge(environmentLayer),
96116
Layer.provideMerge(DesktopShutdown.layer),
97117
Layer.provideMerge(DesktopState.layer),
@@ -123,4 +143,103 @@ describe("DesktopLifecycle", () => {
123143
).pipe(Effect.provide(layer));
124144
});
125145
}
146+
147+
it.effect("destroys windows before waiting for backend shutdown", () =>
148+
Effect.gen(function* () {
149+
const appListeners = new Map<string, (...args: readonly unknown[]) => void>();
150+
const shutdownRequested = yield* Deferred.make<void>();
151+
const allowShutdown = yield* Deferred.make<void>();
152+
const quitRequested = yield* Deferred.make<void>();
153+
const events: string[] = [];
154+
155+
const quit = Effect.sync(() => {
156+
events.push("quit");
157+
}).pipe(Effect.andThen(Deferred.succeed(quitRequested, undefined)), Effect.asVoid);
158+
const destroyAll = Effect.sync(() => {
159+
events.push("destroy");
160+
});
161+
const flushMainWindowBounds = Effect.sync(() => {
162+
events.push("flush");
163+
});
164+
165+
const desktopShutdownLayer = Layer.succeed(DesktopShutdown.DesktopShutdown, {
166+
request: Effect.sync(() => {
167+
events.push("request");
168+
}).pipe(Effect.andThen(Deferred.succeed(shutdownRequested, undefined)), Effect.asVoid),
169+
awaitRequest: Deferred.await(shutdownRequested),
170+
markComplete: Deferred.succeed(allowShutdown, undefined).pipe(Effect.asVoid),
171+
awaitComplete: Deferred.await(allowShutdown),
172+
isComplete: Deferred.isDone(allowShutdown),
173+
});
174+
175+
const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
176+
platform: "darwin",
177+
isDevelopment: false,
178+
} as DesktopEnvironment.DesktopEnvironment["Service"]);
179+
180+
const layer = DesktopLifecycle.layer.pipe(
181+
Layer.provideMerge(makeElectronAppLayer(appListeners, quit)),
182+
Layer.provideMerge(electronThemeLayer),
183+
Layer.provideMerge(makeElectronWindowLayer(destroyAll)),
184+
Layer.provideMerge(makeDesktopWindowLayer({ flushMainWindowBounds })),
185+
Layer.provideMerge(environmentLayer),
186+
Layer.provideMerge(desktopShutdownLayer),
187+
Layer.provideMerge(DesktopState.layer),
188+
);
189+
190+
yield* Effect.scoped(
191+
Effect.gen(function* () {
192+
const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
193+
yield* lifecycle.register;
194+
195+
const event = { preventDefault: () => undefined } as Electron.Event;
196+
appListeners.get("before-quit")?.(event);
197+
198+
yield* Deferred.await(shutdownRequested);
199+
const eventsBeforeCleanup = [...events];
200+
yield* Deferred.succeed(allowShutdown, undefined);
201+
yield* Deferred.await(quitRequested);
202+
203+
assert.deepEqual(eventsBeforeCleanup, ["flush", "destroy", "request"]);
204+
assert.deepEqual(events, ["flush", "destroy", "request", "quit"]);
205+
}),
206+
).pipe(Effect.provide(layer));
207+
}),
208+
);
209+
210+
it.effect("ignores app activation while quitting", () =>
211+
Effect.gen(function* () {
212+
const appListeners = new Map<string, (...args: readonly unknown[]) => void>();
213+
let activationCount = 0;
214+
const activate = Effect.sync(() => {
215+
activationCount += 1;
216+
});
217+
const environmentLayer = Layer.succeed(DesktopEnvironment.DesktopEnvironment, {
218+
platform: "darwin",
219+
isDevelopment: false,
220+
} as DesktopEnvironment.DesktopEnvironment["Service"]);
221+
const layer = DesktopLifecycle.layer.pipe(
222+
Layer.provideMerge(makeElectronAppLayer(appListeners)),
223+
Layer.provideMerge(electronThemeLayer),
224+
Layer.provideMerge(makeElectronWindowLayer()),
225+
Layer.provideMerge(makeDesktopWindowLayer({ activate })),
226+
Layer.provideMerge(environmentLayer),
227+
Layer.provideMerge(DesktopShutdown.layer),
228+
Layer.provideMerge(DesktopState.layer),
229+
);
230+
231+
yield* Effect.scoped(
232+
Effect.gen(function* () {
233+
const lifecycle = yield* DesktopLifecycle.DesktopLifecycle;
234+
const state = yield* DesktopState.DesktopState;
235+
yield* lifecycle.register;
236+
yield* Ref.set(state.quitting, true);
237+
238+
appListeners.get("activate")?.();
239+
240+
assert.equal(activationCount, 0);
241+
}),
242+
).pipe(Effect.provide(layer));
243+
}),
244+
);
126245
});

0 commit comments

Comments
 (0)