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

import { assert, describe, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientError from "effect/http/HttpClientError";
import * as HttpClientRequest from "effect/http/HttpClientRequest";

import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
import {
  classifyOpenCodeCliVersion,
  makeOpenCodeRuntimeProbe,
  probeOpenCodeRuntime,
} from "./versionProbe.ts";
import {
  OPENCODE_1_RESPONSES,
  OPENCODE_2_RESPONSES,
  replayOpenCodeServer,
} from "./probeResponses.fixture.ts";

const noBinary = {
  runOpenCodeCommand: () => Effect.die("A configured server must not run the local binary"),
} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];

const probeServer = (serverUrl: string, serverPassword: string, http: HttpClient.HttpClient) =>
  probeOpenCodeRuntime({ binaryPath: "opencode", serverUrl, serverPassword }).pipe(
    Effect.provideService(HttpClient.HttpClient, http),
    Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, noBinary),
  );
const SERVER_URL = "http://127.0.0.1:4096/";

describe("OpenCode version probe", () => {
  it("classifies the recorded `opencode --version` output of both versions", () => {
    assert.deepStrictEqual(classifyOpenCodeCliVersion("1.18.32\n"), {
      generation: "v1",
      version: "1.18.32",
    });
    assert.deepStrictEqual(classifyOpenCodeCliVersion("opencode v2.0.18\n"), {
      generation: "v2",
      version: "2.0.18",
    });
    assert.isUndefined(classifyOpenCodeCliVersion("opencode dev build\n"));
  });

  it.effect("finds 2.x at /api/info without falling through to its HTML /global/health", () =>
    Effect.gen(function* () {
      const paths: Array<string> = [];
      const probed = yield* probeServer(
        SERVER_URL,
        "pw",
        replayOpenCodeServer(OPENCODE_2_RESPONSES, "pw", paths),
      );
      assert.deepStrictEqual(probed, { generation: "v2", version: "2.0.18" });
      assert.deepStrictEqual(paths, ["/api/info"]);
    }),
  );

  it.effect("skips the HTML 1.x serves at /api/info and finds it at /global/health", () =>
    Effect.gen(function* () {
      const paths: Array<string> = [];
      const probed = yield* probeServer(
        SERVER_URL,
        "pw",
        replayOpenCodeServer(OPENCODE_1_RESPONSES, "pw", paths),
      );
      assert.deepStrictEqual(probed, { generation: "v1", version: "1.18.32" });
      assert.deepStrictEqual(paths, ["/api/info", "/global/health"]);
    }),
  );

  it.effect("keeps a server URL's path prefix and query when probing", () =>
    Effect.gen(function* () {
      const urls: Array<string> = [];
      const replay = replayOpenCodeServer(OPENCODE_1_RESPONSES, "pw");
      const proxied = HttpClient.make((request, url) => {
        urls.push(url.href);
        return replay.execute(
          HttpClientRequest.setUrl(
            request,
            `http://127.0.0.1:4096${url.pathname.replace(/^\/opencode/, "")}`,
          ),
        );
      });
      const probed = yield* probeServer("http://proxy:8080/opencode/?route=oc", "pw", proxied);
      assert.strictEqual(probed.generation, "v1");
      assert.deepStrictEqual(urls, [
        "http://proxy:8080/opencode/api/info?route=oc",
        "http://proxy:8080/opencode/global/health?route=oc",
      ]);
    }),
  );

  it.effect("reports a rejected password instead of guessing a version", () =>
    Effect.gen(function* () {
      for (const responses of [OPENCODE_1_RESPONSES, OPENCODE_2_RESPONSES]) {
        const paths: Array<string> = [];
        const error = yield* Effect.flip(
          probeServer(SERVER_URL, "wrong", replayOpenCodeServer(responses, "pw", paths)),
        );
        assert.match(error.detail, /401 Unauthorized/);
        assert.deepStrictEqual(paths, ["/api/info"]);
      }
    }),
  );

  it.effect("sends a non-ASCII password as UTF-8, as both versions expect", () =>
    Effect.gen(function* () {
      for (const [responses, password, generation] of [
        [OPENCODE_1_RESPONSES, "pässwörd", "v1"],
        [OPENCODE_2_RESPONSES, "pass€word", "v2"],
      ] as const) {
        const probed = yield* probeServer(
          SERVER_URL,
          password,
          replayOpenCodeServer(responses, password),
        );
        assert.strictEqual(probed.generation, generation);
      }
    }),
  );

  it.effect("does not take other JSON at /api/info for OpenCode 2", () =>
    Effect.gen(function* () {
      const impostor = {
        ...OPENCODE_1_RESPONSES,
        "/api/info": { status: 200, contentType: "application/json", body: '{"version":"3.4.1"}' },
        "/global/health": OPENCODE_1_RESPONSES["/api/info"],
      };
      const error = yield* Effect.flip(
        probeServer(SERVER_URL, "pw", replayOpenCodeServer(impostor, "pw")),
      );
      assert.match(error.detail, /did not identify itself as OpenCode/);
    }),
  );

  it.effect("never puts the configured URL or its credentials in an error detail", () =>
    Effect.gen(function* () {
      const secret = "userinfo-secret";
      const unreachable = HttpClient.make((request) =>
        Effect.die(`should not be reached for ${request.url}`),
      );
      // A fetch failure that echoes the full request URL, as Node's does.
      const refused = HttpClient.make((request) =>
        Effect.fail(
          new HttpClientError.HttpClientError({
            reason: new HttpClientError.TransportError({
              request,
              description: `connect ECONNREFUSED ${request.url}`,
            }),
          }),
        ),
      );
      for (const [serverUrl, http] of [
        [`127.0.0.1:4096?token=${secret}`, unreachable],
        [`localhost:4096/${secret}`, unreachable],
        [`http://user:${secret}@10.0.0.1:4096/?token=${secret}`, refused],
      ] as const) {
        const error = yield* Effect.flip(probeServer(serverUrl, secret, http));
        assert.notInclude(error.detail, secret, serverUrl);
        assert.notInclude(error.detail, "10.0.0.1", serverUrl);
      }
    }),
  );

  it.effect("remembers a probed 2.x runtime but re-probes 1.x and failures", () =>
    Effect.gen(function* () {
      const outputs = ["", "opencode v2.0.18\n", "1.18.32\n", "1.18.32\n"];
      let calls = 0;
      const runtime = {
        runOpenCodeCommand: () => {
          const stdout = outputs[calls++];
          return stdout
            ? Effect.succeed({ stdout, stderr: "", code: 0 })
            : Effect.fail(
                new OpenCodeRuntime.OpenCodeRuntimeError({ operation: "spawn", detail: "ENOENT" }),
              );
        },
      } as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
      const probe = yield* makeOpenCodeRuntimeProbe(
        probeOpenCodeRuntime({ binaryPath: "opencode", serverUrl: "", serverPassword: "" }).pipe(
          Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
          Effect.provideService(
            HttpClient.HttpClient,
            HttpClient.make(() => Effect.die("A local binary must not be probed over HTTP")),
          ),
        ),
      );

      yield* Effect.flip(probe.get);
      assert.isTrue((yield* probe.lastSuccess)._tag === "None");
      assert.strictEqual((yield* probe.get).generation, "v2");
      assert.strictEqual((yield* probe.get).generation, "v2");
      assert.strictEqual(calls, 2);
      assert.strictEqual((yield* probe.refresh).generation, "v1");
      assert.strictEqual(calls, 3);
      assert.strictEqual((yield* probe.get).generation, "v1");
      assert.strictEqual(calls, 4);
    }),
  );
});