@ironbee-ai/cli 0.15.0 → 0.17.0

package/dist/clients/codex/util.js

@@ -0,0 +1,784 @@
+"use strict";
+/**
+ * Codex CLI client utilities — stdin parsing, tool classification, TOML
+ * surgical editing, AGENTS.md block merge, auth detection.
+ *
+ * The TOML helpers are intentionally minimal: line-based surgical edits to
+ * known sections (`[features]`, `[mcp_servers.<name>]`). We don't need a
+ * full TOML parser/serializer because the only blocks we write/read have
+ * fixed shapes. User content outside our managed sections is preserved
+ * verbatim.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENTS_MD_END_MARKER = exports.AGENTS_MD_START_MARKER = void 0;
+exports.parseCodexHookStdin = parseCodexHookStdin;
+exports.canonicalizeCodexServerName = canonicalizeCodexServerName;
+exports.canonicalizeCodexToolName = canonicalizeCodexToolName;
+exports.extractCodexMcpServer = extractCodexMcpServer;
+exports.normalizeCodexToolName = normalizeCodexToolName;
+exports.classifyCodexTool = classifyCodexTool;
+exports.extractCodexToolInput = extractCodexToolInput;
+exports.extractBashBinary = extractBashBinary;
+exports.decodeJwtPayload = decodeJwtPayload;
+exports.resolveCodexUsage = resolveCodexUsage;
+exports.findTomlSection = findTomlSection;
+exports.ensureFeaturesHooksTrue = ensureFeaturesHooksTrue;
+exports.upsertMcpServer = upsertMcpServer;
+exports.removeMcpServer = removeMcpServer;
+exports.tomlBodyFromRecord = tomlBodyFromRecord;
+exports.upsertAgentsMdBlock = upsertAgentsMdBlock;
+exports.stripAgentsMdBlock = stripAgentsMdBlock;
+exports.readCodexConfigToml = readCodexConfigToml;
+exports.writeCodexConfigToml = writeCodexConfigToml;
+exports.codexConfigTomlPath = codexConfigTomlPath;
+exports.codexHooksJsonPath = codexHooksJsonPath;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const logger_1 = require("../../lib/logger");
+function parseCodexHookStdin(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        logger_1.logger.debug(`failed to parse Codex hook stdin: ${e}`);
+        return {};
+    }
+}
+// ─── Tool classification ──────────────────────────────────────────────────
+const MCP_PREFIX = "mcp__";
+/**
+ * Codex flattens `-` to `_` in BOTH segments of `mcp__<server>__<tool>` when
+ * dispatching hooks — so `mcp__browser-devtools__bdt_content_take-screenshot`
+ * arrives on hook stdin as `mcp__browser_devtools__bdt_content_take_screenshot`.
+ *
+ * Two lossy mappings happen at once:
+ *   1. **server segment**: only three values matter; map them explicitly.
+ *   2. **tool action segment**: the canonical shape is
+ *      `<prefix>_<domain>_<action-with-hyphens>` — first two underscores are
+ *      structural separators, all later underscores were `-` originally.
+ *      Live-verified examples (Codex 0.135.x):
+ *        bdt_navigation_go_to            → bdt_navigation_go-to
+ *        bdt_content_take_screenshot     → bdt_content_take-screenshot
+ *        bdt_a11y_take_aria_snapshot     → bdt_a11y_take-aria-snapshot
+ *        bdt_o11y_get_console_messages   → bdt_o11y_get-console-messages
+ *        bdt_interaction_click           → bdt_interaction_click       (no hyphens in action)
+ *
+ * We denormalize BEFORE emitting any `tool_call` event so the wire format
+ * matches Claude/Cursor exactly and downstream consumers (verify-gate
+ * required-tools satisfier, evidence extractors, recording start/stop
+ * comparisons) work with one canonical name.
+ */
+const FLAT_SERVER_TO_CANONICAL = {
+    browser_devtools: "browser-devtools",
+    node_devtools: "node-devtools",
+    backend_devtools: "backend-devtools",
+};
+const DEVTOOLS_TOOL_PREFIXES = ["bdt_", "ndt_", "bedt_"];
+/**
+ * Reverse Codex's `-`→`_` flattening on the server segment. Idempotent: an
+ * already-canonical (hyphenated) name passes through unchanged.
+ */
+function canonicalizeCodexServerName(serverSegment) {
+    return FLAT_SERVER_TO_CANONICAL[serverSegment] ?? serverSegment;
+}
+/**
+ * Reverse Codex's `-`→`_` flattening on a devtools tool action segment.
+ * Rule: keep the first two underscores (prefix + domain separators), turn
+ * every subsequent `_` into `-`. Only applies to known devtools prefixes
+ * (`bdt_` / `ndt_` / `bedt_`); other tool names pass through unchanged.
+ *
+ * Idempotent: input that already contains `-` only flattens further
+ * underscores past the third segment.
+ */
+function canonicalizeCodexToolName(bareToolName) {
+    if (!DEVTOOLS_TOOL_PREFIXES.some((p) => bareToolName.startsWith(p))) {
+        return bareToolName;
+    }
+    const parts = bareToolName.split("_");
+    if (parts.length <= 3) {
+        return bareToolName;
+    }
+    return `${parts[0]}_${parts[1]}_${parts.slice(2).join("-")}`;
+}
+/** Prefix → canonical devtools MCP server name. Single source of truth. */
+const DEVTOOLS_PREFIX_TO_SERVER = [
+    ["bdt_", "browser-devtools"],
+    ["ndt_", "node-devtools"],
+    ["bedt_", "backend-devtools"],
+];
+/**
+ * Returns the CANONICAL (hyphen-form) MCP server name for a Codex tool name.
+ *
+ * Codex tool names arrive in TWO shapes depending on the surface:
+ *   1. **Hook stdin** wraps the bare name in `mcp__<server>__<tool>` with the
+ *      `-`→`_` flattening (e.g. `mcp__browser_devtools__bdt_content_start_recording`).
+ *   2. **Rollout JSONL** (`function_call.name`) carries the BARE tool name
+ *      (e.g. `bdt_content_take_screenshot`) — no `mcp__` wrapper at all.
+ *
+ * Both are handled here so downstream comparisons against the registered
+ * server name (`browser-devtools` / `node-devtools` / `backend-devtools`)
+ * work regardless of surface.
+ *
+ * Returns null for non-MCP tools.
+ */
+function extractCodexMcpServer(toolName) {
+    if (!toolName) {
+        return null;
+    }
+    if (toolName.startsWith(MCP_PREFIX)) {
+        const rest = toolName.slice(MCP_PREFIX.length);
+        const sep = rest.indexOf("__");
+        if (sep < 0) {
+            return null;
+        }
+        return canonicalizeCodexServerName(rest.slice(0, sep));
+    }
+    for (const [prefix, server] of DEVTOOLS_PREFIX_TO_SERVER) {
+        if (toolName.startsWith(prefix)) {
+            return server;
+        }
+    }
+    return null;
+}
+/**
+ * Map a Codex / OpenAI tool name to the cross-client canonical (Claude) vocab,
+ * so `tool_call.tool_name` (live + import) AND `session_analytics.tools[*]`
+ * map keys (analytics projection) ALL agree on the same wire string for the
+ * same logical tool. Without this alignment, a backend join of
+ * `session_analytics.tools[k]` against `tool_call.tool_name` breaks on every
+ * Codex session for the affected tools:
+ *
+ *   `apply_patch` → analytics keys `"Edit"`, live/import ship `"apply_patch"`
+ *   `update_plan` → analytics keys `"TodoWrite"`, live/import ship `"update_plan"`
+ *   `read_file`   → analytics keys `"Read"`, live/import ship `"read_file"`
+ *   `web_search`  → analytics keys `"WebSearch"`, live/import ship `"web_search"`
+ *   `web_fetch`   → analytics keys `"WebFetch"`, live/import ship `"web_fetch"`
+ *
+ * Round 67 fix: extend the mapping (was `exec_command → Bash` only) to cover
+ * every alias the analytics projection's `claudeAlias` switch handles. The
+ * projection in `analytics/codex/projection.ts:670` continues to apply the
+ * same mapping for its `tools` map keys (kept there as a defense-in-depth /
+ * documentation aid — the two MUST stay in lockstep). Cross-client
+ * aggregations on `tools["Bash"]` / `tools["Read"]` / etc. now include both
+ * Claude and Codex sources for every alias, not just `Bash`.
+ */
+function normalizeCodexToolName(toolName) {
+    if (toolName === "exec_command") {
+        return "Bash";
+    }
+    if (toolName === "apply_patch") {
+        return "Edit";
+    }
+    if (toolName === "update_plan") {
+        return "TodoWrite";
+    }
+    if (toolName === "read_file") {
+        return "Read";
+    }
+    if (toolName === "web_search") {
+        return "WebSearch";
+    }
+    if (toolName === "web_fetch") {
+        return "WebFetch";
+    }
+    return toolName;
+}
+function classifyCodexTool(rawToolName) {
+    if (!rawToolName) {
+        return { tool_type: null, tool_name: "", mcp_server: null };
+    }
+    // Two shapes lead to MCP classification:
+    //   1. Hook stdin: `mcp__<server>__<tool>` (Codex wraps the bare name).
+    //   2. Rollout JSONL: bare `bdt_*` / `ndt_*` / `bedt_*` (no wrapper).
+    // Both routes through the same `extractCodexMcpServer` so import +
+    // analytics + live see identical (tool_type, mcp_server) — without this
+    // import-side devtools tool_call events ship with tool_type=null and
+    // mcp_server=null, and verify-gate cycle-attribution joins break.
+    if (rawToolName.startsWith(MCP_PREFIX)) {
+        const rest = rawToolName.slice(MCP_PREFIX.length);
+        const sep = rest.indexOf("__");
+        if (sep >= 0) {
+            const serverSegment = rest.slice(0, sep);
+            const canonicalServer = canonicalizeCodexServerName(serverSegment);
+            const bareToolName = rest.slice(sep + 2);
+            const canonicalTool = canonicalizeCodexToolName(bareToolName);
+            return { tool_type: "mcp", tool_name: canonicalTool, mcp_server: canonicalServer };
+        }
+    }
+    // Bare-prefix rollout shape. extractCodexMcpServer already knows the
+    // canonical server name for each devtools prefix. Canonicalize the tool
+    // name too (underscore → hyphen past segment 3) so wire shape matches.
+    const bareServer = extractCodexMcpServer(rawToolName);
+    if (bareServer !== null && !rawToolName.startsWith(MCP_PREFIX)) {
+        return {
+            tool_type: "mcp",
+            tool_name: canonicalizeCodexToolName(rawToolName),
+            mcp_server: bareServer,
+        };
+    }
+    const normalized = normalizeCodexToolName(rawToolName);
+    // Codex's `multi_agent_v1` namespace exposes three sub-agent lifecycle
+    // tools: `spawn_agent` (dispatch — Claude-parity `Agent`/`Task`),
+    // `wait_agent` (sync on outstanding agents), `close_agent` (cancel /
+    // reap). Without explicit `tool_type: "sub_agent"` tagging, every
+    // Codex `tool_call` event for these ships with `tool_type` OMITTED
+    // (null branch), so backend dashboards filtering on `tool_type =
+    // 'sub_agent'` (cross-client sub-agent usage) silently miss every
+    // Codex multi-agent session. The Codex projection separately routes
+    // `spawn_agent.agent_type` into the `subAgents` map (see
+    // analytics/codex/projection.ts:715), so the session-level
+    // `uses_sub_agent` aggregate is unaffected — the per-event wire field
+    // is the bug. Keep `tool_name` as the literal tool name (each
+    // lifecycle phase is a distinct call); Claude's `tool_name` collapses
+    // to the agent_type because Claude has only ONE meta-tool for the
+    // whole lifecycle, while Codex has three. Cross-client semantic
+    // difference, not a parity-break.
+    if (rawToolName === "spawn_agent" || rawToolName === "wait_agent" || rawToolName === "close_agent") {
+        return { tool_type: "sub_agent", tool_name: normalized, mcp_server: null };
+    }
+    return { tool_type: null, tool_name: normalized, mcp_server: null };
+}
+/**
+ * Per-tool input whitelist (mirrors `extractClaudeToolInput` / `extractCursorToolInput`).
+ * Default Codex toolset: `Bash`/`exec_command`, `apply_patch`, `update_plan`, MCP tools.
+ * Returns undefined for unknown tools (so the wire shape stays opt-in).
+ */
+function extractCodexToolInput(toolName, toolInput) {
+    if (!toolName || toolInput === undefined) {
+        return undefined;
+    }
+    // apply_patch: hook stdin shape (live-tested 0.135.0) is
+    // `tool_input.command = "<patch text>"`. Fallback to .input (function_call
+    // shape) and raw string (defensive).
+    if (toolName === "apply_patch") {
+        if (typeof toolInput === "string") {
+            return { input_size: toolInput.length };
+        }
+        if (typeof toolInput === "object" && toolInput !== null) {
+            const rec = toolInput;
+            const body = rec.command ?? rec.input;
+            if (typeof body === "string") {
+                return { input_size: body.length };
+            }
+        }
+        return { input_size: undefined };
+    }
+    // From here, function_call tools — tool_input is a Record
+    if (typeof toolInput !== "object" || toolInput === null) {
+        return undefined;
+    }
+    const obj = toolInput;
+    const normalized = normalizeCodexToolName(toolName);
+    if (normalized === "Bash") {
+        // Codex `exec_command` function args use `cmd` (verified 0.135.0
+        // against real rollouts: `~/.codex/sessions/.../*.jsonl` — every
+        // `{"name":"exec_command", "arguments":"{\"cmd\":...}"}` line uses
+        // `cmd`, never `command`). Earlier we only read `obj.command`, so
+        // `binary` was ALWAYS undefined for every Codex Bash tool_call —
+        // wire impact: `bash_binaries` map in Codex `session_analytics`
+        // was empty across the board, and per-event `tool_input.binary`
+        // was missing on the wire (cross-pipeline divergence with Claude's
+        // `extractCommandBinary` which correctly extracts the binary).
+        // Fall back to `command` defensively in case some Codex hook-stdin
+        // path or future shape uses the apply_patch-style remap.
+        const cmd = obj.cmd ?? obj.command;
+        const binary = typeof cmd === "string"
+            ? extractBashBinary(cmd)
+            : undefined;
+        return {
+            workdir: obj.workdir,
+            binary,
+        };
+    }
+    if (toolName === "update_plan") {
+        const explanation = obj.explanation;
+        const plan = obj.plan;
+        return {
+            explanation: typeof explanation === "string" ? explanation : undefined,
+            plan_step_count: Array.isArray(plan) ? plan.length : undefined,
+        };
+    }
+    // Codex 0.135+ sub-agent orchestration tools (`multi_agent_v1` namespace).
+    // Real-rollout shape verified against `~/.codex/sessions/.../*.jsonl`:
+    //   spawn_agent: {"agent_type":"explorer","message":"...","fork_context":true}
+    //   wait_agent:  {"targets":["<uuid>",...],"timeout_ms":30000}
+    //   close_agent: {"target":"<uuid>"}
+    // Without per-tool branches, `extractCodexToolInput` falls through to the
+    // final `return undefined` and wire `tool_call.tool_input` is dropped —
+    // backend loses `agent_type` (the primary sub-agent telemetry signal),
+    // fan-out arity (`wait_agent.targets.length`), and close-agent target
+    // joins. The `message` field is agent-authored free text → length-only
+    // (mirrors `Bash.command` policy: keep the binary, drop the content).
+    if (toolName === "spawn_agent") {
+        const agentType = obj.agent_type;
+        const message = obj.message;
+        const forkContext = obj.fork_context;
+        return {
+            agent_type: typeof agentType === "string" ? agentType : undefined,
+            message_size: typeof message === "string" ? message.length : undefined,
+            fork_context: typeof forkContext === "boolean" ? forkContext : undefined,
+        };
+    }
+    if (toolName === "wait_agent") {
+        const targets = obj.targets;
+        const timeoutMs = obj.timeout_ms;
+        return {
+            target_count: Array.isArray(targets) ? targets.length : undefined,
+            timeout_ms: typeof timeoutMs === "number" ? timeoutMs : undefined,
+        };
+    }
+    if (toolName === "close_agent") {
+        const target = obj.target;
+        return {
+            target: typeof target === "string" ? target : undefined,
+        };
+    }
+    // `view_image`: agent inspects a screenshot/image by file path. `path` is
+    // useful telemetry (groups verification screenshots by run), `detail` is
+    // OpenAI's tier flag. Mirrors Claude `Read.file_path` policy.
+    if (toolName === "view_image") {
+        const path = obj.path;
+        const detail = obj.detail;
+        return {
+            path: typeof path === "string" ? path : undefined,
+            detail: typeof detail === "string" ? detail : undefined,
+        };
+    }
+    // `write_stdin`: writes characters into an exec_command's open stdin
+    // (session_id is the exec_command session, NOT the Codex session).
+    // `chars` is agent-authored free text → length-only (privacy fence,
+    // mirrors `Bash.command` content drop). Keep `session_id` for joining
+    // back to the originating exec_command and timing knobs for parity.
+    if (toolName === "write_stdin") {
+        const sessionId = obj.session_id;
+        const chars = obj.chars;
+        const yieldTimeMs = obj.yield_time_ms;
+        const maxOutputTokens = obj.max_output_tokens;
+        return {
+            session_id: typeof sessionId === "number" ? sessionId : undefined,
+            chars_size: typeof chars === "string" ? chars.length : undefined,
+            yield_time_ms: typeof yieldTimeMs === "number" ? yieldTimeMs : undefined,
+            max_output_tokens: typeof maxOutputTokens === "number" ? maxOutputTokens : undefined,
+        };
+    }
+    // MCP devtools tools: pass through verbatim, BUT strip `_metadata` —
+    // require-verification.ts injects `_metadata` (containing internal
+    // correlation IDs AND `collectorApiKey` — a SECRET) into the
+    // tool_input via `updatedInput` for every devtools call. Live
+    // track-action strips it before recording (clients/codex/hooks/
+    // track-action.ts:167-170 `toolInputAsRecord`); import was missing
+    // the same strip → Codex import devtools `tool_call` events shipped
+    // `_metadata` (including `collectorApiKey`) onto the wire, while
+    // live shipped it stripped. Cross-pipeline divergence + secret
+    // leak on every re-import.
+    //
+    // BOTH shapes routed through `extractCodexMcpServer` so bare `bdt_*` /
+    // `ndt_*` / `bedt_*` from rollout JSONL gets the same passthrough as
+    // hook-stdin's `mcp__<server>__<tool>` shape. Without this, import-
+    // side devtools tool_call events ship with `tool_input: undefined`
+    // — backend dedup latest-wins → re-import erases the live tool_input
+    // payload.
+    if (toolName.startsWith(MCP_PREFIX) || extractCodexMcpServer(toolName) !== null) {
+        if ("_metadata" in obj) {
+            const { _metadata, ...rest } = obj;
+            void _metadata;
+            return rest;
+        }
+        return obj;
+    }
+    return undefined;
+}
+function extractBashBinary(command) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    // Skip leading env-var assignments (e.g. `KEY=val cmd …` → `cmd`).
+    // Cross-client parity with Claude's `extractCommandBinary` AND a
+    // secret-leak fence: real commands like `API_KEY=secret git push`
+    // used to land `binary="API_KEY=secret"` on the wire — both wrong
+    // (bash_binaries key polluted with secret-shaped tokens, and the
+    // secret value itself shipped as the analytics label).
+    const tokens = trimmed.split(/\s+/);
+    for (const t of tokens) {
+        // skip env-var assignments like FOO=bar / API_KEY=abc
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) {
+            continue;
+        }
+        if (t.length > 0) {
+            // Strip path prefix so `/usr/bin/git` → `git`. Cross-client
+            // parity intentionally stops short of Claude's "keep full
+            // path" behavior — Codex's pre-existing semantics already
+            // stripped the path, and changing to match Claude would
+            // break any downstream consumer keyed on the existing
+            // Codex-side `bash_binaries` keys. Documented divergence.
+            return t.split(/[\\/]/).pop() ?? t;
+        }
+    }
+    return undefined;
+}
+/**
+ * Decode the *payload* of a JWT (`header.payload.signature`).
+ *
+ * We never verify the signature — the token was minted by Codex into the
+ * user's own `~/.codex/auth.json` and we just want to read the claims for
+ * event-tagging. Returns `null` on any malformedness (wrong segment count,
+ * bad base64url, non-JSON payload).
+ */
+function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+        return null;
+    }
+    try {
+        const json = Buffer.from(parts[1], "base64url").toString("utf-8");
+        const parsed = JSON.parse(json);
+        if (typeof parsed !== "object" || parsed === null) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract `(email, chatgpt_plan_type)` from `tokens.id_token`. Handles both
+ * shapes Codex has shipped:
+ *   - JWT string (current, live-verified) — claims live in the payload
+ *   - `{ email, chatgpt_plan_type }` object (older / hypothetical) — direct
+ */
+function extractIdTokenFields(idToken) {
+    if (typeof idToken === "string") {
+        const payload = decodeJwtPayload(idToken);
+        if (!payload) {
+            return {};
+        }
+        return {
+            email: payload.email,
+            planType: payload["https://api.openai.com/auth"]?.chatgpt_plan_type,
+        };
+    }
+    if (typeof idToken === "object" && idToken !== null) {
+        const obj = idToken;
+        return { email: obj.email, planType: obj.chatgpt_plan_type };
+    }
+    return {};
+}
+/**
+ * Read `~/.codex/auth.json` to derive `usage_type` / `usage_plan` /
+ * `user_email` for event base-fields population.
+ *
+ * `auth_mode` values seen in the wild:
+ *   - `"chatgpt"` — ChatGPT browser-login / subscription (Plus / Pro / Team /
+ *     Enterprise). Current default for `codex login`.
+ *   - `"swic"` — older subscription mode alias; kept for back-compat.
+ *   - `"api"` — OpenAI Platform API key.
+ *
+ * `authPath` is optional — defaults to `~/.codex/auth.json`. Tests pass an
+ * explicit path to avoid HOME-env-var caching issues across jest workers.
+ */
+function resolveCodexUsage(authPath) {
+    const p = authPath ?? (0, path_1.join)((0, os_1.homedir)(), ".codex", "auth.json");
+    if (!(0, fs_1.existsSync)(p)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(p, "utf-8"));
+        const usageType = parsed.auth_mode === "chatgpt" || parsed.auth_mode === "swic"
+            ? "subscription"
+            : parsed.auth_mode === "api"
+                ? "api"
+                : undefined;
+        const { email, planType } = extractIdTokenFields(parsed.tokens?.id_token);
+        return {
+            usageType,
+            usagePlan: planType?.toLowerCase(),
+            userEmail: email,
+        };
+    }
+    catch (e) {
+        logger_1.logger.debug(`failed to parse ${p}: ${e}`);
+        return {};
+    }
+}
+// ─── TOML surgical editor (~/.codex/config.toml) ──────────────────────────
+/**
+ * Test if a line starts a TOML table header `[name]` (skipping arrays-of-tables `[[...]]`).
+ */
+function tableHeaderLineExact(line, sectionName) {
+    const trimmed = line.trim();
+    return trimmed === `[${sectionName}]`;
+}
+function isAnyTableHeader(line) {
+    const trimmed = line.trim();
+    return /^\[\[?[^\]]+\]\]?$/.test(trimmed);
+}
+/**
+ * Find the line range [startIdx, endIdx) of a TOML table by exact header
+ * `[<sectionName>]`. Returns null if not found. `endIdx` is the line index
+ * of the next header (or content end). Header itself is included.
+ */
+function findTomlSection(lines, sectionName) {
+    let startIdx = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        if (tableHeaderLineExact(lines[i], sectionName)) {
+            startIdx = i;
+            break;
+        }
+    }
+    if (startIdx < 0) {
+        return null;
+    }
+    let endIdx = lines.length;
+    for (let j = startIdx + 1; j < lines.length; j += 1) {
+        if (isAnyTableHeader(lines[j])) {
+            endIdx = j;
+            break;
+        }
+    }
+    return { startIdx, endIdx };
+}
+/**
+ * Strip trailing blank lines from a section body (kept just before the next
+ * header) so we don't accumulate them on repeated upsert.
+ */
+function trimTrailingBlanks(lines) {
+    const out = [...lines];
+    while (out.length > 0 && out[out.length - 1].trim() === "") {
+        out.pop();
+    }
+    return out;
+}
+/**
+ * Append `block` to `content` with a single blank-line separator. Normalizes
+ * trailing whitespace so the result always has exactly `\n\n` between the
+ * prior content and the new block, plus a single trailing `\n`.
+ */
+function appendBlockWithSeparator(content, block) {
+    if (content.length === 0) {
+        return block.join("\n") + "\n";
+    }
+    const trimmedTrailing = content.replace(/\n+$/, "");
+    return trimmedTrailing + "\n\n" + block.join("\n") + "\n";
+}
+/**
+ * Ensure `[features]` table contains `hooks = true`. Idempotent — merges
+ * into an existing `[features]` table if present (without disturbing other
+ * keys), or appends a fresh table at the end of the file.
+ */
+function ensureFeaturesHooksTrue(content) {
+    const lines = content.split("\n");
+    const section = findTomlSection(lines, "features");
+    if (section === null) {
+        return appendBlockWithSeparator(content, ["[features]", "hooks = true"]);
+    }
+    // Existing [features] table — check if `hooks = ...` already present
+    const bodyLines = lines.slice(section.startIdx + 1, section.endIdx);
+    const hookKeyRegex = /^\s*hooks\s*=/;
+    let foundHookKey = false;
+    for (let k = 0; k < bodyLines.length; k += 1) {
+        if (hookKeyRegex.test(bodyLines[k])) {
+            bodyLines[k] = "hooks = true";
+            foundHookKey = true;
+            break;
+        }
+    }
+    if (!foundHookKey) {
+        // Insert hooks=true at the top of the body (right after the header)
+        bodyLines.unshift("hooks = true");
+    }
+    const trimmed = trimTrailingBlanks(bodyLines);
+    const newLines = [
+        ...lines.slice(0, section.startIdx),
+        lines[section.startIdx],
+        ...trimmed,
+        ...(section.endIdx < lines.length ? [""] : []),
+        ...lines.slice(section.endIdx),
+    ];
+    const out = newLines.join("\n");
+    // Always end with a single trailing newline for true idempotency.
+    return out.endsWith("\n") ? out : out + "\n";
+}
+/**
+ * Insert or replace a `[mcp_servers.<name>]` block with the given body lines.
+ * Body lines should NOT include the header line. Idempotent.
+ */
+function upsertMcpServer(content, serverName, bodyLines) {
+    const sectionName = `mcp_servers.${serverName}`;
+    const lines = content.split("\n");
+    const section = findTomlSection(lines, sectionName);
+    const header = `[${sectionName}]`;
+    const block = [header, ...bodyLines];
+    if (section === null) {
+        return appendBlockWithSeparator(content, block);
+    }
+    // Replace existing block in place
+    const before = lines.slice(0, section.startIdx);
+    const after = lines.slice(section.endIdx);
+    const newLines = [
+        ...before,
+        ...block,
+        ...(after.length > 0 ? [""] : []),
+        ...after,
+    ];
+    const out = newLines.join("\n");
+    return out.endsWith("\n") ? out : out + "\n";
+}
+/**
+ * Remove a `[mcp_servers.<name>]` block entirely. Idempotent.
+ *
+ * Preserves the leading blank line that previously separated the removed
+ * block from the prior section — that blank stays as the separator between
+ * the prior section and whatever comes after. Collapses any consecutive
+ * blank lines that arise from the removal so we never end up with more
+ * than one blank line between sections.
+ */
+function removeMcpServer(content, serverName) {
+    const sectionName = `mcp_servers.${serverName}`;
+    const lines = content.split("\n");
+    const section = findTomlSection(lines, sectionName);
+    if (section === null) {
+        return content;
+    }
+    const newLines = [
+        ...lines.slice(0, section.startIdx),
+        ...lines.slice(section.endIdx),
+    ];
+    // Collapse any 2+ consecutive blank lines (created by the removal) to one.
+    const collapsed = [];
+    let prevBlank = false;
+    for (const line of newLines) {
+        const isBlank = line.trim().length === 0;
+        if (isBlank && prevBlank) {
+            continue;
+        }
+        collapsed.push(line);
+        prevBlank = isBlank;
+    }
+    const out = collapsed.join("\n");
+    return out.endsWith("\n") || out.length === 0 ? out : out + "\n";
+}
+/**
+ * Render a body of inline TOML key=value lines from a record. Strings get
+ * quoted, arrays of strings get inline TOML array syntax, env nested table
+ * gets emitted as an inline table.
+ */
+function tomlBodyFromRecord(record) {
+    const out = [];
+    for (const [key, value] of Object.entries(record)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (typeof value === "string") {
+            out.push(`${key} = ${JSON.stringify(value)}`);
+        }
+        else if (typeof value === "number" || typeof value === "boolean") {
+            out.push(`${key} = ${value}`);
+        }
+        else if (Array.isArray(value)) {
+            const items = value.map((v) => {
+                if (typeof v === "string") {
+                    return JSON.stringify(v);
+                }
+                if (typeof v === "number" || typeof v === "boolean") {
+                    return String(v);
+                }
+                return JSON.stringify(v);
+            });
+            out.push(`${key} = [${items.join(", ")}]`);
+        }
+        else if (typeof value === "object") {
+            const inner = value;
+            const pairs = [];
+            for (const [k, v] of Object.entries(inner)) {
+                if (v === undefined || v === null) {
+                    continue;
+                }
+                if (typeof v === "string") {
+                    pairs.push(`${k} = ${JSON.stringify(v)}`);
+                }
+                else if (typeof v === "number" || typeof v === "boolean") {
+                    pairs.push(`${k} = ${v}`);
+                }
+                else {
+                    pairs.push(`${k} = ${JSON.stringify(v)}`);
+                }
+            }
+            out.push(`${key} = { ${pairs.join(", ")} }`);
+        }
+    }
+    return out;
+}
+// ─── AGENTS.md block merge ────────────────────────────────────────────────
+exports.AGENTS_MD_START_MARKER = "<!-- ironbee:start -->";
+exports.AGENTS_MD_END_MARKER = "<!-- ironbee:end -->";
+/**
+ * Upsert the IronBee-managed block in an AGENTS.md file. The block is
+ * delimited by HTML comment markers; user content outside the markers is
+ * preserved verbatim. If markers don't exist, the block is appended.
+ */
+function upsertAgentsMdBlock(existing, blockContent) {
+    const wrapped = `${exports.AGENTS_MD_START_MARKER}\n${blockContent.trimEnd()}\n${exports.AGENTS_MD_END_MARKER}`;
+    const startIdx = existing.indexOf(exports.AGENTS_MD_START_MARKER);
+    const endIdx = existing.indexOf(exports.AGENTS_MD_END_MARKER);
+    if (startIdx >= 0 && endIdx > startIdx) {
+        const afterStart = existing.slice(0, startIdx);
+        const afterEnd = existing.slice(endIdx + exports.AGENTS_MD_END_MARKER.length);
+        return afterStart + wrapped + afterEnd;
+    }
+    if (existing.trim().length === 0) {
+        return wrapped + "\n";
+    }
+    return existing.trimEnd() + "\n\n" + wrapped + "\n";
+}
+/**
+ * Strip the IronBee-managed block from AGENTS.md. Returns null when the
+ * resulting file would be empty (caller can delete the file). Preserves
+ * any user content outside the markers.
+ */
+function stripAgentsMdBlock(existing) {
+    const startIdx = existing.indexOf(exports.AGENTS_MD_START_MARKER);
+    const endIdx = existing.indexOf(exports.AGENTS_MD_END_MARKER);
+    if (startIdx < 0 || endIdx < startIdx) {
+        return existing.trim().length === 0 ? null : existing;
+    }
+    const before = existing.slice(0, startIdx).trimEnd();
+    const after = existing.slice(endIdx + exports.AGENTS_MD_END_MARKER.length).trimStart();
+    const combined = before + (before.length > 0 && after.length > 0 ? "\n\n" : "") + after;
+    if (combined.trim().length === 0) {
+        return null;
+    }
+    return combined.endsWith("\n") ? combined : combined + "\n";
+}
+// ─── Convenience for atomic Codex config write ────────────────────────────
+function readCodexConfigToml() {
+    const p = codexConfigTomlPath();
+    if (!(0, fs_1.existsSync)(p)) {
+        return "";
+    }
+    try {
+        return (0, fs_1.readFileSync)(p, "utf-8");
+    }
+    catch (e) {
+        logger_1.logger.debug(`failed to read ${p}: ${e}`);
+        return "";
+    }
+}
+function writeCodexConfigToml(content) {
+    const p = codexConfigTomlPath();
+    try {
+        (0, fs_1.writeFileSync)(p, content);
+    }
+    catch (e) {
+        logger_1.logger.debug(`failed to write ${p}: ${e}`);
+    }
+}
+function codexConfigTomlPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), ".codex", "config.toml");
+}
+function codexHooksJsonPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), ".codex", "hooks.json");
+}
+//# sourceMappingURL=util.js.map