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// Adopt the Rust provider's stored accounts once, keeping permission
// refusals retryable and merging entries without changing their contents.
import * as Effect from "effect/Effect";
import * as Result from "effect/Result";
import * as z from "zod";
import { Fs, Host } from "convergence/effect";

const MARK = "legacy";
const entry = z.object({ id: z.unknown().optional() });
export function legacyDir(api: { paths?: { data?: string | null } }): string | null {
  const data = api.paths?.data;
  return typeof data === "string" && data ? `${data.replace(/\/+$/, "")}/legacy` : null;
}
const idOf = (value: unknown) => {
  const parsed = entry.safeParse(value);
  return parsed.success && typeof parsed.data.id === "string" ? parsed.data.id.trim() : "";
};
export function mergeInstances(stored: unknown, legacy: unknown): unknown[] | null {
  if (!Array.isArray(legacy)) return null;
  const current: unknown[] = Array.isArray(stored) ? stored : [];
  const ids = new Set(current.map(idOf));
  const added = legacy.filter((value: unknown) => {
    const id = idOf(value);
    if (!value || typeof value !== "object" || ids.has(id)) return false;
    ids.add(id);
    return true;
  });
  return added.length ? [...current, ...added] : null;
}
export const adoptLegacy = Effect.fn("Codex.adoptLegacy")(function* (dir: string | null) {
  if (!dir) return false;
  const host = yield* Host;
  const fs = yield* Fs;
  const result = yield* Effect.result(
    Effect.gen(function* () {
      if ((yield* host.call("host/storage.get", { key: MARK })).value) return false;
      // Missing files were optional; a permission refusal leaves the migration unmarked.
      const text = yield* fs
        .read(`${dir}/instances.json`)
        .pipe(Effect.catchTag("HostCallFailed", () => Effect.succeed(null)));
      let changed = false;
      if (text !== null) {
        let legacy: unknown = null;
        try {
          legacy = JSON.parse(text);
        } catch {
          console.warn(`codex: ${dir}/instances.json is not JSON; it is left out`);
        }
        const merged = mergeInstances(
          (yield* host.call("host/storage.get", { key: "instances" })).value ?? null,
          legacy,
        );
        if (merged) {
          yield* host.call("host/storage.set", { key: "instances", value: merged });
          changed = true;
          console.info("codex: took the Rust plugin's accounts");
        }
      }
      yield* host.call("host/storage.set", { key: MARK, value: { at: Date.now() } });
      return changed;
    }),
  );
  if (Result.isSuccess(result)) return result.success;
  console.warn(`codex: the Rust plugin's files could not be read: ${result.failure.message}`);
  return false;
});