opencode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74// Scripted scenarios for the opencode conversion.
import { test } from "node:test";
import assert from "node:assert/strict";
import * as Effect from "effect/Effect";
import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { liveLayer } from "convergence/effect";
import type { Api } from "convergence";
import { activate } from "./main.ts";
import { adoptLegacy as adoptLegacyEffect, legacyDir, mergeInstances } from "./legacy.ts";
import type { HostScript } from "../sdk/testing.ts";
import { diskFs, fakeApi, memoryStorage, settle } from "../sdk/testing.ts";

async function dataFolder(instances: string) {
  const data = await mkdtemp(join(tmpdir(), "opencode-legacy-"));
  await mkdir(join(data, "legacy"), { recursive: true });
  await writeFile(join(data, "legacy", "instances.json"), instances);
  return data;
}

function apiWith(data: string, storage: HostScript, fs = diskFs()) {
  const api = fakeApi({ onHost: storage, fs });
  api.paths = { data };
  return api;
}

test("the entry without an id counts as one id: the stored one wins", () => {
  assert.deepEqual(mergeInstances([{ name: "Mine" }], [{ name: "Old" }, { id: "team" }]), [
    { name: "Mine" },
    { id: "team" },
  ]);
  assert.deepEqual(mergeInstances(null, [{ command: "~/bin/opencode" }]), [{ command: "~/bin/opencode" }]);
});

test("the Rust plugin's servers register, taken into storage once", async (t) => {
  const data = await dataFolder(
    JSON.stringify([{ id: "team", name: "OpenCode (team)", serverUrl: "https://oc.example:4096" }]),
  );
  const storage = memoryStorage({ instances: [{ id: "", name: "My OpenCode" }] });
  const api = apiWith(data, storage);
  t.after(activate(api));
  await settle(20);
  assert.deepEqual(
    api.registered.map((def) => def.id),
    ["opencode", "opencode:team"],
  );
  assert.deepEqual(
    (storage.values.get("instances") as { id: string }[]).map((entry) => entry.id),
    ["", "team"],
  );
  await writeFile(join(data, "legacy", "instances.json"), JSON.stringify([{ id: "late" }]));
  assert.equal(await adoptLegacy(api), false, "read once");
});

test("a refused read is tried again at the next load", async () => {
  const data = await dataFolder("[]");
  const refused = memoryStorage();
  assert.equal(await adoptLegacy(apiWith(data, refused, diskFs({ allow: () => false }))), false);
  assert.equal(refused.values.has("legacy"), false);
});

const adoptLegacy = (api: Api) =>
  Effect.runPromise(
    adoptLegacyEffect(legacyDir(api)).pipe(
      Effect.provide(
        liveLayer(
          api,
          () => Promise.reject(new Error("unexpected handler")),
          () => {},
        ),
      ),
    ),
  );