@bli-cockpit/cli 0.2.49 → 0.2.51

package/dist/commands/memory-install-toml.js

@@ -0,0 +1,265 @@
+/**
+ * The smallest TOML surface that can put ONE table into `~/.codex/config.toml`
+ * and read it back — and nothing else.
+ *
+ * This is deliberately not a TOML parser. That file is a person's own Codex
+ * configuration: model, approval policy, sandbox, their other MCP servers. The
+ * rule is that everything outside `[mcp_servers.bli-memory]` comes out of an
+ * install byte-identical, which a parse-and-reserialise round trip cannot
+ * promise (it would reorder keys, drop comments and normalise strings). So the
+ * writer works on LINE SPANS: find our table's header, find where it ends, swap
+ * those lines, leave every other byte alone.
+ *
+ * The reader is the other half of BLI-2541's rule — verify against what the
+ * platform stored, not against what you wrote. It understands exactly the three
+ * value forms we emit (a quoted string, a single-line array of strings, a
+ * single-line inline table of strings). Anything else in our table reads back as
+ * unparsed, which surfaces as `read_back_mismatch` rather than as a shrug.
+ */
+/**
+ * Finds `[a.b]` (or `["a"."b"]`, or any mix) and the span it owns: everything up
+ * to the next table header of any kind, or end of file.
+ */
+export function findTomlTableSpan(text, tablePath) {
+    const lines = text.split("\n");
+    for (let index = 0; index < lines.length; index += 1) {
+        const header = parseTableHeader(lines[index] ?? "");
+        if (!header || !samePath(header, tablePath))
+            continue;
+        let end = lines.length;
+        for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+            if (parseTableHeader(lines[cursor] ?? "") || isArrayTableHeader(lines[cursor] ?? "")) {
+                end = cursor;
+                break;
+            }
+        }
+        return { start_line: index, end_line: end };
+    }
+    return null;
+}
+/** Reads our table's simple key/values back off stored text. Null = no such table. */
+export function readTomlTable(text, tablePath) {
+    const span = findTomlTableSpan(text, tablePath);
+    if (!span)
+        return null;
+    const lines = text.split("\n").slice(span.start_line + 1, span.end_line);
+    const out = {};
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const equals = trimmed.indexOf("=");
+        if (equals <= 0)
+            continue;
+        const key = unquoteKey(trimmed.slice(0, equals).trim());
+        if (!key)
+            continue;
+        // `null` means "present but in a form this reader does not model" — the
+        // caller reports a mismatch instead of pretending the field matched.
+        out[key] = parseTomlValue(trimmed.slice(equals + 1).trim());
+    }
+    return out;
+}
+/**
+ * Replaces our table's lines, or appends the table at the end when it is
+ * absent. Everything outside the span is untouched, including trailing
+ * whitespace and comments.
+ */
+export function upsertTomlTable(text, tablePath, renderedTable) {
+    const block = renderedTable.replace(/\n+$/u, "");
+    const span = findTomlTableSpan(text, tablePath);
+    if (!span) {
+        if (!text.trim())
+            return `${block}\n`;
+        const separator = text.endsWith("\n") ? "\n" : "\n\n";
+        return `${text}${separator}${block}\n`;
+    }
+    const lines = text.split("\n");
+    const before = lines.slice(0, span.start_line);
+    const after = lines.slice(span.end_line);
+    return [...before, ...block.split("\n"), ...after].join("\n");
+}
+/** Removes our table's lines. Used by `--uninstall`-shaped callers and tests. */
+export function removeTomlTable(text, tablePath) {
+    const span = findTomlTableSpan(text, tablePath);
+    if (!span)
+        return text;
+    const lines = text.split("\n");
+    return [...lines.slice(0, span.start_line), ...lines.slice(span.end_line)].join("\n");
+}
+export function renderTomlTable(tablePath, entries) {
+    const header = `[${tablePath.map(renderKey).join(".")}]`;
+    const body = entries.map(([key, value]) => `${renderKey(key)} = ${renderValue(value)}`);
+    return [header, ...body].join("\n");
+}
+function renderKey(key) {
+    return /^[A-Za-z0-9_-]+$/u.test(key) ? key : `"${key.replace(/"/gu, '\\"')}"`;
+}
+function renderValue(value) {
+    if (typeof value === "string")
+        return renderString(value);
+    if (Array.isArray(value))
+        return `[${value.map(renderString).join(", ")}]`;
+    const pairs = Object.entries(value).map(([key, entry]) => `${renderKey(key)} = ${renderString(entry)}`);
+    return pairs.length === 0 ? "{}" : `{ ${pairs.join(", ")} }`;
+}
+function renderString(value) {
+    return `"${value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"')}"`;
+}
+function parseTableHeader(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("[") || trimmed.startsWith("[["))
+        return null;
+    const close = trimmed.indexOf("]");
+    if (close < 0)
+        return null;
+    // Anything after the closing bracket other than a comment is not a header.
+    const rest = trimmed.slice(close + 1).trim();
+    if (rest && !rest.startsWith("#"))
+        return null;
+    return splitKeyPath(trimmed.slice(1, close));
+}
+function isArrayTableHeader(line) {
+    return line.trim().startsWith("[[");
+}
+function splitKeyPath(raw) {
+    const parts = [];
+    let current = "";
+    let quote = null;
+    for (const character of raw) {
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            else
+                current += character;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === ".") {
+            parts.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    parts.push(current.trim());
+    return parts.filter((part) => part.length > 0);
+}
+function samePath(left, right) {
+    return left.length === right.length && left.every((part, index) => part === right[index]);
+}
+function unquoteKey(raw) {
+    const trimmed = raw.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2)) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseTomlValue(raw) {
+    const value = stripTrailingComment(raw).trim();
+    if (!value)
+        return null;
+    if (value.startsWith('"') || value.startsWith("'")) {
+        return parseTomlString(value);
+    }
+    if (value.startsWith("[")) {
+        if (!value.endsWith("]"))
+            return null;
+        const inner = value.slice(1, -1).trim();
+        if (!inner)
+            return [];
+        const items = splitTopLevel(inner);
+        const parsed = items.map(parseTomlString);
+        return parsed.every((item) => item !== null) ? parsed : null;
+    }
+    if (value.startsWith("{")) {
+        if (!value.endsWith("}"))
+            return null;
+        const inner = value.slice(1, -1).trim();
+        const out = {};
+        if (!inner)
+            return out;
+        for (const pair of splitTopLevel(inner)) {
+            const equals = pair.indexOf("=");
+            if (equals <= 0)
+                return null;
+            const key = unquoteKey(pair.slice(0, equals).trim());
+            const parsed = parseTomlString(pair.slice(equals + 1).trim());
+            if (!key || parsed === null)
+                return null;
+            out[key] = parsed;
+        }
+        return out;
+    }
+    return null;
+}
+function parseTomlString(raw) {
+    const value = raw.trim();
+    if (value.length < 2)
+        return null;
+    const quote = value[0];
+    if ((quote !== '"' && quote !== "'") || value[value.length - 1] !== quote)
+        return null;
+    const inner = value.slice(1, -1);
+    if (quote === "'")
+        return inner;
+    return inner.replace(/\\(["\\nrt])/gu, (_match, escaped) => {
+        if (escaped === "n")
+            return "\n";
+        if (escaped === "r")
+            return "\r";
+        if (escaped === "t")
+            return "\t";
+        return escaped;
+    });
+}
+/** Splits on commas that are not inside a quoted string. */
+function splitTopLevel(raw) {
+    const parts = [];
+    let current = "";
+    let quote = null;
+    for (const character of raw) {
+        if (quote) {
+            current += character;
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            current += character;
+            continue;
+        }
+        if (character === ",") {
+            parts.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}
+function stripTrailingComment(raw) {
+    let quote = null;
+    for (let index = 0; index < raw.length; index += 1) {
+        const character = raw[index];
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === "#")
+            return raw.slice(0, index);
+    }
+    return raw;
+}