@bitkyc08/opencodex 2.83.0 → 2.86.0

package/src/codex/prompt-layers/import-source.ts

@@ -0,0 +1,30 @@
+import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+
+// CRLF normalization can halve the byte count. Every body within 64 KiB
+// therefore fits this raw ceiling; title bytes stay outside the body budget.
+const MAX_IMPORT_SOURCE_BYTES = 2 * 64 * 1024;
+
+/** The prompt-text-probe descriptor pattern: nonblocking, regular, bounded. */
+export function readBaseImportSource(path: string): string {
+  const nonBlocking = (constants as { O_NONBLOCK?: number }).O_NONBLOCK ?? 0;
+  const descriptor = openSync(path, constants.O_RDONLY | nonBlocking);
+  try {
+    if (!fstatSync(descriptor).isFile()) throw new Error("prompt source is not a regular file");
+    const parts: Buffer[] = [];
+    const view = Buffer.allocUnsafe(8192);
+    let total = 0;
+    for (;;) {
+      const count = readSync(descriptor, view, 0, Math.min(view.length, MAX_IMPORT_SOURCE_BYTES + 1 - total), total);
+      if (count === 0) return Buffer.concat(parts).toString("utf8");
+      total += count;
+      if (total > MAX_IMPORT_SOURCE_BYTES) {
+        const error = new Error("prompt source exceeds the import byte ceiling") as NodeJS.ErrnoException;
+        error.code = "EFBIG";
+        throw error;
+      }
+      parts.push(Buffer.from(view.subarray(0, count)));
+    }
+  } finally {
+    closeSync(descriptor);
+  }
+}

package/src/codex/prompt-layers/toml-edit.ts

@@ -1,5 +1,5 @@
 import { OCX_SECTION_MARKER } from "../injected-marker";
-import { encodeBasicString } from "./encoding";
+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. */
@@ -37,28 +37,156 @@ function joinLines(lines: string[], eol: "\r\n" | "\n"): string {
   return eol === "\n" ? text : text.replace(/\n/g, "\r\n");
 }
 
-function firstTableIndex(lines: string[]): number {
-  const idx = lines.findIndex(l => TABLE_HEADER.test(l));
+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;
 }
 
-/** Set a root-scope boolean, inserting above the first table when absent. */
-export function setRootBool(content: string, key: string, value: boolean): string {
+/**
+ * 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 limit = firstTableIndex(lines);
-  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(`^(\\s*${escaped}\\s*=\\s*)(?:true|false)(\\s*(?:#.*)?)$`);
+  const starts = scopedLineStarts(lines);
+  const limit = firstTableIndex(lines, starts);
   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);
-    }
+    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 bom + joinLines(lines, eol);
+  return { text: bom + joinLines(lines, eol), mode: "appended" };
 }
 
 /**
@@ -68,51 +196,56 @@ export function setRootBool(content: string, key: string, value: boolean): strin
  * 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 {
+function setRootStringLines(content: string, key: string, value: string | null): LineEdit {
   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*(?:#.*)?$`);
+  const starts = scopedLineStarts(lines);
+  const limit = firstTableIndex(lines, starts);
   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 (!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 bom + joinLines(lines, eol);
+  if (value === null) return { text: bom + joinLines(lines, eol), mode: "noop" };
   lines.splice(limit, 0, `${key} = ${encodeBasicString(value)}`);
-  return bom + joinLines(lines, eol);
+  return { text: bom + joinLines(lines, eol), mode: "appended" };
 }
 
-/** Set a boolean inside `[table]`, appending the table when absent. */
-export function setTableBool(content: string, table: string, key: string, value: boolean): string {
+/**
+ * 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 start = lines.findIndex(l => new RegExp(`^\\s*\\[${escaped}\\]\\s*(?:#.*)?$`).test(l));
+  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 bom + joinLines(lines, eol);
+    return { text: bom + joinLines(lines, eol), mode: "appended" };
   }
-  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;
+  while (end < lines.length && !(starts[end] && 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);
-    }
+    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 bom + joinLines(lines, eol);
+  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
@@ -161,3 +294,102 @@ export function removeUnownedProjection(content: string): string {
   }
   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);
+}

package/src/codex/prompt-layers/toml-read.ts

@@ -1,5 +1,5 @@
 import { OCX_SECTION_MARKER } from "../injected-marker";
-import { decodeBasicString } from "./encoding";
+import { decodeBasicString, lexicalLineStarts, matchKeyHead } from "./encoding";
 
 /**
  * Decoded string entries of a root-scope TOML array.
@@ -118,6 +118,25 @@ export function rootLines(content: string): string[] {
   return first === -1 ? lines : lines.slice(0, first);
 }
 
+/**
+ * Root-scope lines that start outside every string and composite span. Used by
+ * fallbacks that scan lines because the parser refused the file (for example a
+ * Codex-valid i64 Bun cannot represent): prose inside a multiline value must not
+ * be read as a setting. A file whose spans never close keeps the plain scan.
+ */
+export function scopedRootLines(content: string): string[] {
+  const lines = content.split("\n");
+  const starts = lexicalLineStarts(lines);
+  if (starts === null) return rootLines(content);
+  const out: string[] = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    if (!starts[i]) continue;
+    if (TABLE_HEADER.test(lines[i]!)) break;
+    out.push(lines[i]!);
+  }
+  return out;
+}
+
 /** Lines of `[header]`'s body, up to the next table header. */
 export function tableLines(content: string, header: string): string[] | null {
   const lines = content.split("\n");
@@ -129,11 +148,40 @@ export function tableLines(content: string, header: string): string[] | null {
   return end === -1 ? rest : rest.slice(0, end);
 }
 
+/**
+ * A root-scope (`table === null`) or `[table]` boolean, reading only lines that
+ * start outside every string and composite span, so assignment-shaped prose in a
+ * multiline value is never reported as the setting. A file whose spans never
+ * close falls back to the plain line scan; Codex cannot load it either way.
+ */
+export function scopedBool(content: string, table: string | null, key: string): boolean | null {
+  const lines = content.split("\n");
+  const starts = lexicalLineStarts(lines);
+  if (starts === null) {
+    const scope = table === null ? rootLines(content) : tableLines(content, table);
+    return scope === null ? null : boolInLines(scope, key);
+  }
+  const top = (i: number) => starts[i] === true;
+  let from = 0;
+  if (table !== null) {
+    const escaped = table.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const header = new RegExp(`^\\s*\\[${escaped}\\]\\s*(?:#.*)?$`);
+    from = lines.findIndex((l, i) => top(i) && header.test(l)) + 1;
+    if (from === 0) return null;
+  }
+  for (let i = from; i < lines.length; i += 1) {
+    if (!top(i)) continue;
+    if (TABLE_HEADER.test(lines[i]!)) break;
+    const value = boolInLines([lines[i]!], key);
+    if (value !== null) return value;
+  }
+  return null;
+}
+
 export function boolInLines(lines: string[], key: string): boolean | null {
-  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(`^\\s*${escaped}\\s*=\\s*(true|false)\\s*(?:#.*)?$`);
   for (const line of lines) {
-    const m = pattern.exec(line);
+    const head = matchKeyHead(line, key);
+    const m = head === null ? null : /^(true|false)\s*(?:#.*)?$/.exec(head.rest);
     if (m) return m[1] === "true";
   }
   return null;