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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109// Scripted scenarios for the codex conversion.
import { test } from "node:test";
import assert from "node:assert/strict";
import { runPlugin } from "convergence/effect";
import { RpcTransport } from "../sdk/effect.ts";
import type { CodexAgent } from "./agent.ts";
import { registerAccounts } from "./main.ts";
import { fakeApi, settle } from "../sdk/testing.ts";

test("the default account registers at once, stored accounts after", async (t) => {
  const api = fakeApi({
    env: { HOME: "/Users/me", CODEX_ARGS: "-c model=o3" },
    onHost: (method, params) => {
      if (method === "host/storage.get") {
        assert.equal(params.key, "instances");
        return { value: [{ id: "work", name: "Codex Work", home: "~/.codex_work", args: ["-c", "x=1"] }] };
      }
      return {};
    },
  });
  const agents: CodexAgent[] = [];
  const dispose = runPlugin(RpcTransport.layer, registerAccounts(agents))(api);
  t.after(dispose);
  assert.deepEqual(
    api.registered.map((def) => def.id),
    ["codex"],
    "registered before anything is awaited",
  );
  await settle();
  assert.deepEqual(
    api.registered.map((def) => [def.id, def.name]),
    [
      ["codex", "Codex"],
      ["codex:work", "Codex Work"],
    ],
  );
  // The runtime tells the host of agents registered after the load.
  assert.equal(
    api.hostCalls.some((call) => call.method === "host/agents.changed"),
    false,
  );

  // The environment reaches the account before its first call.
  const work = agents[1];
  const definition = api.registered[1];
  api.process.spawn = async (program, args, options) => {
    throw Object.assign(new Error(`stop here: ${JSON.stringify({ program, args, options })}`), { name: "Stop" });
  };
  await assert.rejects(
    Promise.resolve(
      present(definition.initialize)({ agentId: definition.id }, { agentId: definition.id, emit: () => {} }),
    ),
    (error: unknown) => {
      assert.ok(error instanceof Error);
      assert.match(error.message, /"args":\["app-server","-c","model=o3","-c","x=1"\]/);
      assert.match(error.message, /"CODEX_HOME":"\/Users\/me\/.codex_work"/);
      return true;
    },
  );
  assert.equal(work.env.HOME, "/Users/me");

  // Events an agent emits go out under its own id.
  work.emit({ sessionId: "s", event: "run_finished", outcome: { status: "completed" } });
  assert.equal(present(api.emitted.at(-1)).agentId, "codex:work");
});

test("without stored accounts only the default one is served", async (t) => {
  const api = fakeApi({ onHost: () => ({ value: null }) });
  const dispose = runPlugin(RpcTransport.layer, registerAccounts())(api);
  t.after(dispose);
  await settle();
  assert.deepEqual(
    api.registered.map((def) => def.id),
    ["codex"],
  );
  assert.equal(
    api.hostCalls.some((call) => call.method === "host/agents.changed"),
    false,
  );
});

test("an environment the plugin may not read leaves the defaults", async (t) => {
  const api = fakeApi({ onHost: () => ({ value: null }) });
  api.env.get = async (t) => {
    throw Object.assign(new Error("PermissionNotGranted"), { name: "PermissionNotGranted" });
  };
  const agents: CodexAgent[] = [];
  const dispose = runPlugin(RpcTransport.layer, registerAccounts(agents))(api);
  t.after(dispose);
  const definition = api.registered[0];
  api.process.spawn = async (t) => {
    throw new Error("not here");
  };
  await assert.rejects(
    Promise.resolve(
      present(definition.list_options)(
        { agentId: definition.id, workspace: "/w" },
        { agentId: definition.id, emit: () => {} },
      ),
    ),
    /could not be started/,
  );
  assert.deepEqual(agents[0].env, {});
});

function present<T>(value: T | null | undefined): T {
  assert.ok(value != null);
  return value;
}