@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
396 lines (366 loc) • 17.6 kB
text/typescript
import { OCX_SECTION_MARKER } from "../injected-marker";
import { encodeBasicString, lexicalLineStarts, matchKeyHead } from "./encoding";
import { TABLE_HEADER, ANY_DEV_INSTRUCTIONS, DEV_INSTRUCTIONS_KEY } from "./toml-read";
/** Line editing, not re-serialization: the user's comments and layout survive. */
export function dominantEol(content: string): "\r\n" | "\n" {
const crlf = (content.match(/\r\n/g) ?? []).length;
if (crlf === 0) return "\n";
const bareLf = (content.match(/\n/g) ?? []).length - crlf;
return crlf >= bareLf ? "\r\n" : "\n";
}
function splitLines(content: string): string[] {
return content.replace(/\r\n/g, "\n").split("\n");
}
/**
* A leading UTF-8 BOM, split off so line editing never steps over it.
*
* Codex reads config.toml with Rust `toml_edit`, which accepts a BOM at byte 0 and
* nowhere else. Inserting the generated block at line index 0 pushed the BOM down
* to byte 58, the write reported success because our own byte comparison matched
* what we intended to write, and the next parse failed with
* "Expected a key but found (0xEF)" — a config file the user could no longer load,
* produced by a write that told them it worked.
*
* Editors on Windows write this byte routinely, so the file is not exotic.
*/
function splitBom(content: string): { bom: string; body: string } {
return content.startsWith("\ufeff")
? { bom: "\ufeff", body: content.slice(1) }
: { bom: "", body: content };
}
function joinLines(lines: string[], eol: "\r\n" | "\n"): string {
const text = lines.join("\n");
return eol === "\n" ? text : text.replace(/\n/g, "\r\n");
}
function firstTableIndex(lines: string[], starts?: readonly boolean[]): number {
const idx = lines.findIndex((l, i) => (starts === undefined || starts[i] === true) && TABLE_HEADER.test(l));
return idx === -1 ? lines.length : idx;
}
/**
* Raised when a recognized `key =` line carries a value a line editor cannot
* replace safely — a multi-line `"""…"""`/`'''…'''` span, an unterminated
* quote, or trailing junk that is neither value nor comment. Callers refuse
* BEFORE writing rather than splice over a span they cannot see the end of.
*/
export class UnsupportedTomlForm extends Error {
constructor(readonly line: string) {
super(`unsupported TOML value form: ${line.trim()}`);
this.name = "UnsupportedTomlForm";
}
}
/** Where `<key> =` ends and the value begins. `prefix` keeps indent and key quoting. */
interface AssignmentHead {
prefix: string;
rest: string;
}
/**
* Lexical line scope for the editors below (see `lexicalLineStarts`). A span
* that never closes means the scope of every later line is unknown, so the
* whole edit refuses instead of guessing.
*/
function scopedLineStarts(lines: readonly string[]): boolean[] {
const starts = lexicalLineStarts(lines);
if (starts === null) throw new UnsupportedTomlForm("configuration contains an unterminated string or composite value");
return starts;
}
/**
* Split `rest` (everything after `key =`) into the value token and a trailing
* `#…` comment — adjacent or whitespace-separated, both preserved.
*
* The scan is string-aware so a `#` inside a quoted value is never mistaken
* for a comment opener: `"a#b" # note` parses as value `"a#b"` + comment
* ` # note`, while `false# note` parses as `false` + `# note`. Anything the
* token scan cannot classify — a multi-line string opener, an unterminated
* quote, text after the value that is not a comment — throws
* UnsupportedTomlForm so the caller refuses rather than guesses a span.
*/
function splitValueComment(head: AssignmentHead, line: string): { value: string; comment: string } {
const { rest } = head;
if (rest.startsWith('"""') || rest.startsWith("'''")) throw new UnsupportedTomlForm(line);
let value: string;
const first = rest[0];
if (first === '"') {
// Basic string: an escaped quote does not close, an unterminated one refuses.
let i = 1;
while (i < rest.length && rest[i] !== '"') i += rest[i] === "\\" ? 2 : 1;
if (i >= rest.length) throw new UnsupportedTomlForm(line);
value = rest.slice(0, i + 1);
} else if (first === "'") {
// Literal string: no escapes, the next ' closes it.
const end = rest.indexOf("'", 1);
if (end === -1) throw new UnsupportedTomlForm(line);
value = rest.slice(0, end + 1);
} else {
// Composite values may continue onto another line. This scalar editor
// refuses them instead of replacing only their opener and orphaning the tail.
if (first === "[" || first === "{") throw new UnsupportedTomlForm(line);
const m = /^[^\s#]+/.exec(rest);
if (!m) throw new UnsupportedTomlForm(line);
value = m[0];
}
const tail = rest.slice(value.length);
if (tail !== "" && !/^\s*(?:#|$)/.test(tail)) throw new UnsupportedTomlForm(line);
return { value, comment: tail };
}
/**
* The shape of `key`'s root-scope assignment, or "absent". "unsupported" means
* a `key =` line was found but its value is a form the line editor refuses —
* multiline strings and the like — so a caller can fail BEFORE touching disk
* instead of inside the transaction.
*/
export function rootKeyValueForm(content: string, key: string): "absent" | "simple" | "unsupported" {
const { body } = splitBom(content);
const lines = splitLines(body);
let starts: boolean[];
try { starts = scopedLineStarts(lines); } catch { return "unsupported"; }
const limit = firstTableIndex(lines, starts);
for (let i = 0; i < limit; i += 1) {
if (!starts[i]) continue;
const head = matchKeyHead(lines[i]!, key);
if (!head) continue;
try {
splitValueComment(head, lines[i]!);
return "simple";
} catch {
return "unsupported";
}
}
return "absent";
}
/**
* Replace or remove one matched line. The line's own indentation, key quoting,
* and trailing comment are preserved; `null` removes the assignment but keeps
* a comment behind so a `# note` written beside the key survives a reset.
*/
function applyLineEdit(lines: string[], i: number, key: string, replacement: string | null): void {
const head = matchKeyHead(lines[i]!, key)!;
const { comment } = splitValueComment(head, lines[i]!);
if (replacement === null) {
if (comment.trim()) lines[i] = comment.trim();
else lines.splice(i, 1);
} else {
lines[i] = `${head.prefix}${replacement}${comment}`;
}
}
type EditMode = "inplace" | "appended" | "noop";
interface LineEdit { text: string; mode: EditMode }
/**
* Set a root-scope boolean, inserting above the first table when absent.
*
* `null` REMOVES the key rather than writing a value, which is what restoring a
* documented default means: `include_permissions_instructions = true` and an
* absent key are different facts about the same file, and only the absent one
* lets a changed upstream default ever take effect again.
*
* The value slot is classified, not just skipped over: any value form the line
* editor cannot see the end of — a multi-line string span, an unterminated
* quote — throws UnsupportedTomlForm so the write is refused instead of
* appending a second assignment TOML would reject as a duplicate key. A value
* that is not a boolean is a bad fact about the same key, so it is REPLACED,
* and a trailing comment survives a write or a removal whether or not a space
* precedes the `#`.
*/
function setRootBoolLines(content: string, key: string, value: boolean | null): LineEdit {
const eol = dominantEol(content);
const { bom, body } = splitBom(content);
const lines = splitLines(body);
const starts = scopedLineStarts(lines);
const limit = firstTableIndex(lines, starts);
for (let i = 0; i < limit; i += 1) {
if (!starts[i] || !matchKeyHead(lines[i]!, key)) continue;
applyLineEdit(lines, i, key, value === null ? null : String(value));
return { text: bom + joinLines(lines, eol), mode: "inplace" };
}
if (value === null) return { text: bom + joinLines(lines, eol), mode: "noop" };
lines.splice(limit, 0, `${key} = ${value}`);
return { text: bom + joinLines(lines, eol), mode: "appended" };
}
/**
* Set or REMOVE a root-scope basic string. `null` removes the key.
*
* Removal is what selecting the default variant does, and it has to be a real deletion
* rather than an empty string: `model_instructions_file = ""` is a path Codex would try
* to read, not an absent setting.
*/
function setRootStringLines(content: string, key: string, value: string | null): LineEdit {
const eol = dominantEol(content);
const { bom, body } = splitBom(content);
const lines = splitLines(body);
const starts = scopedLineStarts(lines);
const limit = firstTableIndex(lines, starts);
for (let i = 0; i < limit; i += 1) {
if (!starts[i] || !matchKeyHead(lines[i]!, key)) continue;
applyLineEdit(lines, i, key, value === null ? null : encodeBasicString(value));
return { text: bom + joinLines(lines, eol), mode: "inplace" };
}
if (value === null) return { text: bom + joinLines(lines, eol), mode: "noop" };
lines.splice(limit, 0, `${key} = ${encodeBasicString(value)}`);
return { text: bom + joinLines(lines, eol), mode: "appended" };
}
/**
* Set a boolean inside `[table]`, appending the table when absent.
*
* `null` removes the key line but leaves the table header: an empty `[skills]`
* is valid TOML, and deleting the header would also orphan any comments the
* user wrote inside the table.
*/
function setTableBoolLines(content: string, table: string, key: string, value: boolean | null): LineEdit {
const eol = dominantEol(content);
const { bom, body } = splitBom(content);
const lines = splitLines(body);
const starts = scopedLineStarts(lines);
const escaped = table.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const header = new RegExp(`^\\s*\\[${escaped}\\]\\s*(?:#.*)?$`);
const start = lines.findIndex((l, i) => starts[i] === true && header.test(l));
if (start === -1) {
if (value === null) return { text: bom + joinLines(lines, eol), mode: "noop" };
const tail = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
lines.splice(tail, 0, `[${table}]`, `${key} = ${value}`);
return { text: bom + joinLines(lines, eol), mode: "appended" };
}
let end = start + 1;
while (end < lines.length && !(starts[end] && TABLE_HEADER.test(lines[end]!))) end += 1;
for (let i = start + 1; i < end; i += 1) {
if (!starts[i] || !matchKeyHead(lines[i]!, key)) continue;
applyLineEdit(lines, i, key, value === null ? null : String(value));
return { text: bom + joinLines(lines, eol), mode: "inplace" };
}
if (value === null) return { text: bom + joinLines(lines, eol), mode: "noop" };
lines.splice(end, 0, `${key} = ${value}`);
return { text: bom + joinLines(lines, eol), mode: "appended" };
}
/**
* Replace, insert, or remove the generated two-line block. Canonical form is
* marker + assignment at the top of the document; replacement is "find the
* marker, replace the next line" rather than a span search.
*/
export function setProjection(content: string | null, projection: string | null): string {
const base = content ?? "";
const eol = dominantEol(base);
// The BOM is held aside for the whole edit. This is the function that produced
// the corruption: the insert below is at index 0, which put the marker line
// ahead of a byte that is only legal at byte 0.
const { bom, body } = splitBom(base);
const lines = splitLines(body);
const limit = firstTableIndex(lines);
let markerAt = -1;
for (let i = 0; i < limit; i += 1) {
if (i > 0 && lines[i - 1]!.includes(OCX_SECTION_MARKER) && ANY_DEV_INSTRUCTIONS.test(lines[i]!)) {
markerAt = i - 1;
break;
}
}
if (markerAt !== -1) {
if (projection === null) lines.splice(markerAt, 2);
else lines[markerAt + 1] = `${DEV_INSTRUCTIONS_KEY} = ${encodeBasicString(projection)}`;
return bom + joinLines(lines, eol);
}
if (projection === null) return bom + joinLines(lines, eol);
lines.splice(0, 0, OCX_SECTION_MARKER, `${DEV_INSTRUCTIONS_KEY} = ${encodeBasicString(projection)}`);
return bom + joinLines(lines, eol);
}
/** Remove an unowned or reshaped `developer_instructions` from the root scope. */
export function removeUnownedProjection(content: string): string {
const eol = dominantEol(content);
const lines = splitLines(content);
const limit = firstTableIndex(lines);
for (let i = 0; i < limit; i += 1) {
if (!ANY_DEV_INSTRUCTIONS.test(lines[i]!)) continue;
const marked = i > 0 && lines[i - 1]!.includes(OCX_SECTION_MARKER);
lines.splice(marked ? i - 1 : i, marked ? 2 : 1);
return joinLines(lines, eol);
}
return joinLines(lines, eol);
}
/**
* Refuse, before any write, an edit that does not do exactly what it was asked.
*
* The line editors above address bare table headers and bare or quoted keys. A
* quoted, spaced, inline or dotted spelling of the same table makes them append a
* duplicate header (a file Codex cannot load) or, for restore-default, leave the
* override in place while the caller reports success. Both are caught by parsing
* the before and after images: the parsed result must equal the parsed input with
* only the intended path set or removed. When Bun cannot parse the input (its
* parser has documented gaps a valid Codex config can hit, such as i64 extremes),
* only an in-place replacement of a key the editor located is trusted; an append
* or a no-op restore cannot be verified and is refused. A target value with
* control characters is checked for presence and type only, for the same reason.
*/
function checkedEdit(before: string, edit: LineEdit, path: readonly string[], value: string | boolean | null): string {
const after = edit.text;
let parsedBefore: Record<string, unknown>;
try { parsedBefore = Bun.TOML.parse(before.replace(/^\ufeff/, "")) as Record<string, unknown>; } catch {
if (edit.mode === "inplace") return after;
throw new UnsupportedTomlForm("config.toml uses syntax this editor cannot verify; edit it by hand");
}
let parsedAfter: Record<string, unknown>;
try { parsedAfter = Bun.TOML.parse(after.replace(/^\ufeff/, "")) as Record<string, unknown>; } catch {
throw new UnsupportedTomlForm("edit would leave config.toml unparseable");
}
try {
const expected = tomlClone(parsedBefore) as Record<string, unknown>;
let parent: Record<string, unknown> | null = expected;
let afterParent: unknown = parsedAfter;
for (const segment of path.slice(0, -1)) {
const next: unknown = parent?.[segment];
afterParent = isPlainTable(afterParent) ? afterParent[segment] : undefined;
if (next === undefined) {
if (value === null) { parent = null; break; }
parent![segment] = {};
parent = parent![segment] as Record<string, unknown>;
continue;
}
if (!isPlainTable(next)) throw new UnsupportedTomlForm("edit target is not a plain table");
parent = next;
}
const key = path[path.length - 1]!;
if (parent !== null) {
if (value === null) delete parent[key];
else if (typeof value === "string" && /[\u0000-\u001f\u007f]/.test(value)) {
const landed = isPlainTable(afterParent) ? afterParent[key] : undefined;
if (typeof landed !== "string") throw new UnsupportedTomlForm("edit did not land on the intended key");
parent[key] = landed;
} else parent[key] = value;
}
if (!tomlEqual(parsedAfter, expected)) throw new UnsupportedTomlForm("edit did not land on the intended key");
} catch (error) {
if (error instanceof UnsupportedTomlForm) throw error;
throw new UnsupportedTomlForm("edit could not be verified");
}
return after;
}
function isPlainTable(value: unknown): value is Record<string, unknown> {
if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
const proto = Object.getPrototypeOf(value);
return proto === Object.prototype || proto === null;
}
/** Arrays and plain tables are copied; TOML date/time values are immutable and shared. */
function tomlClone(value: unknown): unknown {
if (Array.isArray(value)) return value.map(tomlClone);
if (isPlainTable(value)) return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, tomlClone(v)]));
return value;
}
function tomlEqual(a: unknown, b: unknown): boolean {
if (Object.is(a, b)) return true;
if (Array.isArray(a) || Array.isArray(b)) {
return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => tomlEqual(v, b[i]));
}
if (isPlainTable(a) || isPlainTable(b)) {
if (!isPlainTable(a) || !isPlainTable(b)) return false;
const ka = Object.keys(a), kb = Object.keys(b);
return ka.length === kb.length && ka.every(k => Object.hasOwn(b, k) && tomlEqual(a[k], b[k]));
}
if (a !== null && b !== null && typeof a === "object" && typeof b === "object") {
return Object.getPrototypeOf(a) === Object.getPrototypeOf(b) && String(a) === String(b);
}
return false;
}
export function setRootBool(content: string, key: string, value: boolean | null): string {
return checkedEdit(content, setRootBoolLines(content, key, value), [key], value);
}
export function setRootString(content: string, key: string, value: string | null): string {
return checkedEdit(content, setRootStringLines(content, key, value), [key], value);
}
export function setTableBool(content: string, table: string, key: string, value: boolean | null): string {
return checkedEdit(content, setTableBoolLines(content, table, key, value), [...table.split("."), key], value);
}