// ---------------------------------------------------------------------------// Shared helpers for the Codex plugin surfaces that run through `node_repl`.//// Two Codex plugins ship no MCP server of their own and are driven by// executing JavaScript in Codex's Node REPL: Computer Use (`@oai/sky`) and// Chrome (`browser-client.mjs`). Both surfaces project that REPL as typed MCP// tools, and both therefore have to embed caller arguments into a JS source// text and read one JSON value back out. That encoding is the genuinely// shared part, and it is the part that must be exactly right.// --------------------------------------------------------------------------- /** A JS string literal. For values that ARE strings and are ours (a resolved *  module path), where the prototype hazard below cannot apply. *//** * An expression that evaluates to `value` inside the REPL. * * `JSON.parse` of a string, NOT a bare object literal. JSON is almost a subset * of JS, but the two differ in exactly the way that matters here: `__proto__` * as a key sets an object's PROTOTYPE in a literal while being an ordinary own * key under `JSON.parse`. Embedding caller arguments as a literal therefore let * a caller move data onto the prototype chain — an argument named `__proto__` * would vanish from `args.__proto__` and reappear as inherited properties on * every lookup the generated program makes. Parsing keeps arguments data. * * The JSON is then escaped as a JS string. U+2028 and U+2029 are legal raw * inside a JSON string but are literal line terminators in a JS source text, so * a value containing one would end the statement early. */export const jsString = (value: string): string =>  JSON.stringify(value).replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029"); export const jsLiteral = (value: unknown): string =>  `JSON.parse(${JSON.stringify(JSON.stringify(value ?? null))    .replaceAll("\u2028", "\\u2028")    .replaceAll("\u2029", "\\u2029")})`; /** * Wrap a program body so it runs in its own scope and reports one JSON value. * * The scope is not cosmetic. A REPL session is persistent and pooled * connections now reuse it across calls, so a program that declared its * working variables at top level would redeclare the same `const` on every * call — which the REPL answers with a warning per variable, prepended to the * result a caller then has to read around. Everything per-call lives in here; * only deliberate caches (the imported runtime) are left on `globalThis`. * * The REPL returns values only through `nodeRepl.write`, and only as text; * `undefined` (every action method) becomes `null` so a caller always gets a * well-formed JSON body rather than an empty string. */export const writeJsonResult = (body: readonly string[], expression: string): string =>  [    "await (async () => {",    ...body.map((line) => `  ${line}`),    `  const result = ${expression};`,    "  nodeRepl.write(JSON.stringify(result ?? null));",    "})();",  ].join("\n");