Skip to content

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.

18.4 KB
Raw Blame
import { testRpcClient } from "../test-support/services.ts";
import {
  BackgroundPolicySnapshot,
  EnvironmentId,
  type ServerSelfUpdateProgressEvent,
  WS_METHODS,
} from "@akeru/contracts";
import { describe, expect, expectTypeOf, it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
import * as TestClock from "effect/testing/TestClock";
import { RpcClientError } from "effect/unstable/rpc";

import {
  AVAILABLE_CONNECTION_STATE,
  PrimaryConnectionTarget,
  type PreparedConnection,
  type SupervisorConnectionState,
} from "../connection/model.ts";
import * as EnvironmentSupervisor from "../connection/supervisor.ts";
import * as RpcSession from "../rpc/session.ts";
import type { WsRpcProtocolClient } from "../rpc/protocol.ts";
import {
  EnvironmentRpcRequestObserver,
  request,
  runStream,
  subscribe,
  type EnvironmentStreamRpcTag,
  type EnvironmentRpcStreamValue,
  type EnvironmentSubscriptionRpcTag,
  type EnvironmentUnaryRpcTag,
} from "./client.ts";

const decodeBackgroundPolicySnapshot = Schema.decodeUnknownEffect(BackgroundPolicySnapshot);

const TARGET = new PrimaryConnectionTarget({
  environmentId: EnvironmentId.make("environment-1"),
  label: "Test environment",
  httpBaseUrl: "https://environment.example.test",
  wsBaseUrl: "wss://environment.example.test",
});

const UPDATE_DOWNLOADING: ServerSelfUpdateProgressEvent = {
  type: "progress",
  stage: "downloading",
};

const UPDATE_INSTALLING: ServerSelfUpdateProgressEvent = {
  type: "progress",
  stage: "installing",
};

function session(client: WsRpcProtocolClient): RpcSession.RpcSession {
  return {
    client,
    initialConfig: Effect.never,
    ready: Effect.void,
    probe: Effect.void,
    closed: Effect.never,
  };
}

const makeHarness = Effect.fn("TestEnvironmentRpc.makeHarness")(function* () {
  const state = yield* SubscriptionRef.make<SupervisorConnectionState>(AVAILABLE_CONNECTION_STATE);

  const activeSession = yield* SubscriptionRef.make<Option.Option<RpcSession.RpcSession>>(
    Option.none(),
  );

  const prepared = yield* SubscriptionRef.make<Option.Option<PreparedConnection>>(Option.none());
  const retryCount = yield* Ref.make(0);

  const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
    target: TARGET,
    state,
    session: activeSession,
    prepared,
    connect: Effect.void,
    disconnect: Effect.void,
    retryNow: Ref.update(retryCount, (count) => count + 1),
    retryIfDesired: Ref.update(retryCount, (count) => count + 1),
  } satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);

  return {
    activeSession,
    retryCount,
    supervisor,
  };
});

