codex

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
75// Scripted scenarios for the codex conversion.
import { test } from "node:test";
import assert from "node:assert/strict";
import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { activate } from "./main.ts";
import * as Effect from "effect/Effect";
import { liveLayer } from "convergence/effect";
import type { Api } from "convergence";
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(), "codex-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 stored accounts keep theirs and gain the legacy ones they lack", () => {
  assert.deepEqual(mergeInstances([{ id: "a", name: "Mine" }], [{ id: "a", name: "Old" }, { id: "b" }]), [
    { id: "a", name: "Mine" },
    { id: "b" },
  ]);
  assert.equal(mergeInstances(null, { id: "a" }), null, "not a list");
});

test("the Rust plugin's accounts register, taken into storage once", async (t) => {
  const data = await dataFolder(JSON.stringify([{ id: "work", name: "Codex Work", home: "~/.codex_work" }]));
  const storage = memoryStorage();
  const api = apiWith(data, storage);
  t.after(activate(api));
  await settle(20);
  assert.deepEqual(
    api.registered.map((def) => def.id),
    ["codex", "codex:work"],
  );
  assert.deepEqual(storage.values.get("instances"), [{ id: "work", name: "Codex Work", home: "~/.codex_work" }]);
  assert.ok(storage.values.get("legacy"));
  await writeFile(join(data, "legacy", "instances.json"), JSON.stringify([{ id: "late" }]));
  assert.equal(await adoptLegacy(api), false, "read once");
});

test("a broken file is left out, a refused read is tried again", async () => {
  const data = await dataFolder("{ not json");
  const storage = memoryStorage();
  assert.equal(await adoptLegacy(apiWith(data, storage)), false);
  assert.equal(storage.values.has("instances"), false);
  assert.ok(storage.values.get("legacy"));

  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")),
          () => {},
        ),
      ),
    ),
  );