@cortexkit/opencode-magic-context 0.36.0 → 0.37.0

package/src/shared/jsonc-edit.ts

@@ -0,0 +1,295 @@
+import {
+    applyEdits,
+    createScanner,
+    findNodeAtLocation,
+    getNodeValue,
+    type JSONPath,
+    modify,
+    type Node,
+    type ParseError,
+    parseTree,
+} from "jsonc-parser";
+
+interface TokenLocation {
+    offset: number;
+    length: number;
+    line: number;
+}
+
+/**
+ * jsonc-parser exposes SyntaxKind as a const enum, which cannot be referenced
+ * from this isolated TypeScript module. Keep the scanner token values local.
+ */
+const TOKEN_COMMA = 5;
+const TOKEN_LINE_COMMENT = 12;
+const TOKEN_BLOCK_COMMENT = 13;
+const TOKEN_EOF = 17;
+
+function parseDocument(text: string): Node {
+    const errors: ParseError[] = [];
+    const root = parseTree(text, errors, { allowTrailingComma: true });
+    if (!root || errors.length > 0) {
+        throw new Error("Cannot edit invalid JSONC");
+    }
+    return root;
+}
+
+function findNode(text: string, path: JSONPath): Node | undefined {
+    return findNodeAtLocation(parseDocument(text), path);
+}
+
+function findComma(text: string, start: number, end: number): TokenLocation | undefined {
+    const scanner = createScanner(text, false);
+    scanner.setPosition(start);
+
+    for (;;) {
+        const kind = scanner.scan();
+        const offset = scanner.getTokenOffset();
+        if (kind === TOKEN_EOF || offset >= end) return undefined;
+        if (kind === TOKEN_COMMA) {
+            return {
+                offset,
+                length: scanner.getTokenLength(),
+                line: scanner.getTokenStartLine(),
+            };
+        }
+    }
+}
+
+function lineStart(text: string, offset: number): number {
+    const previousNewline = text.lastIndexOf("\n", offset - 1);
+    return previousNewline === -1 ? 0 : previousNewline + 1;
+}
+
+function lineEnd(text: string, offset: number): number {
+    const nextNewline = text.indexOf("\n", offset);
+    if (nextNewline === -1) return text.length;
+    return text[nextNewline - 1] === "\r" ? nextNewline - 1 : nextNewline;
+}
+
+function inlineCommentEnd(
+    text: string,
+    start: number,
+    line: number,
+    limit: number,
+): number | undefined {
+    const scanner = createScanner(text, false);
+    scanner.setPosition(start);
+    let end: number | undefined;
+
+    for (;;) {
+        const kind = scanner.scan();
+        const offset = scanner.getTokenOffset();
+        if (kind === TOKEN_EOF || offset >= limit || scanner.getTokenStartLine() !== line) {
+            return end;
+        }
+        if (kind === TOKEN_LINE_COMMENT || kind === TOKEN_BLOCK_COMMENT) {
+            end = offset + scanner.getTokenLength();
+        }
+    }
+}
+
+/**
+ * Keep comments written inline after a preceding separator with that preceding
+ * entry. Comments on a later line belong to the entry that follows the comma.
+ */
+function startAfterPrecedingInlineComments(
+    text: string,
+    comma: TokenLocation,
+    entryOffset: number,
+): number {
+    const commentEnd = inlineCommentEnd(text, comma.offset + comma.length, comma.line, entryOffset);
+    if (commentEnd === undefined) return comma.offset + comma.length;
+
+    const nextNewline = text.indexOf("\n", commentEnd);
+    return nextNewline === -1 ? commentEnd : nextNewline + 1;
+}
+
+/** Remove inline comments following a removed entry's comma with that entry. */
+function endAfterFollowingInlineComments(
+    text: string,
+    comma: TokenLocation,
+    nextEntryOffset: number,
+): number {
+    const commentEnd = inlineCommentEnd(
+        text,
+        comma.offset + comma.length,
+        comma.line,
+        nextEntryOffset,
+    );
+    return commentEnd === undefined ? comma.offset + comma.length : lineEnd(text, commentEnd);
+}
+
+function closingWhitespace(text: string, entryEnd: number, closingBracket: number): string {
+    const trailing = text.slice(entryEnd, closingBracket);
+    const finalNewline = trailing.lastIndexOf("\n");
+    if (finalNewline === -1) return "";
+    const newlineStart = trailing[finalNewline - 1] === "\r" ? finalNewline - 1 : finalNewline;
+    return trailing.slice(newlineStart);
+}
+
+function removeArrayEntry(text: string, array: Node, index: number): string {
+    const entries = array.children ?? [];
+    const entry = entries[index];
+    if (!entry) return text;
+
+    const closingBracket = array.offset + array.length - 1;
+    if (entries.length === 1) {
+        const start = array.offset + 1;
+        const replacement = closingWhitespace(text, entry.offset + entry.length, closingBracket);
+        return text.slice(0, start) + replacement + text.slice(closingBracket);
+    }
+
+    if (index === entries.length - 1) {
+        const previous = entries[index - 1];
+        if (!previous) return text;
+        const comma = findComma(text, previous.offset + previous.length, entry.offset);
+        if (!comma) return text;
+        const replacement = closingWhitespace(text, entry.offset + entry.length, closingBracket);
+        return text.slice(0, comma.offset) + replacement + text.slice(closingBracket);
+    }
+
+    const next = entries[index + 1];
+    if (!next) return text;
+    const followingComma = findComma(text, entry.offset + entry.length, next.offset);
+    if (!followingComma) return text;
+
+    const start =
+        index === 0
+            ? array.offset + 1
+            : (() => {
+                  const previous = entries[index - 1];
+                  if (!previous) return entry.offset;
+                  const precedingComma = findComma(
+                      text,
+                      previous.offset + previous.length,
+                      entry.offset,
+                  );
+                  return precedingComma
+                      ? startAfterPrecedingInlineComments(text, precedingComma, entry.offset)
+                      : entry.offset;
+              })();
+    const end = endAfterFollowingInlineComments(text, followingComma, next.offset);
+
+    return text.slice(0, start) + text.slice(end);
+}
+
+function indentationAt(text: string, offset: number): string {
+    const prefix = text.slice(lineStart(text, offset), offset);
+    return /^[\t ]*$/.test(prefix) ? prefix : "";
+}
+
+function inferIndent(text: string, array: Node): string {
+    const firstEntry = array.children?.[0];
+    if (firstEntry) return indentationAt(text, firstEntry.offset);
+
+    const closingBracket = array.offset + array.length - 1;
+    const closingIndent = indentationAt(text, closingBracket);
+    return `${closingIndent}${closingIndent.includes("\t") ? "\t" : "  "}`;
+}
+
+function appendArrayValue(text: string, array: Node, value: unknown): string {
+    const entries = array.children ?? [];
+    const closingBracket = array.offset + array.length - 1;
+    const serialized = JSON.stringify(value);
+
+    if (entries.length === 0) {
+        if (!text.slice(array.offset, closingBracket).includes("\n")) {
+            return text.slice(0, closingBracket) + serialized + text.slice(closingBracket);
+        }
+
+        const indent = inferIndent(text, array);
+        const closingLineStart = lineStart(text, closingBracket);
+        const eol = text.includes("\r\n") ? "\r\n" : "\n";
+        return (
+            text.slice(0, closingLineStart) +
+            indent +
+            serialized +
+            eol +
+            text.slice(closingLineStart)
+        );
+    }
+
+    const lastEntry = entries.at(-1);
+    if (!lastEntry) return text;
+    const trailingComma = findComma(text, lastEntry.offset + lastEntry.length, closingBracket);
+    const isMultiline = text.slice(array.offset, closingBracket).includes("\n");
+
+    if (!isMultiline) {
+        return (
+            text.slice(0, lastEntry.offset + lastEntry.length) +
+            `,${serialized}` +
+            text.slice(lastEntry.offset + lastEntry.length)
+        );
+    }
+
+    const closingLineStart = lineStart(text, closingBracket);
+    const eol = text.includes("\r\n") ? "\r\n" : "\n";
+    const inserted = `${inferIndent(text, array)}${serialized}${trailingComma ? "," : ""}${eol}`;
+    const withValue = text.slice(0, closingLineStart) + inserted + text.slice(closingLineStart);
+
+    if (trailingComma) return withValue;
+    return (
+        withValue.slice(0, lastEntry.offset + lastEntry.length) +
+        "," +
+        withValue.slice(lastEntry.offset + lastEntry.length)
+    );
+}
+
+/**
+ * Replace one JSONC value without reserializing the rest of the document. New
+ * paths use jsonc-parser's structural edit so the original document remains
+ * untouched outside the inserted property.
+ */
+export function setJsoncValue(text: string, path: JSONPath, value: unknown): string {
+    const node = findNode(text, path);
+    if (node) {
+        if (Object.is(getNodeValue(node), value)) return text;
+        const serialized = JSON.stringify(value);
+        return text.slice(0, node.offset) + serialized + text.slice(node.offset + node.length);
+    }
+
+    return applyEdits(text, modify(text, path, value, {}));
+}
+
+/**
+ * Remove matching array entries while retaining the exact bytes for survivor
+ * comments and surrounding JSONC regions.
+ */
+export function removeJsoncArrayEntries(
+    text: string,
+    path: JSONPath,
+    shouldRemove: (entry: unknown) => boolean,
+): { text: string; removed: boolean } {
+    let nextText = text;
+    let removed = false;
+
+    for (;;) {
+        const array = findNode(nextText, path);
+        if (array?.type !== "array") return { text: nextText, removed };
+        const index = (array.children ?? []).findIndex((entry) =>
+            shouldRemove(getNodeValue(entry)),
+        );
+        if (index === -1) return { text: nextText, removed };
+
+        const updated = removeArrayEntry(nextText, array, index);
+        if (updated === nextText) return { text: nextText, removed };
+        nextText = updated;
+        removed = true;
+    }
+}
+
+/** Append values to an existing JSONC array without reserializing sibling fields. */
+export function appendJsoncArrayValues(text: string, path: JSONPath, values: unknown[]): string {
+    let nextText = text;
+
+    for (const value of values) {
+        const array = findNode(nextText, path);
+        if (array?.type !== "array") {
+            return setJsoncValue(nextText, path, values);
+        }
+        nextText = appendArrayValue(nextText, array, value);
+    }
+
+    return nextText;
+}

