@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
164 lines (149 loc) • 6.66 kB
text/typescript
import { OCX_SECTION_MARKER } from "../injected-marker";
import { encodeBasicString } 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. */
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[]): number {
const idx = lines.findIndex(l => TABLE_HEADER.test(l));
return idx === -1 ? lines.length : idx;
}
/** Set a root-scope boolean, inserting above the first table when absent. */
export function setRootBool(content: string, key: string, value: boolean): string {
const eol = dominantEol(content);
const { bom, body } = splitBom(content);
const lines = splitLines(body);
const limit = firstTableIndex(lines);
const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const pattern = new RegExp(`^(\\s*${escaped}\\s*=\\s*)(?:true|false)(\\s*(?:#.*)?)$`);
for (let i = 0; i < limit; i += 1) {
const m = pattern.exec(lines[i]!);
if (m) {
lines[i] = `${m[1]}${value}${m[2]}`;
return bom + joinLines(lines, eol);
}
}
lines.splice(limit, 0, `${key} = ${value}`);
return bom + joinLines(lines, eol);
}
/**
* 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.
*/
export function setRootString(content: string, key: string, value: string | null): string {
const eol = dominantEol(content);
const { bom, body } = splitBom(content);
const lines = splitLines(body);
const limit = firstTableIndex(lines);
const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const pattern = new RegExp(`^\\s*${escaped}\\s*=\\s*"[^"]*"\\s*(?:#.*)?$`);
for (let i = 0; i < limit; i += 1) {
if (!pattern.test(lines[i]!)) continue;
if (value === null) lines.splice(i, 1);
else lines[i] = `${key} = ${encodeBasicString(value)}`;
return bom + joinLines(lines, eol);
}
if (value === null) return bom + joinLines(lines, eol);
lines.splice(limit, 0, `${key} = ${encodeBasicString(value)}`);
return bom + joinLines(lines, eol);
}
/** Set a boolean inside `[table]`, appending the table when absent. */
export function setTableBool(content: string, table: string, key: string, value: boolean): string {
const eol = dominantEol(content);
const { bom, body } = splitBom(content);
const lines = splitLines(body);
const escaped = table.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const start = lines.findIndex(l => new RegExp(`^\\s*\\[${escaped}\\]\\s*(?:#.*)?$`).test(l));
if (start === -1) {
const tail = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
lines.splice(tail, 0, `[${table}]`, `${key} = ${value}`);
return bom + joinLines(lines, eol);
}
const keyEscaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const pattern = new RegExp(`^(\\s*${keyEscaped}\\s*=\\s*)(?:true|false)(\\s*(?:#.*)?)$`);
let end = start + 1;
while (end < lines.length && !TABLE_HEADER.test(lines[end]!)) end += 1;
for (let i = start + 1; i < end; i += 1) {
const m = pattern.exec(lines[i]!);
if (m) {
lines[i] = `${m[1]}${value}${m[2]}`;
return bom + joinLines(lines, eol);
}
}
lines.splice(end, 0, `${key} = ${value}`);
return bom + joinLines(lines, eol);
}
/**
* 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);
}