sailfork / t3code-github / packages/ provider-opencode/ src/ server/ OpenCodeRuntime.inventory.test.ts

import * as NodeAssert from "node:assert/strict";

import * as NodeServices from "@effect/platform-node/NodeServices";
import { createOpencodeClient, type OpencodeClient } from "@opencode-ai/sdk/v2";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Queue from "effect/Queue";

import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
import * as OpenCodeServerLedger from "./OpenCodeServerLedger.ts";

const layerTest = OpenCodeRuntime.layer.pipe(
  Layer.provide(OpenCodeServerLedger.layerTest),
  Layer.provideMerge(NodeServices.layer),
);

it.layer(layerTest)("OpenCodeRuntime inventory", (it) => {
  it.effect("aborts pending SDK requests when inventory loading is interrupted", () =>
    Effect.gen(function* () {
      const runtime = yield* OpenCodeRuntime.OpenCodeRuntime;
      const started = yield* Queue.make<void>();
      const aborted = yield* Queue.make<string>();
      const client = createOpencodeClient({
        baseUrl: "http://opencode.test",
        fetch: Object.assign(
          (input: string | Request | URL) => {
            const request = input instanceof Request ? input : new Request(input.toString());
            return new Promise<Response>((_resolve, reject) => {
              request.signal.addEventListener(
                "abort",
                () => {
                  Queue.offerUnsafe(aborted, new URL(request.url).pathname);
                  reject(request.signal.reason);
                },
                { once: true },
              );
              Queue.offerUnsafe(started, undefined);
            });
          },
          { preconnect: () => undefined },
        ),
      });

      const inventoryFiber = yield* runtime.loadOpenCodeInventory(client).pipe(Effect.forkChild);
      yield* Queue.takeN(started, 4);
      yield* Fiber.interrupt(inventoryFiber);

      NodeAssert.deepEqual((yield* Queue.takeAll(aborted)).toSorted(), [
        "/agent",
        "/command",
        "/provider",
        "/skill",
      ]);
    }),
  );

  it.effect("discovers directory-scoped commands without retaining prompt templates", () =>
    Effect.gen(function* () {
      const runtime = yield* OpenCodeRuntime.OpenCodeRuntime;
      const requests: Request[] = [];
      const client = createOpencodeClient({
        baseUrl: "http://opencode.test",
        directory: "/workspace/project",
        fetch: Object.assign(
          async (input: string | Request | URL) => {
            const request = input instanceof Request ? input : new Request(input.toString());
            requests.push(request);
            const route = new URL(request.url).pathname;
            return Response.json(
              route === "/provider"
                ? { connected: ["openai"], all: [], default: {} }
                : route === "/command"
                  ? [
                      {
                        name: "review",
                        description: "Review changes",
                        source: "command",
                        hints: ["$ARGUMENTS"],
                        template: "private native template",
                      },
                    ]
                  : [],
            );
          },
          { preconnect: () => undefined },
        ),
      });
      const inventory = yield* runtime.loadOpenCodeInventory(client);
      NodeAssert.deepEqual(inventory.commands, [
        {
          name: "review",
          description: "Review changes",
          source: "command",
          hints: ["$ARGUMENTS"],
        },
      ]);
      const commandRequest = requests.find(
        (request) => new URL(request.url).pathname === "/command",
      );
      NodeAssert.ok(commandRequest);
      NodeAssert.equal(
        new URL(commandRequest.url).searchParams.get("directory") ??
          decodeURIComponent(commandRequest.headers.get("x-opencode-directory") ?? ""),
        "/workspace/project",
      );
    }),
  );

  it.effect("keeps provider inventory when agent discovery fails", () =>
    Effect.gen(function* () {
      const runtime = yield* OpenCodeRuntime.OpenCodeRuntime;
      const client = {
        provider: {
          list: () =>
            Promise.resolve({
              data: {
                connected: ["openai"],
                all: [],
                default: {},
              },
            }),
        },
        app: {
          agents: () => Promise.reject(new Error("agents endpoint unavailable")),
          skills: () => Promise.resolve({ data: [] }),
        },
      } as unknown as OpencodeClient;

      const inventory = yield* runtime.loadOpenCodeInventory(client);

      NodeAssert.deepEqual(inventory.providerList.connected, ["openai"]);
      NodeAssert.deepEqual(inventory.agents, []);
      NodeAssert.deepEqual(inventory.skills, []);
    }),
  );
});