package/src/shared/jsonc-parser.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "bun:test";
+
+import { parseJsonc } from "./jsonc-parser";
+
+describe("parseJsonc prototype-pollution hardening", () => {
+    it("rejects dangerous keys recursively, including inside arrays", () => {
+        const rejected: string[] = [];
+        const parsed = parseJsonc<Record<string, unknown>>(
+            `{
+                "safe": 1,
+                "constructor": { "hidden": true },
+                "nested": { "prototype": { "hidden": true }, "safe": 2 },
+                "items": [
+                    { "__proto__": { "polluted": true }, "safe": 3 },
+                    { "safe": 4 }
+                ]
+            }`,
+            { onRejectedKey: (path) => rejected.push(path.join(".")) },
+        );
+
+        expect(rejected).toEqual(["constructor", "nested.prototype", "items.0.__proto__"]);
+        expect(Object.hasOwn(parsed, "constructor")).toBe(false);
+
+        const nested = parsed.nested as Record<string, unknown>;
+        expect(nested).toEqual({ safe: 2 });
+        expect(Object.getPrototypeOf(nested)).toBe(Object.prototype);
+
+        const items = parsed.items as Array<Record<string, unknown>>;
+        expect(items).toEqual([{ safe: 3 }, { safe: 4 }]);
+        expect(Object.getPrototypeOf(items[0])).toBe(Object.prototype);
+        expect("polluted" in items[0]).toBe(false);
+    });
+});

