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 Match from "effect/Match";
import { describe, expect, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as SubscriptionRef from "effect/SubscriptionRef";
import * as TestClock from "effect/testing/TestClock";
import * as EnvironmentSupervisor from "./supervisor.ts";
import {
TARGET_ENTRY,
PREPARED_CONNECTION,
transient,
blocked,
awaitState,
eventuallyState,
makeHarness,
} from "./supervisor.test-support.ts";
describe("EnvironmentSupervisor", () => {
it.effect("waits while offline and connects immediately when the network returns", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({ networkStatus: "offline" });
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "offline");
expect(yield* Ref.get(harness.prepareCount)).toBe(0);
yield* harness.setNetworkStatus("online");
const ready = yield* awaitState(supervisor.state, (state) => state.phase === "connected");
expect(ready).toMatchObject({
desired: true,
network: "online",
phase: "connected",
attempt: 1,
generation: 1,
lastFailure: null,
});
expect(yield* Ref.get(harness.prepareCount)).toBe(1);
}),
);
it.effect("resets retries when activation arrives before the network returns", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.closeLatestSession();
yield* awaitState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 1,
);
yield* harness.setNetworkStatus("offline");
yield* awaitState(
supervisor.state,
(state) => state.phase === "offline" && state.attempt === 2,
);
yield* harness.wake("application-active-reconnect");
yield* awaitState(
supervisor.state,
(state) => state.phase === "offline" && state.attempt === 1,
);
yield* harness.setNetworkStatus("online");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2 && state.attempt === 1,
);
}),
);
it.effect("resets retries when activation wakes a blocked connection", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({
prepare: (attempt) =>
Match.value(attempt).pipe(
Match.when(1, () => Effect.fail(transient())),
Match.when(2, () => Effect.fail(blocked())),
Match.orElse(() => Effect.succeed(PREPARED_CONNECTION)),
),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 1,
);
yield* TestClock.adjust("3 seconds");
yield* awaitState(
supervisor.state,
(state) => state.phase === "blocked" && state.attempt === 2,
);
yield* harness.wake("application-active-reconnect");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.attempt === 1,
);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("releases a live session while offline and starts a new generation when online", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 1,
);
yield* harness.setNetworkStatus("offline");
yield* awaitState(supervisor.state, (state) => state.phase === "offline");
expect(yield* Ref.get(harness.releaseCount)).toBe(1);
expect(Option.isNone(yield* SubscriptionRef.get(supervisor.session))).toBe(true);
yield* harness.setNetworkStatus("online");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2,
);
expect(yield* Ref.get(harness.sessionCount)).toBe(2);
}),
);
it.effect("retries a blocked connection when platform credentials change", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({
prepare: (attempt) =>
attempt === 1 ? Effect.fail(blocked()) : Effect.succeed(PREPARED_CONNECTION),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "blocked");
yield* harness.wake("credentials-changed");
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
expect(yield* Ref.get(harness.prepareCount)).toBe(2);
}),
);
it.effect("does not let platform wakeups reset an in-flight attempt", () =>
Effect.gen(function* () {
const firstAttemptStarted = yield* Deferred.make<void>();
const harness = yield* makeHarness({
prepare: () =>
Deferred.succeed(firstAttemptStarted, undefined).pipe(Effect.andThen(Effect.never)),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* Deferred.await(firstAttemptStarted);
yield* Effect.all(
[
harness.wake("credentials-changed"),
harness.wake("application-active"),
harness.wake("credentials-changed"),
],
{ concurrency: "unbounded" },
);
yield* Effect.yieldNow;
expect(yield* Ref.get(harness.prepareCount)).toBe(1);
yield* TestClock.adjust("15 seconds");
const retrying = yield* eventuallyState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 1,
);
expect(retrying).toMatchObject({
lastFailure: {
_tag: "ConnectionTransientError",
reason: "timeout",
message: "Test environment did not respond during connection setup.",
},
});
expect(yield* Ref.get(harness.prepareCount)).toBe(1);
expect(yield* Ref.get(harness.sessionCount)).toBe(0);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("restarts the retry ladder when mobile returns to the foreground", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.closeLatestSession();
yield* awaitState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 1,
);
yield* TestClock.adjust("3 seconds");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2,
);
yield* harness.closeLatestSession();
yield* awaitState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 2,
);
yield* harness.wake("application-active-reconnect");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 3 && state.attempt === 1,
);
yield* harness.closeLatestSession();
yield* awaitState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 1,
);
expect(yield* Ref.get(harness.sessionCount)).toBe(3);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("restarts the retry ladder when a long resume replaces a connected session", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.closeLatestSession();
yield* awaitState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 1,
);
yield* TestClock.adjust("3 seconds");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2 && state.attempt === 2,
);
yield* harness.wake("application-active-reconnect");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 3 && state.attempt === 1,
);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("restarts the retry ladder when a long resume interrupts connection setup", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({
prepare: (attempt) => (attempt === 2 ? Effect.never : Effect.succeed(PREPARED_CONNECTION)),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.closeLatestSession();
yield* awaitState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 1,
);
yield* TestClock.adjust("3 seconds");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connecting" && state.attempt === 2,
);
yield* harness.wake("application-active-reconnect");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2 && state.attempt === 1,
);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("probes the active session without reconnecting on application activation", () =>
Effect.gen(function* () {
const probeCount = yield* Ref.make(0);
const probeCalled = yield* Deferred.make<void>();
const harness = yield* makeHarness({
probe: () =>
Ref.update(probeCount, (count) => count + 1).pipe(
Effect.andThen(Deferred.succeed(probeCalled, undefined)),
),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.wake("application-active");
yield* Deferred.await(probeCalled);
expect(yield* Ref.get(probeCount)).toBe(1);
expect(yield* Ref.get(harness.sessionCount)).toBe(1);
expect(yield* Ref.get(harness.releaseCount)).toBe(0);
expect((yield* SubscriptionRef.get(supervisor.state)).phase).toBe("connected");
}),
);
it.effect("immediately replaces a mobile session after a long background resume", () =>
Effect.gen(function* () {
const probeCount = yield* Ref.make(0);
const harness = yield* makeHarness({
probe: () => Ref.update(probeCount, (count) => count + 1),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 1,
);
yield* harness.wake("application-active-reconnect");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2,
);
expect(yield* Ref.get(probeCount)).toBe(0);
expect(yield* Ref.get(harness.sessionCount)).toBe(2);
expect(yield* Ref.get(harness.releaseCount)).toBe(1);
}),
);
it.effect("replaces a mobile session when a long resume interrupts an active probe", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({
probe: (attempt) => (attempt === 1 ? Effect.never : Effect.void),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 1,
);
yield* harness.wake("application-active-probe");
yield* Effect.yieldNow;
yield* harness.wake("application-active-reconnect");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2,
);
expect(yield* Ref.get(harness.sessionCount)).toBe(2);
expect(yield* Ref.get(harness.releaseCount)).toBe(1);
}),
);
it.effect("reconnects immediately when the foreground liveness probe fails", () =>
Effect.gen(function* () {
const allowReconnect = yield* Deferred.make<void>();
const harness = yield* makeHarness({
prepare: (attempt) =>
attempt === 2
? Deferred.await(allowReconnect).pipe(Effect.as(PREPARED_CONNECTION))
: Effect.succeed(PREPARED_CONNECTION),
probe: (attempt) =>
attempt === 1 ? Effect.fail(transient("The live session is stale.")) : Effect.void,
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.wake("application-active");
const reconnecting = yield* awaitState(
supervisor.state,
(state) => state.phase === "connecting",
);
expect(reconnecting.attempt).toBe(1);
expect(Option.isNone(yield* SubscriptionRef.get(supervisor.session))).toBe(true);
// No TestClock advance: a failed wake probe skips the first backoff rung.
yield* Deferred.succeed(allowReconnect, undefined);
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2 && state.attempt === 1,
);
expect(yield* Ref.get(harness.sessionCount)).toBe(2);
expect(yield* Ref.get(harness.releaseCount)).toBe(1);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("keeps normal backoff when a reconnect after a failed wake probe also fails", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({
prepare: (attempt) =>
attempt === 2 ? Effect.fail(transient()) : Effect.succeed(PREPARED_CONNECTION),
probe: (attempt) =>
attempt === 1 ? Effect.fail(transient("The live session is stale.")) : Effect.void,
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.wake("application-active");
// The immediate follow-up attempt fails: only the first attempt after
// the wake probe skips the ladder, so this failure backs off normally.
yield* awaitState(
supervisor.state,
(state) => state.phase === "backoff" && state.attempt === 1,
);
yield* TestClock.adjust("2999 millis");
expect(yield* Ref.get(harness.prepareCount)).toBe(2);
yield* TestClock.adjust("1 milli");
yield* eventuallyState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2,
);
expect(yield* Ref.get(harness.prepareCount)).toBe(3);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("uses the full tolerance window for a stalled desktop foreground probe", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({
probe: (attempt) => (attempt === 1 ? Effect.never : Effect.void),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.wake("application-active");
yield* TestClock.adjust("14999 millis");
expect(yield* Ref.get(harness.sessionCount)).toBe(1);
yield* TestClock.adjust("1 milli");
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2 && state.attempt === 1,
);
expect(yield* Ref.get(harness.sessionCount)).toBe(2);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("quickly times out a stalled mobile foreground liveness probe", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({
probe: (attempt) => (attempt === 1 ? Effect.never : Effect.void),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.wake("application-active-probe");
yield* TestClock.adjust("3 seconds");
// The timed-out wake probe reconnects immediately without a backoff
// sleep: no further clock advance is needed.
yield* awaitState(
supervisor.state,
(state) => state.phase === "connected" && state.generation === 2 && state.attempt === 1,
);
expect(yield* Ref.get(harness.sessionCount)).toBe(2);
}).pipe(Effect.provide(TestClock.layer())),
);
it.effect("honors an explicit disconnect while a foreground probe is stalled", () =>
Effect.gen(function* () {
const probeStarted = yield* Deferred.make<void>();
const harness = yield* makeHarness({
probe: () => Deferred.succeed(probeStarted, undefined).pipe(Effect.andThen(Effect.never)),
});
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.wake("application-active");
yield* Deferred.await(probeStarted);
yield* supervisor.disconnect;
yield* awaitState(supervisor.state, (state) => state.phase === "available");
expect(yield* Ref.get(harness.releaseCount)).toBe(1);
}),
);
it.effect("does not churn a healthy session when credentials change", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* harness.wake("credentials-changed");
yield* Effect.yieldNow;
expect(yield* Ref.get(harness.sessionCount)).toBe(1);
expect(yield* Ref.get(harness.releaseCount)).toBe(0);
expect((yield* SubscriptionRef.get(supervisor.state)).phase).toBe("connected");
}),
);
it.effect("does not lose an explicit disconnect among concurrent wakeup signals", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
const supervisor = yield* EnvironmentSupervisor.make(TARGET_ENTRY, {
initiallyDesired: true,
}).pipe(Effect.provide(harness.dependencies));
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
yield* Effect.all(
[
supervisor.disconnect,
harness.wake("credentials-changed"),
harness.wake("application-active"),
harness.wake("credentials-changed"),
],
{ concurrency: "unbounded" },
);
yield* awaitState(supervisor.state, (state) => state.phase === "available");
expect(yield* Ref.get(harness.releaseCount)).toBe(1);
expect(Option.isNone(yield* SubscriptionRef.get(supervisor.session))).toBe(true);
}),
);
});