describe("environment RPC", () => {
  it("classifies every stream RPC separately from unary calls", () => {
    type StreamTags = {
      [Tag in keyof WsRpcProtocolClient]: Extract<
        ReturnType<WsRpcProtocolClient[Tag]>,
        Stream.Stream<unknown, unknown, unknown>
      > extends never
        ? never
        : Tag;
    }[keyof WsRpcProtocolClient];

    expectTypeOf<EnvironmentStreamRpcTag>().toEqualTypeOf<StreamTags>();
    expectTypeOf<
      typeof WS_METHODS.subscribeBackgroundPolicy
    >().toExtend<EnvironmentSubscriptionRpcTag>();
    expectTypeOf<
      Extract<EnvironmentUnaryRpcTag, typeof WS_METHODS.subscribeBackgroundPolicy>
    >().toEqualTypeOf<never>();
    expectTypeOf<
      EnvironmentRpcStreamValue<typeof WS_METHODS.subscribeBackgroundPolicy>
    >().toEqualTypeOf<BackgroundPolicySnapshot>();
  });

  it.effect(
    "delivers background policy snapshots across a failed transport and replacement session",
    () =>
      Effect.gen(function* () {
        const snapshot = yield* decodeBackgroundPolicySnapshot({
          hostPower: {
            source: "unknown",
            idle: "unknown",
            idleSeconds: null,
            locked: "unknown",
            suspended: false,
            onBattery: "unknown",
            lowPowerMode: "unknown",
            thermalState: "unknown",
            stale: false,
            updatedAt: DateTime.makeUnsafe("2026-01-01T00:00:00.000Z"),
          },
          leases: [],
          activeForegroundLeaseCount: 0,
          activeScopeKeys: [],
          shouldRunOpportunisticWork: true,
          updatedAt: DateTime.makeUnsafe("2026-01-01T00:00:00.000Z"),
        });

        const deliveries = yield* Queue.unbounded<BackgroundPolicySnapshot>();
        const failureObserved = yield* Queue.unbounded<void>();
        const { activeSession, supervisor } = yield* makeHarness();

        const mockClient = (
          method: () => Stream.Stream<BackgroundPolicySnapshot, RpcClientError.RpcClientError>,
        ) => {
          // SAFETY: This isolated client only subscribes to background policy; all other RPC access fails immediately.
          return new Proxy(
            {},
            {
              get: (_target, tag) => {
                if (tag === WS_METHODS.subscribeBackgroundPolicy) return method;
                throw new Error("Unexpected RPC in background policy test");
              },
            },
          ) as WsRpcProtocolClient;
        };

        const firstClient = mockClient(() =>
          Stream.concat(
            Stream.make(snapshot),
            Stream.fail(
              new RpcClientError.RpcClientError({
                reason: new RpcClientError.RpcClientDefect({
                  message: "socket closed",
                  cause: new Error("socket closed"),
                }),
              }),
            ),
          ).pipe(Stream.ensuring(Queue.offer(failureObserved, undefined).pipe(Effect.asVoid))),
        );

        const secondSnapshot = { ...snapshot, activeForegroundLeaseCount: 1 };

        const secondClient = mockClient(() =>
          Stream.concat(Stream.make(secondSnapshot), Stream.never),
        );

        const subscriptionFiber = yield* subscribe(WS_METHODS.subscribeBackgroundPolicy, {}).pipe(
          Stream.runForEach((value) => Queue.offer(deliveries, value)),
          Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
          Effect.forkChild,
        );

        yield* SubscriptionRef.set(activeSession, Option.some(session(firstClient)));
        expect(yield* Queue.take(deliveries)).toEqual(snapshot);
        yield* Queue.take(failureObserved);
        yield* SubscriptionRef.set(activeSession, Option.none());
        yield* SubscriptionRef.set(activeSession, Option.some(session(secondClient)));
        expect(yield* Queue.take(deliveries)).toEqual(secondSnapshot);
        yield* Fiber.interrupt(subscriptionFiber);
      }),
  );
  it.effect("observes unary requests until they complete", () =>
    Effect.gen(function* () {
      const observations: string[] = [];

      const client = testRpcClient({
        [WS_METHODS.serverProbe]: () => Effect.succeed({}),
      });

      const { activeSession, supervisor } = yield* makeHarness();
      yield* SubscriptionRef.set(activeSession, Option.some(session(client)));

      const result = yield* request(WS_METHODS.serverProbe, {}).pipe(
        Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
        Effect.provideService(
          EnvironmentRpcRequestObserver,
          EnvironmentRpcRequestObserver.of({
            observe: ({ environmentId, method }) =>
              Effect.sync(() => {
                observations.push(`start:${environmentId}:${method}`);

                return Effect.sync(() => {
                  observations.push(`finish:${environmentId}:${method}`);
                });
              }),
          }),
        ),
      );

      expect(result).toEqual({});
      expect(observations).toEqual([
        `start:${TARGET.environmentId}:${WS_METHODS.serverProbe}`,
        `finish:${TARGET.environmentId}:${WS_METHODS.serverProbe}`,
      ]);
    }),
  );

  it.effect("binds finite streaming commands to one active session", () =>
    Effect.gen(function* () {
      const firstEvents = yield* Queue.unbounded<ServerSelfUpdateProgressEvent>();
      const secondEvents = yield* Queue.unbounded<ServerSelfUpdateProgressEvent>();

      const firstClient = testRpcClient({
        [WS_METHODS.serverUpdateServerWithProgress]: () => Stream.fromQueue(firstEvents),
      });

      const secondClient = testRpcClient({
        [WS_METHODS.serverUpdateServerWithProgress]: () => Stream.fromQueue(secondEvents),
      });

      const { activeSession, supervisor } = yield* makeHarness();

      yield* SubscriptionRef.set(activeSession, Option.some(session(firstClient)));

      const resultFiber = yield* runStream(WS_METHODS.serverUpdateServerWithProgress, {
        targetVersion: "1.2.3",
      }).pipe(
        Stream.take(2),
        Stream.runCollect,
        Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
        Effect.forkChild,
      );

      yield* Effect.yieldNow;

      yield* Queue.offer(firstEvents, UPDATE_DOWNLOADING);
      yield* SubscriptionRef.set(activeSession, Option.some(session(secondClient)));
      yield* Queue.offer(secondEvents, UPDATE_INSTALLING);
      yield* Queue.offer(firstEvents, UPDATE_INSTALLING);

      expect(yield* Fiber.join(resultFiber)).toEqual([UPDATE_DOWNLOADING, UPDATE_INSTALLING]);
    }),
  );

  it.effect("switches durable subscriptions when the supervisor replaces the session", () =>
    Effect.gen(function* () {
      const subscriptions: string[] = [];

      const firstClient = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () => {
          subscriptions.push("first");

          return Stream.never;
        },
      });

      const secondClient = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () => {
          subscriptions.push("second");

          return Stream.never;
        },
      });

      const { activeSession, retryCount, supervisor } = yield* makeHarness();

      const awaitSubscriptions = Effect.fn("TestEnvironmentRpc.awaitSubscriptions")(function* (
        count: number,
      ) {
        for (let attempt = 0; attempt < 100; attempt += 1) {
          if (subscriptions.length >= count) {
            return;
          }

          yield* Effect.yieldNow;
        }

        return yield* Effect.die(new Error(`Expected ${count} durable subscriptions.`));
      });

      const subscriptionFiber = yield* subscribe(WS_METHODS.subscribeServerLifecycle, {}).pipe(
        Stream.runDrain,
        Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
        Effect.forkChild,
      );

      yield* SubscriptionRef.set(activeSession, Option.some(session(firstClient)));
      yield* awaitSubscriptions(1);
      yield* SubscriptionRef.set(activeSession, Option.some(session(secondClient)));
      yield* awaitSubscriptions(2);
      yield* Fiber.interrupt(subscriptionFiber);

      expect(subscriptions).toEqual(["first", "second"]);
      expect(yield* Ref.get(retryCount)).toBe(0);
    }),
  );

  it.effect("keeps durable subscriptions alive across a transport failure and new session", () =>
    Effect.gen(function* () {
      const subscriptions: string[] = [];

      const firstClient = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () => {
          subscriptions.push("first");

          return Stream.fail(
            new RpcClientError.RpcClientError({
              reason: new RpcClientError.RpcClientDefect({
                message: "socket closed",
                cause: new Error("socket closed"),
              }),
            }),
          );
        },
      });

      const secondClient = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () => {
          subscriptions.push("second");

          return Stream.never;
        },
      });

      const { activeSession, retryCount, supervisor } = yield* makeHarness();

      const subscriptionFiber = yield* subscribe(WS_METHODS.subscribeServerLifecycle, {}).pipe(
        Stream.runDrain,
        Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
        Effect.forkChild,
      );

      yield* SubscriptionRef.set(activeSession, Option.some(session(firstClient)));

      for (let attempt = 0; attempt < 100 && subscriptions.length < 1; attempt += 1) {
        yield* Effect.yieldNow;
      }

      yield* SubscriptionRef.set(activeSession, Option.none());
      yield* SubscriptionRef.set(activeSession, Option.some(session(secondClient)));

      for (let attempt = 0; attempt < 100 && subscriptions.length < 2; attempt += 1) {
        yield* Effect.yieldNow;
      }

      yield* Fiber.interrupt(subscriptionFiber);

      expect(subscriptions).toEqual(["first", "second"]);
      expect(yield* Ref.get(retryCount)).toBe(0);
    }),
  );

  it.effect("surfaces domain subscription failures without reconnecting", () =>
    Effect.gen(function* () {
      const domainError = new Error("terminal subscription rejected");

      const client = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () => Stream.fail(domainError),
      });

      const { activeSession, retryCount, supervisor } = yield* makeHarness();

      yield* SubscriptionRef.set(activeSession, Option.some(session(client)));

      const error = yield* subscribe(WS_METHODS.subscribeServerLifecycle, {}).pipe(
        Stream.runDrain,
        Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
        Effect.flip,
      );

      expect(error).toBe(domainError);
      expect(yield* Ref.get(retryCount)).toBe(0);
    }),
  );

  it.effect("keeps handled domain failures dormant until a replacement session arrives", () =>
    Effect.gen(function* () {
      const domainError = new Error("terminal subscription rejected");
      const subscriptions: string[] = [];
      const observedFailures: Error[] = [];

      const firstClient = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () => {
          subscriptions.push("first");

          return Stream.fail(domainError);
        },
      });

      const secondClient = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () => {
          subscriptions.push("second");

          return Stream.never;
        },
      });

      const { activeSession, retryCount, supervisor } = yield* makeHarness();

      yield* SubscriptionRef.set(activeSession, Option.some(session(firstClient)));

      const subscriptionFiber = yield* subscribe(
        WS_METHODS.subscribeServerLifecycle,
        {},
        {
          onExpectedFailure: (cause) =>
            Effect.sync(() => {
              observedFailures.push(Cause.squash(cause) as Error);
            }),
        },
      ).pipe(
        Stream.runDrain,
        Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
        Effect.forkChild,
      );

      for (let attempt = 0; attempt < 100 && observedFailures.length < 1; attempt += 1) {
        yield* Effect.yieldNow;
      }

      expect(subscriptions).toEqual(["first"]);
      expect(observedFailures).toEqual([domainError]);

      yield* SubscriptionRef.set(activeSession, Option.some(session(secondClient)));

      for (let attempt = 0; attempt < 100 && subscriptions.length < 2; attempt += 1) {
        yield* Effect.yieldNow;
      }

      yield* Fiber.interrupt(subscriptionFiber);

      expect(subscriptions).toEqual(["first", "second"]);
      expect(yield* Ref.get(retryCount)).toBe(0);
    }),
  );

  it.effect("retries handled domain failures within the same session when configured", () =>
    Effect.gen(function* () {
      const domainError = new Error("thread not found yet");
      const subscriptionCount = yield* Ref.make(0);
      const expectedFailureCount = yield* Ref.make(0);

      const client = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () =>
          Stream.unwrap(
            Ref.getAndUpdate(subscriptionCount, (count) => count + 1).pipe(
              Effect.map((count) => (count === 0 ? Stream.fail(domainError) : Stream.never)),
            ),
          ),
      });

      const { activeSession, supervisor } = yield* makeHarness();

      yield* SubscriptionRef.set(activeSession, Option.some(session(client)));

      const subscriptionFiber = yield* subscribe(
        WS_METHODS.subscribeServerLifecycle,
        {},
        {
          onExpectedFailure: () => Ref.update(expectedFailureCount, (count) => count + 1),
          retryExpectedFailureAfter: "100 millis",
        },
      ).pipe(
        Stream.runDrain,
        Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
        Effect.forkChild,
      );

      for (let attempt = 0; attempt < 100; attempt += 1) {
        if ((yield* Ref.get(expectedFailureCount)) >= 1) {
          break;
        }

        yield* Effect.yieldNow;
      }

      expect(yield* Ref.get(subscriptionCount)).toBe(1);
      expect(yield* Ref.get(expectedFailureCount)).toBe(1);

      yield* TestClock.adjust("100 millis");

      for (let attempt = 0; attempt < 100; attempt += 1) {
        if ((yield* Ref.get(subscriptionCount)) >= 2) {
          break;
        }

        yield* Effect.yieldNow;
      }

      yield* Fiber.interrupt(subscriptionFiber);

      expect(yield* Ref.get(subscriptionCount)).toBe(2);
      expect(yield* Ref.get(expectedFailureCount)).toBe(1);
    }),
  );

  it.effect("does not classify subscription defects as expected failures", () =>
    Effect.gen(function* () {
      const defect = new Error("subscription invariant failed");
      let expectedFailureCount = 0;

      const client = testRpcClient({
        [WS_METHODS.subscribeServerLifecycle]: () => Stream.die(defect),
      });

      const { activeSession, supervisor } = yield* makeHarness();

      yield* SubscriptionRef.set(activeSession, Option.some(session(client)));

      const exit = yield* subscribe(
        WS_METHODS.subscribeServerLifecycle,
        {},
        {
          onExpectedFailure: () =>
            Effect.sync(() => {
              expectedFailureCount += 1;
            }),
        },
      ).pipe(
        Stream.runDrain,
        Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
        Effect.exit,
      );

      expect(Exit.isFailure(exit)).toBe(true);

      if (Exit.isFailure(exit)) {
        expect(Cause.hasDies(exit.cause)).toBe(true);
      }

      expect(expectedFailureCount).toBe(0);
    }),
  );
});