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// Register one agent per Codex account. The default is visible immediately;
// the remaining accounts follow the same legacy/storage/environment sequence.
import type { PluginServices } from "convergence/effect";
import * as Queue from "effect/Queue";
import * as Effect from "effect/Effect";
import * as Scope from "effect/Scope";
import { Agents, Env, Host, Plugin, runPlugin } from "convergence/effect";
import { RpcTransport } from "../sdk/effect.ts";
import { CodexAgent } from "./agent.ts";
import { defaultAccount, parseInstances } from "./instances.ts";
import type { Instance } from "./instances.ts";
import { adoptLegacy, legacyDir } from "./legacy.ts";

const loginEnv = Effect.fn("Codex.loginEnv")(function* () {
  const env = yield* Env;
  const values: Record<string, string> = {};
  for (const name of ["HOME", "CODEX_HOME", "CODEX_ARGS"]) {
    const value = yield* env.get(name).pipe(
      Effect.catchTag(["HostCallFailed", "PermissionNotGranted", "NeedsReview"], (error) =>
        Effect.sync(() => {
          console.warn(`codex: reading ${name} failed: ${error.message}`);
          return null;
        }),
      ),
    );
    if (typeof value === "string" && value) values[name] = value;
  }
  return values;
});

// The optional collection exposes the accounts to lifecycle tests; the entry
// point uses exactly the same program without retaining another copy of state.
export const registerAccounts = Effect.fn("Codex.registerAccounts")(function* (accounts: CodexAgent[] = []) {
  const agents = yield* Agents;
  const scope = yield* Scope.Scope;
  const transport = yield* RpcTransport;
  const plugin = yield* Plugin;
  const host = yield* Host;
  const env = yield* Effect.cached(loginEnv());
  const register = Effect.fn("Codex.register")(function* (instance: Instance) {
    const jobs = yield* Effect.acquireRelease(
      Queue.make<Effect.Effect<unknown, unknown, PluginServices>>(),
      Queue.shutdown,
    );
    const agent = new CodexAgent({ instance, scope, transport, jobs });
    const handle = yield* agents.register(agent.definition(env));
    agent.emit = handle.emit;
    accounts.push(agent);
    yield* agent.background();
  });
  yield* register(defaultAccount());
  yield* Effect.all(
    [
      env,
      Effect.gen(function* () {
        yield* adoptLegacy(legacyDir(plugin.api));
        const stored = yield* host.call("host/storage.get", { key: "instances" }).pipe(
          Effect.catchTag(["HostCallFailed", "PermissionNotGranted", "NeedsReview"], (error) =>
            Effect.sync(() => {
              console.warn(`codex: the stored accounts could not be read: ${error.message}`);
              return { value: null };
            }),
          ),
        );
        for (const instance of parseInstances(stored.value).slice(1)) yield* register(instance);
      }),
    ],
    { concurrency: "unbounded" },
  );
});

export const activate = runPlugin(RpcTransport.layer, registerAccounts());