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.

7.9 KB
Raw Blame
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Exit from "effect/Exit";
import * as Scope from "effect/Scope";
import * as Queue from "effect/Queue";
import * as Stream from "effect/Stream";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import * as CodexError from "./errors.ts";
import * as CodexProtocol from "./protocol.ts";
import { makeInMemoryStdio } from "./_internal/stdio.ts";
import { encoder, encodeJsonl, decodeJson } from "./protocol.test-support.ts";

it.layer(NodeServices.layer)("effect-codex-app-server protocol", (it) => {
  for (const bufferSize of [undefined, 0, 8] as const) {
    it.effect(
      `bounds callback-only raw retention with buffer size ${bufferSize ?? "default"}`,
      () =>
        Effect.gen(function* () {
          const { stdio, input, output } = yield* makeInMemoryStdio();
          const terminated = yield* Deferred.make<void>();
          const count = 10_000;
          const text = "x".repeat(1024);
          let notificationCount = 0;
          let requestCount = 0;

          const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({
            stdio,
            ...(bufferSize === undefined
              ? {}
              : {
                  rawNotificationBufferSize: bufferSize,
                  rawRequestBufferSize: bufferSize,
                }),
            onNotification: () =>
              Effect.sync(() => {
                notificationCount++;
              }),
            onRequest: (request) =>
              Effect.suspend(() => {
                requestCount++;

                return request.id === 0
                  ? Effect.fail(
                      CodexError.CodexAppServerRequestError.methodNotFound(request.method),
                    )
                  : Effect.succeed({ ok: true });
              }),
            onTermination: () => Deferred.succeed(terminated, undefined).pipe(Effect.asVoid),
          });

          for (let index = 0; index < count; index++) {
            yield* Queue.offer(input, encodeJsonl({ method: "x/stress", params: { index, text } }));
            yield* Queue.offer(
              input,
              encodeJsonl({ id: index, method: "x/request", params: { text } }),
            );
          }

          for (let index = 0; index < count; index++) {
            assert.deepEqual(
              yield* decodeJson(yield* Queue.take(output)),
              index === 0
                ? {
                    id: 0,
                    error: { code: -32601, message: "Method not found: x/request" },
                  }
                : { id: index, result: { ok: true } },
            );
          }

          yield* Queue.end(input);
          yield* Deferred.await(terminated);

          assert.equal(notificationCount, count);
          assert.equal(requestCount, count);
          const notifications = yield* Stream.runCollect(transport.incomingNotifications);
          const requests = yield* Stream.runCollect(transport.incomingRequests);

          const retainedIndexes = Array.from(
            { length: bufferSize ?? 0 },
            (_, offset) => count - (bufferSize ?? 0) + offset,
          );

          assert.deepEqual(
            notifications.map((notification) => notification.params),
            retainedIndexes.map((index) => ({ index, text })),
          );
          assert.deepEqual(
            requests.map((request) => request.id),
            retainedIndexes,
          );
          assert.deepEqual(yield* Queue.clear(output), []);
          assert.deepEqual(yield* Stream.runCollect(transport.incomingNotifications), []);
          assert.deepEqual(yield* Stream.runCollect(transport.incomingRequests), []);
        }),
    );
  }

  it.effect("preserves opt-in late replay after raw readers are interrupted", () =>
    Effect.gen(function* () {
      const { stdio, input } = yield* makeInMemoryStdio();
      const notificationObserved = yield* Deferred.make<void>();
      const requestObserved = yield* Deferred.make<void>();
      const terminated = yield* Deferred.make<void>();

      const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({
        stdio,
        rawNotificationBufferSize: "unbounded",
        rawRequestBufferSize: "unbounded",
        onTermination: () => Deferred.succeed(terminated, undefined).pipe(Effect.asVoid),
      });

      const notificationReader = yield* transport.incomingNotifications.pipe(
        Stream.runForEach(() =>
          Deferred.succeed(notificationObserved, undefined).pipe(Effect.andThen(Effect.never)),
        ),
        Effect.forkScoped,
      );

      const requestReader = yield* transport.incomingRequests.pipe(
        Stream.runForEach(() =>
          Deferred.succeed(requestObserved, undefined).pipe(Effect.andThen(Effect.never)),
        ),
        Effect.forkScoped,
      );

      yield* Queue.offer(input, encodeJsonl({ method: "x/first" }));
      yield* Queue.offer(input, encodeJsonl({ id: 1, method: "x/first" }));
      yield* Deferred.await(notificationObserved);
      yield* Deferred.await(requestObserved);
      yield* Fiber.interrupt(notificationReader);
      yield* Fiber.interrupt(requestReader);

      for (const id of [2, 3]) {
        yield* Queue.offer(input, encodeJsonl({ method: "x/next", params: id }));
        yield* Queue.offer(input, encodeJsonl({ id, method: "x/next" }));
      }

      yield* Queue.end(input);
      yield* Deferred.await(terminated);
      assert.deepEqual(
        (yield* Stream.runCollect(transport.incomingNotifications)).map(
          (notification) => notification.params,
        ),
        [2, 3],
      );
      assert.deepEqual(
        (yield* Stream.runCollect(transport.incomingRequests)).map((request) => request.id),
        [2, 3],
      );
      assert.deepEqual(yield* Stream.runCollect(transport.incomingNotifications), []);
      assert.deepEqual(yield* Stream.runCollect(transport.incomingRequests), []);
    }),
  );

  it.effect("drains raw observations and completes waiting readers on decode failure", () =>
    Effect.gen(function* () {
      const { stdio, input } = yield* makeInMemoryStdio();

      const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({
        stdio,
        rawNotificationBufferSize: 8,
        rawRequestBufferSize: 8,
      });

      const notifications = yield* transport.incomingNotifications.pipe(
        Stream.runCollect,
        Effect.forkScoped,
      );

      const requests = yield* transport.incomingRequests.pipe(Stream.runCollect, Effect.forkScoped);
      yield* Queue.offer(input, encodeJsonl({ method: "x/first" }));
      yield* Queue.offer(input, encodeJsonl({ id: 1, method: "x/first" }));
      yield* Queue.offer(input, encoder.encode("{malformed}\n"));
      assert.deepEqual(yield* Fiber.join(notifications), [{ method: "x/first" }]);
      assert.deepEqual(yield* Fiber.join(requests), [{ id: 1, method: "x/first" }]);
    }),
  );

  it.effect("interrupts raw readers outside the connection scope when it closes", () =>
    Effect.gen(function* () {
      const { stdio } = yield* makeInMemoryStdio();
      const scope = yield* Scope.make();

      const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({
        stdio,
        rawNotificationBufferSize: 8,
        rawRequestBufferSize: 8,
      }).pipe(Effect.provideService(Scope.Scope, scope));

      const notifications = yield* transport.incomingNotifications.pipe(
        Stream.runCollect,
        Effect.forkScoped({ startImmediately: true }),
      );

      const requests = yield* transport.incomingRequests.pipe(
        Stream.runCollect,
        Effect.forkScoped({ startImmediately: true }),
      );

      yield* Scope.close(scope, Exit.void);
      assert.isTrue(Exit.hasInterrupts(yield* Fiber.await(notifications)));
      assert.isTrue(Exit.hasInterrupts(yield* Fiber.await(requests)));
    }),
  );
});