package/src/shared/jsonc-parser.ts

@@ -106,9 +106,61 @@ function stripTrailingCommas(content: string): string {
     return result;
 }
 
-export function parseJsonc<T = unknown>(content: string): T {
+const PROTOTYPE_POLLUTION_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+export function isPrototypePollutionKey(key: string): boolean {
+    return PROTOTYPE_POLLUTION_KEYS.has(key);
+}
+
+export interface ParsedJsonSanitizerOptions {
+    onRejectedKey?: (path: readonly (string | number)[]) => void;
+}
+
+/**
+ * Copy parsed JSON into fresh own-property-only containers while rejecting keys
+ * that can alter an object's prototype during a later merge. Rebuilding objects
+ * also removes an already-polluted prototype produced by third-party parsers.
+ */
+export function sanitizeParsedJson<T>(
+    value: T,
+    options: ParsedJsonSanitizerOptions = {},
+    path: readonly (string | number)[] = [],
+): T {
+    if (Array.isArray(value)) {
+        return value.map((entry, index) =>
+            sanitizeParsedJson(entry, options, [...path, index]),
+        ) as T;
+    }
+    if (value === null || typeof value !== "object") return value;
+
+    const source = value as Record<string, unknown>;
+    const sourcePrototype = Object.getPrototypeOf(source);
+    if (sourcePrototype !== null && sourcePrototype !== Object.prototype) {
+        options.onRejectedKey?.([...path, "__proto__"]);
+    }
+
+    const sanitized: Record<string, unknown> = {};
+    for (const key of Object.keys(source)) {
+        if (isPrototypePollutionKey(key)) {
+            options.onRejectedKey?.([...path, key]);
+            continue;
+        }
+        Object.defineProperty(sanitized, key, {
+            value: sanitizeParsedJson(source[key], options, [...path, key]),
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return sanitized as T;
+}
+
+export function parseJsonc<T = unknown>(
+    content: string,
+    options: ParsedJsonSanitizerOptions = {},
+): T {
     const normalized = stripTrailingCommas(stripJsonComments(content));
-    return JSON.parse(normalized) as T;
+    return sanitizeParsedJson(JSON.parse(normalized) as T, options);
 }
 
 export function readJsoncFile<T = unknown>(filePath: string): T | null {

package/src/shared/logger.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+type LoggerScenarioResult = {
+    exists: boolean;
+    content: string;
+    healthyDiagnostics: {
+        swallowedWriteCount: number;
+        lastErrorMessage: string | null;
+        lastErrorTime: string | null;
+    };
+    failedDiagnostics: {
+        swallowedWriteCount: number;
+        lastErrorMessage: string | null;
+        lastErrorTime: string | null;
+    };
+};
+
+const loggerScenario = `
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+
+const root = process.env.LOGGER_SCENARIO_ROOT;
+const loggerModuleUrl = process.env.LOGGER_MODULE_URL;
+if (!root || !loggerModuleUrl) throw new Error("logger scenario environment is incomplete");
+
+const logger = await import(loggerModuleUrl);
+const logPath = path.join(root, "nested", "magic-context.log");
+process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
+logger.log("first");
+logger.flushLogger();
+const healthyDiagnostics = logger.getLoggerDiagnostics();
+
+const logDirectory = path.dirname(logPath);
+if (process.env.LOGGER_SCENARIO === "recovery") {
+    const { rmSync } = await import("node:fs");
+    rmSync(logDirectory, { recursive: true, force: true });
+    logger.log("second");
+    logger.flushLogger();
+}
+
+// A directory used as the file target makes append fail deterministically on every platform.
+const failedPath = path.join(root, "unwritable-log-target");
+const { mkdirSync } = await import("node:fs");
+mkdirSync(failedPath, { recursive: true });
+process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
+logger.log("failed write");
+logger.flushLogger();
+const failedDiagnostics = logger.getLoggerDiagnostics();
+
+const content = existsSync(logPath) ? readFileSync(logPath, "utf8") : "";
+console.log(JSON.stringify({
+    exists: existsSync(logPath),
+    content,
+    healthyDiagnostics,
+    failedDiagnostics,
+}));
+`;
+
+const scenarioRoots: string[] = [];
+
+afterEach(() => {
+    for (const root of scenarioRoots.splice(0)) {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+async function runLoggerScenario(
+    scenario: "recovery" | "diagnostics",
+): Promise<LoggerScenarioResult> {
+    const root = mkdtempSync(path.join(os.tmpdir(), "magic-context-logger-test-"));
+    scenarioRoots.push(root);
+    const child = Bun.spawn({
+        cmd: ["bun", "--eval", loggerScenario],
+        cwd: import.meta.dir,
+        env: {
+            ...process.env,
+            NODE_ENV: "production",
+            LOGGER_MODULE_URL: new URL("./logger.ts", import.meta.url).href,
+            LOGGER_SCENARIO: scenario,
+            LOGGER_SCENARIO_ROOT: root,
+        },
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const [exitCode, stdout, stderr] = await Promise.all([
+        child.exited,
+        new Response(child.stdout).text(),
+        new Response(child.stderr).text(),
+    ]);
+    expect(exitCode, stderr).toBe(0);
+    return JSON.parse(stdout.trim()) as LoggerScenarioResult;
+}
+
+describe("logger", () => {
+    test("recreates a log directory removed while the process is running", async () => {
+        const result = await runLoggerScenario("recovery");
+
+        expect(result.exists).toBe(true);
+        expect(result.content).toContain("second");
+    });
+
+    test("reports swallowed writes while healthy writes leave the counter at zero", async () => {
+        const result = await runLoggerScenario("diagnostics");
+
+        expect(result.healthyDiagnostics).toEqual({
+            swallowedWriteCount: 0,
+            lastErrorMessage: null,
+            lastErrorTime: null,
+        });
+        expect(result.failedDiagnostics.swallowedWriteCount).toBe(1);
+        expect(result.failedDiagnostics.lastErrorMessage).toBeTruthy();
+        expect(result.failedDiagnostics.lastErrorTime).toMatch(
+            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
+        );
+    });
+});

package/src/shared/logger.ts

@@ -9,25 +9,30 @@ let flushTimer: ReturnType<typeof setTimeout> | null = null;
 const FLUSH_INTERVAL_MS = 500;
 const BUFFER_SIZE_LIMIT = 50;
 
-// Cache the last log directory we mkdir'd successfully so we only retry the
-// filesystem call when the resolved path actually changes. The path is
-// re-evaluated on every flush because `setHarness("pi")` runs after module
-// load on Pi; we MUST NOT freeze it at import time, or Pi's first flush
-// could land in the OpenCode subtree.
-let lastEnsuredDir: string | null = null;
+export interface LoggerDiagnostics {
+    swallowedWriteCount: number;
+    lastErrorMessage: string | null;
+    lastErrorTime: string | null;
+}
 
-function ensureDir(filePath: string): void {
-    const dir = path.dirname(filePath);
-    if (dir === lastEnsuredDir) return;
+let swallowedWriteCount = 0;
+let lastErrorMessage: string | null = null;
+let lastErrorTime: string | null = null;
+
+function recordSwallowedWrite(error: unknown): void {
     try {
-        fs.mkdirSync(dir, { recursive: true });
-        lastEnsuredDir = dir;
+        swallowedWriteCount++;
+        lastErrorMessage = error instanceof Error ? error.message : String(error);
+        lastErrorTime = new Date().toISOString();
     } catch {
-        // Intentional: logging must never throw. If mkdir fails we still
-        // try the append; failure there is also swallowed.
+        // Diagnostics must not make the logger throw either.
     }
 }
 
+function ensureDir(filePath: string): void {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
 function flush(): void {
     if (flushTimer) {
         clearTimeout(flushTimer);
@@ -40,8 +45,8 @@ function flush(): void {
         const logFile = getMagicContextLogPath();
         ensureDir(logFile);
         fs.appendFileSync(logFile, data);
-    } catch {
-        // Intentional: logging must never throw
+    } catch (error) {
+        recordSwallowedWrite(error);
     }
 }
 
@@ -78,6 +83,19 @@ export function sessionLog(sessionId: string, message: string, data?: unknown):
     log(`[magic-context][${sessionId}] ${message}`, data);
 }
 
+export function getLoggerDiagnostics(): LoggerDiagnostics {
+    return {
+        swallowedWriteCount,
+        lastErrorMessage,
+        lastErrorTime,
+    };
+}
+
+/** Flush buffered log entries immediately. Primarily useful to diagnostic readers and tests. */
+export function flushLogger(): void {
+    flush();
+}
+
 /**
  * Resolve the current log file path. The path is harness-aware (see
  * {@link getMagicContextLogPath}) and re-evaluated on every call, so callers

package/src/shared/models-dev-cache.test.ts

@@ -78,6 +78,23 @@ describe("output-token reservation", () => {
         ).toBe(1_048_576);
     });
 
+    test("output_reserve accepts both harness provider spellings with canonical precedence", () => {
+        const limit = { context: 100_000, output: 20_000 };
+        expect(
+            resolveLimit(limit, "openai-codex", "gpt-5.6-sol", {
+                default: 0,
+                "openai-codex/gpt-5.6-sol": 8_000,
+            }),
+        ).toBe(92_000);
+        expect(
+            resolveLimit(limit, "openai-codex", "gpt-5.6-sol", {
+                default: 0,
+                "openai-codex/gpt-5.6-sol": 8_000,
+                "openai/gpt-5.6-sol": 4_000,
+            }),
+        ).toBe(96_000);
+    });
+
     test("output_reserve overrides shared and separate quota defaults", () => {
         expect(resolveLimit({ context: 100_000, output: 20_000 }, "anthropic", "claude", 0)).toBe(
             100_000,