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 { describe, expect, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as SubscriptionRef from "effect/SubscriptionRef";
import {
BearerConnectionCredential,
BearerConnectionRegistration,
PrimaryConnectionRegistration,
} from "./catalog.ts";
import { BearerConnectionTarget } from "./model.ts";
import * as EnvironmentRegistry from "./registry.ts";
import {
TARGET,
BEARER_TARGET,
BEARER_PROFILE,
BEARER_CREDENTIAL,
bearerRegistration,
SSH_TARGET,
SSH_CONNECTION,
SSH_PROFILE,
makeHarness,
awaitConnectionState,
} from "./registry.test-support.ts";
describe("EnvironmentRegistry", () => {
it.effect("starts a newly paired bearer environment without re-reading its profile", () =>
Effect.gen(function* () {
const harness = yield* makeHarness([]);
yield* Effect.gen(function* () {
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
yield* registry.register(
new BearerConnectionRegistration({
target: BEARER_TARGET,
profile: BEARER_PROFILE,
credential: BEARER_CREDENTIAL,
}),
);
yield* awaitConnectionState(
registry,
BEARER_TARGET.environmentId,
(state) => state.phase === "connected",
);
expect(yield* Ref.get(harness.profileReadCount)).toBe(0);
expect(
Option.getOrThrow(
(yield* SubscriptionRef.get(registry.entries)).get(BEARER_TARGET.environmentId)
?.profile ?? Option.none(),
),
).toEqual(BEARER_PROFILE);
}).pipe(Effect.provide(harness.layer), Effect.scoped);
}),
);
it.effect("starts platform environments without persisting or removing them", () =>
Effect.gen(function* () {
const harness = yield* makeHarness([]);
yield* Effect.gen(function* () {
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
yield* registry.registerPlatform(new PrimaryConnectionRegistration({ target: TARGET }));
yield* awaitConnectionState(
registry,
TARGET.environmentId,
(state) => state.phase === "connected",
);
expect((yield* Ref.get(harness.storedTargets)).has(TARGET.environmentId)).toBe(false);
expect(
(yield* SubscriptionRef.get(registry.entries)).get(TARGET.environmentId)?.target,
).toEqual(TARGET);
const error = yield* Effect.flip(registry.remove(TARGET.environmentId));
expect(error._tag).toBe("PlatformEnvironmentRemovalError");
expect(
(yield* SubscriptionRef.get(registry.entries)).get(TARGET.environmentId)?.target,
).toEqual(TARGET);
}).pipe(Effect.provide(harness.layer));
}),
);
it.effect("gives a primary platform registration precedence over persisted registrations", () =>
Effect.gen(function* () {
const shadowedTarget = new BearerConnectionTarget({
environmentId: TARGET.environmentId,
label: "Shadowed bearer environment",
connectionId: "shadowed-bearer-connection",
});
const harness = yield* makeHarness([shadowedTarget]);
yield* Effect.gen(function* () {
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
yield* registry.registerPlatform(new PrimaryConnectionRegistration({ target: TARGET }));
expect(
(yield* SubscriptionRef.get(registry.entries)).get(TARGET.environmentId)?.target,
).toEqual(TARGET);
expect((yield* Ref.get(harness.storedTargets)).has(TARGET.environmentId)).toBe(false);
yield* registry.register(bearerRegistration(shadowedTarget));
expect(
(yield* SubscriptionRef.get(registry.entries)).get(TARGET.environmentId)?.target,
).toEqual(TARGET);
expect((yield* Ref.get(harness.storedTargets)).has(TARGET.environmentId)).toBe(false);
}).pipe(Effect.provide(harness.layer), Effect.scoped);
}),
);
it.effect("rechecks platform ownership after waiting for the environment lease", () =>
Effect.gen(function* () {
const registrationStarted = yield* Deferred.make<void>();
const continueRegistration = yield* Deferred.make<void>();
const shadowedTarget = new BearerConnectionTarget({
environmentId: TARGET.environmentId,
label: "Shadowed bearer environment",
connectionId: "shadowed-bearer-connection",
});
const harness = yield* makeHarness([], [], [], {
beforeRegistrationRegister: () =>
Deferred.succeed(registrationStarted, undefined).pipe(
Effect.andThen(Deferred.await(continueRegistration)),
),
});
yield* Effect.gen(function* () {
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
const persistedRegistration = yield* registry
.register(bearerRegistration(shadowedTarget))
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(registrationStarted);
const platformRegistration = yield* registry
.registerPlatform(new PrimaryConnectionRegistration({ target: TARGET }))
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Effect.yieldNow;
const removal = yield* Effect.flip(registry.remove(TARGET.environmentId)).pipe(
Effect.forkChild({ startImmediately: true }),
);
yield* Deferred.succeed(continueRegistration, undefined);
yield* Fiber.join(persistedRegistration);
yield* Fiber.join(platformRegistration);
const error = yield* Fiber.join(removal);
expect(error._tag).toBe("PlatformEnvironmentRemovalError");
expect(
(yield* SubscriptionRef.get(registry.entries)).get(TARGET.environmentId)?.target,
).toEqual(TARGET);
}).pipe(Effect.provide(harness.layer), Effect.scoped);
}),
);
it.effect("retains a healthy runtime when the platform repeats an identical registration", () =>
Effect.gen(function* () {
const harness = yield* makeHarness([]);
yield* Effect.gen(function* () {
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
const registration = new PrimaryConnectionRegistration({ target: TARGET });
yield* registry.registerPlatform(registration);
yield* awaitConnectionState(
registry,
TARGET.environmentId,
(state) => state.phase === "connected",
);
yield* registry.registerPlatform(registration);
expect(yield* Ref.get(harness.sessions)).toHaveLength(1);
}).pipe(Effect.provide(harness.layer), Effect.scoped);
}),
);
it.effect("removes all owned SSH state only on explicit removal", () =>
Effect.gen(function* () {
const harness = yield* makeHarness(
[SSH_CONNECTION],
[SSH_PROFILE],
[
[
SSH_CONNECTION.connectionId,
new BearerConnectionCredential({ token: "temporary-token" }),
],
],
);
yield* Effect.gen(function* () {
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
yield* registry.start;
yield* registry.remove(SSH_CONNECTION.environmentId);
expect((yield* Ref.get(harness.storedProfiles)).has(SSH_CONNECTION.connectionId)).toBe(
false,
);
expect((yield* Ref.get(harness.storedCredentials)).has(SSH_CONNECTION.connectionId)).toBe(
false,
);
expect(yield* Ref.get(harness.disconnectedSshTargets)).toEqual([SSH_TARGET]);
}).pipe(Effect.provide(harness.layer));
}),
);
});