import {
DEFAULT_SERVER_SETTINGS,
EnvironmentId,
ServerConfig,
type ServerConfig as ServerConfigType,
ServerConfigStreamEvent,
type ServerConfigStreamEvent as ServerConfigStreamEventType,
WS_METHODS,
UsageLimitSourceId,
} from "@t3tools/contracts";
import { splitSocketFrame } from "@t3tools/shared/socketFrameParts";
import { describe, expect, it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
import * as Socket from "effect/socket/Socket";
import * as TestClock from "effect/testing/TestClock";
import {
AVAILABLE_CONNECTION_STATE,
ConnectionBlockedError,
ConnectionTransientError,
PrimaryConnectionTarget,
type PreparedConnection,
} from "../connection/model.ts";
import * as EnvironmentSupervisor from "../connection/supervisor.ts";
import * as Persistence from "../platform/persistence.ts";
import * as RpcSession from "./session.ts";
import { makeEnvironmentServerConfigState } from "../state/server.ts";
import { applyServerConfigProjection } from "../state/serverConfigProjection.ts";
type SocketEventType = "open" | "message" | "close" | "error";
type SocketEvent = {
readonly code?: number;
readonly data?: unknown;
readonly reason?: string;
readonly type: SocketEventType;
};
type SocketListener = (event: SocketEvent) => void;
class TestWebSocket {
static readonly CONNECTING = 0;
static readonly OPEN = 1;
static readonly CLOSING = 2;
static readonly CLOSED = 3;
readyState = TestWebSocket.CONNECTING;
readonly sent: string[] = [];
readonly url: string;
readonly sentChanges: Queue.Queue<void>;
private readonly listeners = new Map<SocketEventType, Set<SocketListener>>();
constructor(url: string, sentChanges: Queue.Queue<void>) {
this.url = url;
this.sentChanges = sentChanges;
}
addEventListener(type: SocketEventType, listener: SocketListener) {
const listeners = this.listeners.get(type) ?? new Set<SocketListener>();
listeners.add(listener);
this.listeners.set(type, listeners);
}
removeEventListener(type: SocketEventType, listener: SocketListener) {
this.listeners.get(type)?.delete(listener);
}
send(data: string) {
this.sent.push(data);
Queue.offerUnsafe(this.sentChanges, undefined);
}
close(code = 1000, reason = "") {
if (this.readyState === TestWebSocket.CLOSED) {
return;
}
this.readyState = TestWebSocket.CLOSED;
this.emit("close", { code, reason, type: "close" });
}
open() {
this.readyState = TestWebSocket.OPEN;
this.emit("open", { type: "open" });
}
serverMessage(data: string) {
this.emit("message", { data, type: "message" });
}
private emit(type: SocketEventType, event: SocketEvent) {
for (const listener of this.listeners.get(type) ?? []) {
listener(event);
}
}
}
const TARGET = new PrimaryConnectionTarget({
environmentId: EnvironmentId.make("environment-1"),
label: "Test environment",
httpBaseUrl: "https://environment.example.test",
wsBaseUrl: "wss://environment.example.test",
});
const PREPARED: PreparedConnection = {
environmentId: TARGET.environmentId,
label: TARGET.label,
httpBaseUrl: TARGET.httpBaseUrl,
socketUrl: "wss://environment.example.test/ws?wsTicket=test",
httpAuthorization: null,
target: TARGET,
};
const SERVER_CONFIG: ServerConfigType = {
environment: {
environmentId: TARGET.environmentId,
label: TARGET.label,
platform: {
os: "darwin",
arch: "arm64",
},
serverVersion: "0.0.0-test",
capabilities: {
repositoryIdentity: true,
connectionProbe: true,
},
},
auth: {
policy: "loopback-browser",
bootstrapMethods: ["one-time-token"],
sessionMethods: ["browser-session-cookie", "bearer-access-token"],
sessionCookieName: "t3_session",
},
cwd: "/tmp/workspace",
keybindingsConfigPath: "/tmp/workspace/keybindings.json",
keybindings: [],
issues: [],
providers: [],
availableEditors: [],
observability: {
logsDirectoryPath: "/tmp/logs",
localTracingEnabled: false,
otlpTracesEnabled: false,
otlpMetricsEnabled: false,
otlpLogsEnabled: false,
},
settings: DEFAULT_SERVER_SETTINGS,
};
const RpcRequest = Schema.TaggedStruct("Request", {
id: Schema.Union([Schema.String, Schema.Number]),
payload: Schema.Unknown,
tag: Schema.String,
});
const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
const isRpcRequest = Schema.is(RpcRequest);
const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
const encodeServerConfig = Schema.encodeSync(ServerConfig);
const encodeServerConfigStreamEvent = Schema.encodeSync(ServerConfigStreamEvent);
const encodeDefect = Schema.encodeSync(Schema.Defect());
const ENCODED_SERVER_CONFIG = encodeServerConfig(SERVER_CONFIG);
const THEME_SERVER_CONFIG: ServerConfigType = {
...SERVER_CONFIG,
environment: {
...SERVER_CONFIG.environment,
capabilities: {
...SERVER_CONFIG.environment.capabilities,
environmentThemes: true,
},
},
};
const ENCODED_THEME_SERVER_CONFIG = encodeServerConfig(THEME_SERVER_CONFIG);
const SOURCE_SERVER_CONFIG: ServerConfigType = {
...THEME_SERVER_CONFIG,
environment: {
...THEME_SERVER_CONFIG.environment,
capabilities: { ...THEME_SERVER_CONFIG.environment.capabilities, usageLimitSources: true },
},
};
const SOURCE_EVENT: ServerConfigStreamEventType = {
version: 1,
type: "usageLimitSourcesUpdated",
payload: {
sources: [
{
id: UsageLimitSourceId.make("proxy"),
kind: "cliproxy",
label: "Proxy",
checkedAt: "2026-09-04T00:00:00Z",
accounts: [],
},
],
},
};
const makeFactory = Effect.fn("TestRpcSessionFactory.make")(function* (
options: RpcSession.RpcSessionOptions = {},
) {
const sentChanges = yield* Queue.unbounded<void>();
const sockets = Object.assign([] as TestWebSocket[], { changes: yield* Queue.unbounded<void>() });
const layerConstructor = Layer.succeed(Socket.WebSocketConstructor, (url) => {
const socket = new TestWebSocket(url, sentChanges);
sockets.push(socket);
Queue.offerUnsafe(sockets.changes, undefined);
return socket as unknown as globalThis.WebSocket;
});
const layer = RpcSession.layer(options).pipe(Layer.provide(layerConstructor));
const factory = yield* RpcSession.RpcSessionFactory.pipe(Effect.provide(layer));
return { factory, sockets };
});
const awaitSocket = Effect.fn("TestRpcSessionFactory.awaitSocket")(function* (
sockets: ReadonlyArray<TestWebSocket> & { readonly changes: Queue.Queue<void> },
index = 0,
) {
for (;;) {
const socket = sockets[index];
if (socket) {
return socket;
}
yield* Queue.take(sockets.changes);
}
});
const awaitRequest = Effect.fn("TestRpcSessionFactory.awaitRequest")(function* (
socket: TestWebSocket,
index = 0,
) {
for (;;) {
const request = socket.sent.map((message) => decodeJson(message)).filter(isRpcRequest)[index];
if (request) {
return request;
}
yield* Queue.take(socket.sentChanges);
}
});
const completeInitialConfig = Effect.fn("TestRpcSessionFactory.completeInitialConfig")(function* (
socket: TestWebSocket,
config: unknown = ENCODED_SERVER_CONFIG,
payload: unknown = {},
) {
const request = yield* awaitRequest(socket);
expect(request).toMatchObject({
_tag: "Request",
tag: WS_METHODS.subscribeServerConfig,
payload,
});
socket.serverMessage(
encodeJson({
_tag: "Chunk",
requestId: request.id,
values: [{ version: 1, type: "snapshot", config }],
}),
);
});
const publishConfigEvents = Effect.fn("TestRpcSessionFactory.publishConfigEvents")(function* (
socket: TestWebSocket,
events: ReadonlyArray<ServerConfigStreamEventType>,
) {
const request = yield* awaitRequest(socket);
socket.serverMessage(
encodeJson({
_tag: "Chunk",
requestId: request.id,
values: events.map((event) => encodeServerConfigStreamEvent(event)),
}),
);
});
describe("RpcSessionFactory", () => {
it.effect("connects while a large config snapshot downloads at 4000 bytes per second", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
const request = yield* awaitRequest(socket);
// Multi-byte text, so parts must be sized in UTF-8 bytes and never split a surrogate pair.
const config = { ...SERVER_CONFIG, cwd: "/" + "é€😀x".repeat(32 * 1024) };
const frame = encodeJson({
_tag: "Chunk",
requestId: request.id,
values: [{ version: 1, type: "snapshot", config: encodeServerConfig(config) }],
});
const parts = new URL(socket.url).searchParams.has("frameParts")
? splitSocketFrame(frame)
: [frame];
for (const part of parts) {
const bytes = new TextEncoder().encode(part);
yield* TestClock.adjust((bytes.length / 4000) * 1000);
socket.serverMessage(new TextDecoder().decode(bytes));
}
yield* Fiber.join(readyFiber);
expect(yield* session.initialConfig).toEqual(config);
}),
);
it.effect("owns one scoped websocket attempt and exposes readiness and closure", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
expect(socket.url).toBe(`${PREPARED.socketUrl}&frameParts=1`);
socket.open();
yield* completeInitialConfig(socket);
yield* Fiber.join(readyFiber);
const config = yield* session.initialConfig;
expect(config).toEqual(SERVER_CONFIG);
expect(socket.sent.map((message) => decodeJson(message)).filter(isRpcRequest)).toHaveLength(
1,
);
const probeFiber = yield* Effect.forkChild(session.probe);
const probeRequest = yield* awaitRequest(socket, 1);
expect(probeRequest).toMatchObject({
_tag: "Request",
tag: WS_METHODS.serverProbe,
payload: {},
});
socket.serverMessage(
encodeJson({
_tag: "Exit",
requestId: probeRequest.id,
exit: {
_tag: "Success",
value: {},
},
}),
);
yield* Fiber.join(probeFiber);
expect(
socket.sent
.map((message) => decodeJson(message))
.filter(isRpcRequest)
.map((request) => request.tag),
).toEqual([WS_METHODS.subscribeServerConfig, WS_METHODS.serverProbe]);
socket.close(1012, "service restart");
const error = yield* Effect.flip(session.closed);
const configStreamError = yield* session
.subscribeServerConfig({})
.pipe(Stream.runDrain, Effect.flip);
expect(error).toBeInstanceOf(ConnectionTransientError);
expect(error).toMatchObject({
reason: "transport",
message: "Test environment disconnected.",
});
expect(configStreamError).toMatchObject({ _tag: "RpcClientError" });
yield* Effect.yieldNow;
expect(sockets).toHaveLength(1);
}),
);
it.effect("counts every inbound frame, including ones that answer no request", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket);
yield* Fiber.join(readyFiber);
const before = yield* session.inboundFrames;
socket.serverMessage(encodeJson({ _tag: "Pong" }));
expect(yield* session.inboundFrames).toBe(before + 1);
}),
);
it.effect("closes the websocket when the session scope is released", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
yield* Effect.scoped(
Effect.gen(function* () {
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket);
yield* Fiber.join(readyFiber);
}),
);
expect(sockets[0]?.readyState).toBe(TestWebSocket.CLOSED);
}),
);
it.effect("ends a stream at once when its socket closes", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket);
yield* Fiber.join(readyFiber);
// Like the supervisor: the closed session interrupts its streams, and a
// stream interrupt must not wait for a socket that is gone.
const ended = yield* Effect.forkChild(
Effect.raceFirst(
Effect.flip(session.closed),
session.client[WS_METHODS.subscribeServerLifecycle]({}).pipe(
Stream.runDrain,
Effect.andThen(Effect.never),
),
),
);
yield* awaitRequest(socket, 1);
socket.close(1006);
yield* TestClock.adjust("999 millis");
expect(ended.pollUnsafe()).toBeDefined();
// A request made after the close still fails instead of waiting forever.
const lateProbe = yield* Effect.forkChild(session.probe);
yield* TestClock.adjust("999 millis");
expect(lateProbe.pollUnsafe()?._tag).toBe("Failure");
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.effect("replays current config and broadcasts updates to every subscriber", () =>
Effect.scoped(
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket);
yield* Fiber.join(readyFiber);
const collectTwo = session
.subscribeServerConfig({})
.pipe(Stream.take(2), Stream.runCollect);
const firstSubscriber = yield* Effect.forkChild(collectTwo);
const secondSubscriber = yield* Effect.forkChild(collectTwo);
yield* Effect.yieldNow;
const shortcut = {
key: "k",
metaKey: false,
ctrlKey: false,
shiftKey: false,
altKey: false,
modKey: true,
};
const request = yield* awaitRequest(socket);
socket.serverMessage(
encodeJson({
_tag: "Chunk",
requestId: request.id,
values: [
{
version: 1,
type: "keybindingsUpdated",
payload: {
keybindings: [{ command: "terminal.toggle", shortcut }],
issues: [],
},
},
],
}),
);
const firstEvents = Array.from(yield* Fiber.join(firstSubscriber));
const secondEvents = Array.from(yield* Fiber.join(secondSubscriber));
expect(firstEvents.map((event) => event.type)).toEqual(["snapshot", "keybindingsUpdated"]);
expect(secondEvents).toEqual(firstEvents);
const replay = yield* session.subscribeServerConfig({}).pipe(Stream.runHead);
expect(replay).toMatchObject({
_tag: "Some",
value: {
type: "snapshot",
config: { keybindings: [{ command: "terminal.toggle", shortcut }] },
},
});
}),
),
);
it.effect.each([
{ usageLimitSources: true },
{ environmentThemes: true, usageLimitSources: true },
])("replays usage sources and removal with %j", (options) =>
Effect.scoped(
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory(options);
const session = yield* factory.connect(PREPARED);
const ready = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket, encodeServerConfig(SOURCE_SERVER_CONFIG), options);
yield* Fiber.join(ready);
const observed = yield* Queue.unbounded<ServerConfigStreamEventType>();
yield* session.subscribeServerConfig().pipe(
Stream.runForEach((event) => Queue.offer(observed, event)),
Effect.forkChild,
);
expect((yield* Queue.take(observed)).type).toBe("snapshot");
const themes: ServerConfigStreamEventType[] = options.environmentThemes
? [{ version: 1, type: "environmentThemesUpdated", payload: { themes: [] } }]
: [];
for (const event of themes) {
yield* publishConfigEvents(socket, [event]);
expect(yield* Queue.take(observed)).toEqual(event);
}
const events: ServerConfigStreamEventType[] = [
SOURCE_EVENT,
{ version: 1, type: "usageLimitSourcesUpdated", payload: { sources: [] } },
SOURCE_EVENT,
];
for (const event of events) {
yield* publishConfigEvents(socket, [event]);
expect(yield* Queue.take(observed)).toEqual(event);
const started = yield* Deferred.make<void>();
const replay = yield* session.subscribeServerConfig(options).pipe(
Stream.tap(() => Deferred.succeed(started, undefined)),
Stream.takeUntil((item) => item.type === "keybindingsUpdated"),
Stream.runCollect,
Effect.forkChild,
);
yield* Deferred.await(started);
const marker: ServerConfigStreamEventType = {
version: 1,
type: "keybindingsUpdated",
payload: { keybindings: [], issues: [] },
};
yield* publishConfigEvents(socket, [marker]);
expect(yield* Queue.take(observed)).toEqual(marker);
const replayed = Array.from(yield* Fiber.join(replay));
expect(replayed.slice(1)).toEqual([...themes, event, marker]);
let projection = applyServerConfigProjection(Option.none(), {
version: 1,
type: "snapshot",
config: SOURCE_SERVER_CONFIG,
});
projection = applyServerConfigProjection(projection, SOURCE_EVENT);
for (const item of replayed) projection = applyServerConfigProjection(projection, item);
expect(Option.getOrThrow(projection).config.usageLimitSources).toEqual(
event.type === "usageLimitSourcesUpdated" && event.payload.sources.length > 0
? event.payload.sources
: undefined,
);
}
expect(socket.sent.map((message) => decodeJson(message)).filter(isRpcRequest)).toHaveLength(
1,
);
}),
),
);
it.effect("replays theme updates and deletion as authoritative events", () =>
Effect.scoped(
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory({ environmentThemes: true });
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket, ENCODED_THEME_SERVER_CONFIG, {
environmentThemes: true,
});
yield* Fiber.join(readyFiber);
const firstThemes = [
{
id: "nightfall",
name: "Nightfall",
appearance: "dark" as const,
canvas: "#1a1b26",
accent: "#7aa2f7",
},
];
const replacementThemes = [
{
id: "midnight",
name: "Midnight",
appearance: "dark" as const,
canvas: "#000000",
accent: "#ffffff",
},
];
const subscriberStarted = yield* Deferred.make<void>();
const subscriber = yield* session.subscribeServerConfig({ environmentThemes: true }).pipe(
Stream.mapEffect((event) =>
Deferred.succeed(subscriberStarted, undefined).pipe(Effect.as(event)),
),
Stream.take(4),
Stream.runCollect,
Effect.forkChild,
);
yield* Deferred.await(subscriberStarted);
yield* publishConfigEvents(socket, [
{
version: 1,
type: "environmentThemesUpdated",
payload: { themes: firstThemes },
},
{
version: 1,
type: "environmentThemesUpdated",
payload: { themes: replacementThemes },
},
{
version: 1,
type: "environmentThemesUpdated",
payload: { themes: [] },
},
]);
const liveEvents = Array.from(yield* Fiber.join(subscriber));
expect(liveEvents.map((event) => event.type)).toEqual([
"snapshot",
"environmentThemesUpdated",
"environmentThemesUpdated",
"environmentThemesUpdated",
]);
expect(liveEvents[2]).toMatchObject({ payload: { themes: replacementThemes } });
const replay = Array.from(
yield* session
.subscribeServerConfig({ environmentThemes: true })
.pipe(Stream.take(2), Stream.runCollect),
);
expect(replay.map((event) => event.type)).toEqual(["snapshot", "environmentThemesUpdated"]);
expect(replay[1]).toMatchObject({ payload: { themes: [] } });
let projection = applyServerConfigProjection(Option.none(), {
version: 1,
type: "snapshot",
config: THEME_SERVER_CONFIG,
});
projection = applyServerConfigProjection(projection, {
version: 1,
type: "environmentThemesUpdated",
payload: { themes: firstThemes },
});
for (const event of replay) {
projection = applyServerConfigProjection(projection, event);
}
expect(Option.getOrThrow(projection).config.environmentThemes).toBeUndefined();
}),
),
);
it.effect("recovers a slow subscriber after it misses theme and usage-source deletion", () =>
Effect.scoped(
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory({
environmentThemes: true,
usageLimitSources: true,
});
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket, encodeServerConfig(SOURCE_SERVER_CONFIG), {
environmentThemes: true,
usageLimitSources: true,
});
yield* Fiber.join(readyFiber);
const slowSubscriberStarted = yield* Deferred.make<void>();
const releaseSlowSubscriber = yield* Deferred.make<void>();
let firstEvent = true;
const slowSubscriber = yield* session
.subscribeServerConfig({ environmentThemes: true, usageLimitSources: true })
.pipe(
Stream.mapEffect((event) => {
if (!firstEvent) return Effect.succeed(event);
firstEvent = false;
return Deferred.succeed(slowSubscriberStarted, undefined).pipe(
Effect.andThen(Deferred.await(releaseSlowSubscriber)),
Effect.as(event),
);
}),
Stream.take(4),
Stream.runCollect,
Effect.forkChild,
);
yield* Deferred.await(slowSubscriberStarted);
const firstThemes = [
{
id: "nightfall",
name: "Nightfall",
appearance: "dark" as const,
canvas: "#1a1b26",
accent: "#7aa2f7",
},
];
const themeEvents: ServerConfigStreamEventType[] = [
{
version: 1,
type: "environmentThemesUpdated",
payload: { themes: firstThemes },
},
{
version: 1,
type: "environmentThemesUpdated",
payload: {
themes: [{ ...firstThemes[0]!, name: "Nightfall 2" }],
},
},
{
version: 1,
type: "environmentThemesUpdated",
payload: { themes: [] },
},
];
const settingsEvents = Array.from({ length: 65 }, (): ServerConfigStreamEventType => ({
version: 1,
type: "settingsUpdated",
payload: { settings: DEFAULT_SERVER_SETTINGS },
}));
const sourceEvents: ServerConfigStreamEventType[] = [
SOURCE_EVENT,
{ version: 1, type: "usageLimitSourcesUpdated", payload: { sources: [] } },
];
const allEvents = [...themeEvents, ...sourceEvents, ...settingsEvents];
const observedByFastSubscriber = yield* Queue.unbounded<ServerConfigStreamEventType>();
yield* session
.subscribeServerConfig({ environmentThemes: true, usageLimitSources: true })
.pipe(
Stream.runForEach((event) => Queue.offer(observedByFastSubscriber, event)),
Effect.forkChild,
);
expect((yield* Queue.take(observedByFastSubscriber)).type).toBe("snapshot");
for (const event of allEvents) {
yield* publishConfigEvents(socket, [event]);
expect(yield* Queue.take(observedByFastSubscriber)).toEqual(event);
}
yield* Deferred.succeed(releaseSlowSubscriber, undefined);
const recovered = Array.from(yield* Fiber.join(slowSubscriber));
expect(recovered.map((event) => event.type)).toEqual([
"snapshot",
"snapshot",
"environmentThemesUpdated",
"usageLimitSourcesUpdated",
]);
expect(recovered[2]).toMatchObject({ payload: { themes: [] } });
expect(recovered[3]).toMatchObject({ payload: { sources: [] } });
let projection = applyServerConfigProjection(Option.none(), {
version: 1,
type: "snapshot",
config: SOURCE_SERVER_CONFIG,
});
projection = applyServerConfigProjection(projection, themeEvents[0]!);
projection = applyServerConfigProjection(projection, SOURCE_EVENT);
for (const event of recovered.slice(1)) {
projection = applyServerConfigProjection(projection, event);
}
expect(Option.getOrThrow(projection).config.environmentThemes).toBeUndefined();
expect(Option.getOrThrow(projection).config.usageLimitSources).toBeUndefined();
}),
),
);
it.effect("closes the session when the config source dies", () =>
Effect.scoped(
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket);
yield* Fiber.join(readyFiber);
const closedFiber = yield* session.closed.pipe(Effect.exit, Effect.forkChild);
socket.serverMessage(
encodeJson({
_tag: "Defect",
defect: encodeDefect(new Error("config stream died")),
}),
);
const closed = yield* Fiber.join(closedFiber);
expect(Exit.isFailure(closed)).toBe(true);
if (Exit.isFailure(closed)) {
expect(Cause.hasDies(closed.cause)).toBe(true);
}
}),
),
);
it.effect.each([{ failure: "defect" as const }, { failure: "typed" as const }])(
"keeps durable config state alive after an owned $failure failure",
({ failure }) =>
Effect.scoped(
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory({ environmentThemes: true });
const firstSession = yield* factory.connect(PREPARED);
const firstReady = yield* Effect.forkChild(firstSession.ready);
const firstSocket = yield* awaitSocket(sockets);
firstSocket.open();
yield* completeInitialConfig(firstSocket, ENCODED_THEME_SERVER_CONFIG, {
environmentThemes: true,
});
yield* Fiber.join(firstReady);
const activeSession = yield* SubscriptionRef.make(Option.some(firstSession));
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: activeSession,
prepared: yield* SubscriptionRef.make(Option.some(PREPARED)),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
const cache = Persistence.EnvironmentCacheStore.of({
loadShell: () => Effect.succeedNone,
saveShell: () => Effect.void,
loadThread: () => Effect.succeedNone,
saveThread: () => Effect.void,
removeThread: () => Effect.void,
loadServerConfig: () => Effect.succeedNone,
saveServerConfig: () => Effect.void,
loadVcsRefs: () => Effect.succeedNone,
saveVcsRefs: () => Effect.void,
removeVcsRefs: () => Effect.void,
clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
const configState = yield* makeEnvironmentServerConfigState({
environmentThemes: true,
}).pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
Effect.provideService(Persistence.EnvironmentCacheStore, cache),
);
const awaitConfig = (predicate: (config: ServerConfigType) => boolean) =>
SubscriptionRef.changes(configState).pipe(
Stream.filter(Option.isSome),
Stream.map((projection) => projection.value.config),
Stream.filter(predicate),
Stream.runHead,
Effect.map(Option.getOrThrow),
);
const firstThemes = [
{
id: "first-theme",
name: "First theme",
appearance: "dark" as const,
canvas: "#111111",
accent: "#ffffff",
},
];
const firstThemeState = yield* awaitConfig(
(config) => config.environmentThemes?.[0]?.id === "first-theme",
).pipe(Effect.forkChild);
yield* publishConfigEvents(firstSocket, [
{
version: 1,
type: "environmentThemesUpdated",
payload: { themes: firstThemes },
},
]);
expect((yield* Fiber.join(firstThemeState)).environmentThemes).toEqual(firstThemes);
const firstClosed = yield* firstSession.closed.pipe(Effect.exit, Effect.forkChild);
const firstRequest = yield* awaitRequest(firstSocket);
firstSocket.serverMessage(
failure === "defect"
? encodeJson({
_tag: "Defect",
defect: encodeDefect(new Error("config stream died")),
})
: encodeJson({
_tag: "Exit",
requestId: firstRequest.id,
exit: {
_tag: "Failure",
cause: [
{
_tag: "Fail",
error: {
_tag: "EnvironmentAuthorizationError",
message: "config subscription rejected",
requiredScope: "orchestration:read",
},
},
],
},
}),
);
const firstClosedExit = yield* Fiber.join(firstClosed);
expect(Exit.isFailure(firstClosedExit)).toBe(true);
if (failure === "typed" && Exit.isFailure(firstClosedExit)) {
expect(Cause.squash(firstClosedExit.cause)).toBeInstanceOf(ConnectionBlockedError);
expect(Cause.squash(firstClosedExit.cause)).toMatchObject({ reason: "permission" });
}
yield* SubscriptionRef.set(activeSession, Option.none());
const recoveredConfig = {
...THEME_SERVER_CONFIG,
environment: {
...THEME_SERVER_CONFIG.environment,
label: "Recovered environment",
},
} satisfies ServerConfigType;
const secondSession = yield* factory.connect(PREPARED);
const secondReady = yield* Effect.forkChild(secondSession.ready);
const secondSocket = yield* awaitSocket(sockets, 1);
secondSocket.open();
yield* completeInitialConfig(secondSocket, encodeServerConfig(recoveredConfig), {
environmentThemes: true,
});
yield* Fiber.join(secondReady);
const recoveredState = yield* awaitConfig(
(config) => config.environment.label === "Recovered environment",
).pipe(Effect.forkChild);
yield* SubscriptionRef.set(activeSession, Option.some(secondSession));
expect((yield* Fiber.join(recoveredState)).environmentThemes).toEqual(firstThemes);
const recoveredThemes = [
{
id: "recovered-theme",
name: "Recovered theme",
appearance: "dark" as const,
canvas: "#000000",
accent: "#eeeeee",
},
];
const liveRecoveredState = yield* awaitConfig(
(config) => config.environmentThemes?.[0]?.id === "recovered-theme",
).pipe(Effect.forkChild);
yield* publishConfigEvents(secondSocket, [
{
version: 1,
type: "environmentThemesUpdated",
payload: { themes: recoveredThemes },
},
]);
expect((yield* Fiber.join(liveRecoveredState)).environmentThemes).toEqual(
recoveredThemes,
);
}),
),
);
it.effect("rejects a server config for a different environment", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(Effect.flip(session.ready));
const configFiber = yield* session
.subscribeServerConfig({})
.pipe(Stream.runHead, Effect.flip, Effect.forkChild);
const customConfigFiber = yield* session
.subscribeServerConfig({ environmentThemes: true })
.pipe(Stream.runHead, Effect.flip, Effect.forkChild);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket, {
...ENCODED_SERVER_CONFIG,
environment: {
...ENCODED_SERVER_CONFIG.environment,
environmentId: "environment-2",
},
});
const error = yield* Fiber.join(readyFiber);
expect(error).toMatchObject({
reason: "configuration",
message: "Connected environment environment-2 does not match environment-1.",
});
expect((yield* Fiber.join(configFiber))._tag).toBe("RpcClientError");
expect((yield* Fiber.join(customConfigFiber))._tag).toBe("RpcClientError");
}),
);
it.effect("keeps reading replies after closing a stream with a full buffer", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
yield* completeInitialConfig(socket);
yield* Fiber.join(readyFiber);
const consuming = yield* Deferred.make<void>();
const streamFiber = yield* session.client[WS_METHODS.subscribeServerConfig]({}).pipe(
Stream.runForEach(() =>
Deferred.succeed(consuming, undefined).pipe(Effect.andThen(Effect.never)),
),
Effect.forkChild,
);
const streamRequest = yield* awaitRequest(socket, 1);
const snapshot = { version: 1, type: "snapshot", config: ENCODED_SERVER_CONFIG };
socket.serverMessage(
encodeJson({
_tag: "Chunk",
requestId: streamRequest.id,
values: Array.from({ length: 64 }, () => snapshot),
}),
);
yield* Deferred.await(consuming);
yield* Fiber.interrupt(streamFiber);
const probeFiber = yield* Effect.forkChild(session.probe);
const probeRequest = yield* awaitRequest(socket, 2);
expect(probeRequest).toMatchObject({ tag: WS_METHODS.serverProbe });
socket.serverMessage(
encodeJson({
_tag: "Exit",
requestId: probeRequest.id,
exit: { _tag: "Success", value: {} },
}),
);
yield* Fiber.join(probeFiber);
}).pipe(Effect.scoped),
);
it.effect("reaches ready when a newer server sends unknown config members", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
const session = yield* factory.connect(PREPARED);
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
socket.open();
const shortcut = {
key: "p",
metaKey: false,
ctrlKey: false,
shiftKey: false,
altKey: false,
modKey: true,
};
yield* completeInitialConfig(socket, {
...ENCODED_SERVER_CONFIG,
keybindings: [
{ command: "someFuture.toggle", shortcut },
{ command: "terminal.toggle", shortcut },
],
issues: [{ kind: "keybindings.future-issue", message: "From a newer server" }],
availableEditors: ["some-future-editor", "zed"],
});
yield* Fiber.join(readyFiber);
const config = yield* session.initialConfig;
expect(config.keybindings).toEqual([{ command: "terminal.toggle", shortcut }]);
expect(config.issues).toEqual([]);
expect(config.availableEditors).toEqual(["zed"]);
}),
);
});