rea-agents 3.1.0 → 3.2.0

package/dist/application/ReferenceSourceImportPolicy.js

@@ -2,40 +2,18 @@ import { readFile, realpath, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import ignore from "ignore";
 import { err, ok } from "../domain/result.js";
-import { withinRoot } from "../reference/ReferenceSourceReaderPaths.js";
-import { DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS, DEFAULT_REFERENCE_SOURCE_LIMITS, } from "./ReferenceSourceImportTypes.js";
-import { canonicalizeConfiguredRoots } from "./ConfiguredRoots.js";
+import { DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS, } from "./ReferenceSourceImportTypes.js";
 const failure = (code, message) => ({
     tag: "reference-source-import",
     code,
     message,
 });
-const validLimits = (limits) => Object.values(limits).every((value) => Number.isSafeInteger(value) && value > 0);
-const maximumLimits = (options) => ({
-    maxBytes: options.policy.maxBytes,
-    maxEntries: options.policy.maxEntries,
-    maxDepth: options.policy.maxDepth,
-    maxPathBytes: options.policy.maxPathBytes,
-});
-const clampLimits = (requested, maximum) => ({
-    maxBytes: Math.min(requested.maxBytes, maximum.maxBytes),
-    maxEntries: Math.min(requested.maxEntries, maximum.maxEntries),
-    maxDepth: Math.min(requested.maxDepth, maximum.maxDepth),
-    maxPathBytes: Math.min(requested.maxPathBytes, maximum.maxPathBytes),
-});
-const authorizeRoot = async (requestedRoot, approvedRoots) => {
-    if (approvedRoots.length === 0)
-        return err(failure("policy", "No approved reference source roots"));
+const resolveRoot = async (requestedRoot) => {
     try {
         if (!(await stat(requestedRoot)).isDirectory())
             return err(failure("invalid-root", "Reference source root is not a directory"));
         const canonicalRoot = await realpath(resolve(requestedRoot));
-        const canonicalApprovedRoots = await canonicalizeConfiguredRoots(approvedRoots.map((approvedRoot) => resolve(approvedRoot)));
-        for (const canonicalApproved of canonicalApprovedRoots) {
-            if (withinRoot(canonicalApproved, canonicalRoot))
-                return ok(canonicalRoot);
-        }
-        return err(failure("policy", "Reference source root is outside approved roots"));
+        return ok(canonicalRoot);
     }
     catch {
         return err(failure("invalid-root", "Reference source root could not be resolved"));
@@ -56,18 +34,13 @@ const buildIgnored = async (root, excludePaths) => {
     }
     return ignored;
 };
-/** Validate limits, authorize root, and build non-executing path filters. */
+/** Resolve the caller-selected directory and build path filters. */
 export const prepareReferenceSourceImport = async (options) => {
-    const requested = options.limits ?? DEFAULT_REFERENCE_SOURCE_LIMITS;
-    const maximum = maximumLimits(options);
-    if (!validLimits(requested) || !validLimits(maximum))
-        return err(failure("invalid-limits", "Import limits must be positive integers"));
-    const root = await authorizeRoot(options.root, options.policy.roots);
+    const root = await resolveRoot(options.root);
     if (!root.ok)
         return root;
     return ok({
         root: root.value,
-        limits: clampLimits(requested, maximum),
         ignored: await buildIgnored(root.value, options.excludePaths ?? []),
         secrets: ignore().add([...options.policy.secretPatterns]),
     });

package/dist/application/ReferenceSourceImportTypes.js

@@ -5,21 +5,11 @@ export const projectReferenceSourceImportError = (error) => {
             category: "cancelled",
             message: "Reference source import was cancelled. Start it again when ready.",
         };
-    if (error.code === "invalid-limits")
-        return {
-            category: "invalid_input",
-            message: "Reference source limits are invalid. Use positive integer limits, then try again.",
-        };
     if (error.code === "invalid-root")
         return {
             category: "invalid_input",
             message: "Reference source directory could not be opened. Check that the path exists, is readable, and points to a directory.",
         };
-    if (error.code === "policy")
-        return {
-            category: "permission_required",
-            message: "Reference source directory is not approved. Add its directory to `REA_REFERENCE_ROOTS_JSON`, restart REA, then try again.",
-        };
     if (error.code === "io")
         return {
             category: "execution_failure",
@@ -41,10 +31,4 @@ export const DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS = [
     ".coverage",
     "*.log",
 ];
-export const DEFAULT_REFERENCE_SOURCE_LIMITS = {
-    maxBytes: 16 * 1024 * 1024,
-    maxEntries: 10_000,
-    maxDepth: 32,
-    maxPathBytes: 4_096,
-};
 export const PARSEABLE_REFERENCE_SOURCE_LANGUAGES = new Set(["JavaScript", "TypeScript", "JSX", "TSX"]);

package/dist/application/RuntimeExecutableDiagnostics.js

@@ -1,13 +1,10 @@
-import { execFile } from "node:child_process";
+import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { access, realpath } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 const TOOL_NAMES = ["node", "npm", "npx"];
-const MAX_CANDIDATES_PER_TOOL = 16;
-const MAX_OUTPUT_BYTES = 65_536;
-const MAX_DIAGNOSTIC_BYTES = 4_096;
 const PROBE_CONCURRENCY = 4;
-/** Inventory and bounded-probe Node toolchain candidates under one exact PATH. */
+/** Inventory and probe Node toolchain candidates under one exact PATH. */
 export const inspectRuntimeExecutables = async (options) => {
     const pathEntries = unique(options.path.split(delimiter).filter(Boolean));
     const candidates = [
@@ -37,7 +34,7 @@ export const inspectRuntimeExecutables = async (options) => {
         seen.add(key);
         uniqueCandidates.push(candidate);
     }
-    const diagnostics = await mapConcurrentBounded(uniqueCandidates, PROBE_CONCURRENCY, (candidate) => probeCandidate(candidate, options.timeoutMs ?? 5_000, options.path));
+    const diagnostics = await mapConcurrentBounded(uniqueCandidates, PROBE_CONCURRENCY, (candidate) => probeCandidate(candidate, options.timeoutMs, options.path));
     return {
         launcher_node: await canonicalPath(options.launcherNode),
         candidates: diagnostics,
@@ -56,47 +53,79 @@ const discoverToolCandidates = async (tool, pathEntries, platform, configuredExt
                 break;
             }
         }
-        if (candidates.length >= MAX_CANDIDATES_PER_TOOL)
-            break;
     }
     return candidates;
 };
 const probeCandidate = async (candidate, timeoutMs, effectivePath) => {
     const canonical = await canonicalPath(candidate.path);
     const result = await executeVersion(candidate.path, timeoutMs, effectivePath);
-    return {
+    const identity = {
         tool: candidate.tool,
         lexical_path: candidate.path,
         canonical_path: canonical,
         path_index: candidate.pathIndex,
         selection: candidate.selection,
-        version: result.ok ? result.version : null,
-        healthy: result.ok,
-        failure: result.ok ? null : result.failure,
     };
+    return result.ok
+        ? { ...identity, version: result.version, healthy: true, failure: null }
+        : {
+            ...identity,
+            version: null,
+            healthy: false,
+            failure: result.failure,
+        };
 };
 const executeVersion = (path, timeoutMs, effectivePath) => new Promise((resolve) => {
-    const child = execFile(path, ["--version"], {
-        encoding: "utf8",
-        timeout: timeoutMs,
-        maxBuffer: MAX_OUTPUT_BYTES,
+    const child = spawn(path, ["--version"], {
         windowsHide: true,
         env: environmentWithPath(effectivePath),
-    }, (cause, stdout, stderr) => {
-        if (cause === null) {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let spawnError;
+    let timeout;
+    let timedOut = false;
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk;
+    });
+    child.once("error", (cause) => {
+        spawnError = cause;
+    });
+    if (timeoutMs !== undefined && timeoutMs > 0) {
+        timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, timeoutMs);
+        timeout.unref();
+    }
+    child.once("close", () => {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        if (spawnError === undefined && child.exitCode === 0) {
             const version = firstNonemptyLine(stdout) ?? firstNonemptyLine(stderr);
-            if (version !== undefined)
+            if (version !== undefined) {
                 resolve({ ok: true, version });
-            else
-                resolve({
-                    ok: false,
-                    failure: failure("runtime_invalid_version_output", child, stderr),
-                });
+                return;
+            }
+            resolve({
+                ok: false,
+                failure: failure("runtime_invalid_version_output", child, stderr),
+            });
             return;
         }
+        const cause = spawnError ??
+            new Error("Runtime version probe did not exit successfully");
         resolve({
             ok: false,
-            failure: classifyProbeFailure(cause, child, stderr),
+            failure: timedOut
+                ? failure("runtime_timeout", child, stderr)
+                : classifyProbeFailure(cause, child, stderr),
         });
     });
 });
@@ -117,7 +146,7 @@ const failure = (code, child, stderr, dependency = null) => ({
     exit_code: child.exitCode,
     signal: child.signalCode,
     dependency,
-    stderr: bounded(stderr.trim()),
+    stderr: stderr.trim(),
 });
 const missingDynamicLibrary = (stderr) => /(?:dyld(?:\[[^\]]+\])?: )?Library not loaded:\s*([^\r\n]+)/u
     .exec(stderr)?.[1]
@@ -143,9 +172,6 @@ const firstNonemptyLine = (value) => value
     .split(/\r?\n/u)
     .find((line) => line.trim().length > 0)
     ?.trim();
-const bounded = (value) => value.length <= MAX_DIAGNOSTIC_BYTES
-    ? value
-    : value.slice(-MAX_DIAGNOSTIC_BYTES);
 const unique = (values) => [...new Set(values)];
 const environmentWithPath = (path) => {
     const environment = {};

package/dist/application/SessionProviderRouter.js

@@ -11,8 +11,8 @@ export class SessionProviderRouter {
     constructor(runtime) {
         this.runtime = runtime;
     }
-    /** Preserve the existing provider/factory seam used by focused embedders. */
-    static legacy(provider, options = {}) {
+    /** Create routing for an embedding backed by one fixed provider or factory. */
+    static single(provider, options = {}) {
         const identity = typeof provider === "function"
             ? { id: "unidentified", name: "Unidentified provider", version: null }
             : provider.identity();

package/dist/application/Setup.js

@@ -13,8 +13,7 @@ import { discoverSetupActions } from "./SetupPlan.js";
 import { clientConfigurationAligned, configureJsonClient, configureTomlClient, inspectClientConfiguration, } from "./SetupClientConfiguration.js";
 export { configureJsonClient, configureTomlClient };
 import { setupInstallFailure, } from "./SetupInstallFailure.js";
-import { providerRegistrationEnvironment, registrationPermissionEnvironment, } from "./SetupRegistrationEnvironment.js";
-export { registrationPermissionEnvironment } from "./SetupRegistrationEnvironment.js";
+import { providerRegistrationEnvironment } from "./SetupRegistrationEnvironment.js";
 export { canonicalSkillNeedsInstall, installCanonicalSkill };
 const registrationCommand = () => process.env.npm_command === "exec"
     ? PRODUCT_IDENTITY.mcpCommand.split(" ")
@@ -254,7 +253,6 @@ export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
             const diagnosis = await runDoctor(undefined, doctorHost);
             return {
                 ...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
-                ...registrationPermissionEnvironment(process.env),
                 ...(diagnosis.hopperPath === undefined
                     ? {}
                     : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }),

package/dist/application/SetupClientConfiguration.js

@@ -1,10 +1,8 @@
+import { clientConfigurationValuesEqual, parseClientConfiguration, serializeClientConfiguration, } from "./ClientConfigurationDocument.js";
 import { constants as fsConstants } from "node:fs";
 import { copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import canonicalize from "canonicalize";
-import { z } from "zod";
 import writeFileAtomic from "write-file-atomic";
-import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { MCP_STARTUP_POLICY } from "../mcpStartupPolicy.js";
 import { resolveClientConfigTransactionPath } from "./ClientConfigPath.js";
@@ -15,43 +13,43 @@ const defaultCommand = () => [
     "mcp",
 ];
 /** Back up, atomically update, and semantically read back one JSON MCP configuration. */
-export const configureJsonClient = async (client, environment = {}, command = defaultCommand()) => {
+export const configureJsonClient = (client, environment = {}, command = defaultCommand()) => configureClientDocument(client, environment, command, "json");
+/** Back up, atomically update, and semantically read back one TOML MCP configuration. */
+export const configureTomlClient = (client, environment = {}, command = defaultCommand()) => configureClientDocument(client, environment, command, "toml");
+const configureClientDocument = async (client, environment, command, format) => {
     const transactionPath = await resolveClientConfigTransactionPath(client.configPath);
     if (transactionPath === undefined)
         return { status: "failed", reason: "path" };
-    let document = {};
     let original;
     try {
         original = await readFile(transactionPath, "utf8");
-        document = parseObject(original);
     }
     catch (cause) {
         if (!isMissing(cause))
             return { status: "failed", reason: "readback" };
     }
-    let servers;
+    let parsed;
     try {
-        servers = parseOptionalObject(document.mcpServers);
+        parsed = parseClientConfiguration(original ?? (format === "toml" ? "" : "{}"), format);
     }
     catch {
         return { status: "failed", reason: "readback" };
     }
-    const desired = clientConfigurationDesired(client, normalizeProviderEnvironment(environment), command);
-    if (sameConfiguration(servers[PRODUCT_IDENTITY.mcpServerKey], desired))
+    const { document, servers, serversKey } = parsed;
+    const desired = clientConfigurationDesired(client, environment, command);
+    if (clientConfigurationValuesEqual(servers[PRODUCT_IDENTITY.mcpServerKey], desired))
         return { status: "unchanged" };
-    let backupPath;
-    if (original !== undefined) {
-        backupPath = `${client.configPath}.rea.backup`;
-        if (!(await preserveConfigBackup(transactionPath, backupPath)))
-            return { status: "failed", reason: "backup" };
-    }
-    document.mcpServers = {
+    const backupPath = original === undefined ? undefined : `${client.configPath}.rea.backup`;
+    if (backupPath !== undefined &&
+        !(await preserveConfigBackup(transactionPath, backupPath)))
+        return { status: "failed", reason: "backup" };
+    document[serversKey] = {
         ...servers,
         [PRODUCT_IDENTITY.mcpServerKey]: desired,
     };
     try {
         await mkdir(dirname(client.configPath), { recursive: true });
-        await writeFileAtomic(transactionPath, `${JSON.stringify(document, null, 2)}\n`, {
+        await writeFileAtomic(transactionPath, serializeClientConfiguration(document, format), {
             encoding: "utf8",
             mode: 0o600,
         });
@@ -60,8 +58,8 @@ export const configureJsonClient = async (client, environment = {}, command = de
         return { status: "failed", reason: "write" };
     }
     try {
-        const readback = parseObject(await readFile(transactionPath, "utf8"));
-        if (!sameConfiguration(parseOptionalObject(readback.mcpServers)[PRODUCT_IDENTITY.mcpServerKey], desired)) {
+        const readback = parseClientConfiguration(await readFile(transactionPath, "utf8"), format);
+        if (!clientConfigurationValuesEqual(readback.servers[PRODUCT_IDENTITY.mcpServerKey], desired)) {
             await restoreConfig(transactionPath, original);
             return { status: "failed", reason: "readback" };
         }
@@ -75,68 +73,13 @@ export const configureJsonClient = async (client, environment = {}, command = de
         ...(backupPath === undefined ? {} : { backupPath }),
     };
 };
-/** Back up, atomically update, and semantically read back Codex TOML configuration. */
-export const configureTomlClient = async (client, environment = {}, command = defaultCommand()) => {
-    const transactionPath = await resolveClientConfigTransactionPath(client.configPath);
-    if (transactionPath === undefined)
-        return { status: "failed", reason: "path" };
-    let document = {};
-    let original;
-    try {
-        original = await readFile(transactionPath, "utf8");
-        document = objectSchema.parse(parseToml(original));
-    }
-    catch (cause) {
-        if (!isMissing(cause))
-            return { status: "failed", reason: "readback" };
-    }
-    let servers;
-    try {
-        servers = parseOptionalObject(document.mcp_servers);
-    }
-    catch {
-        return { status: "failed", reason: "readback" };
-    }
-    const desired = clientConfigurationDesired(client, normalizeProviderEnvironment(environment), command);
-    if (sameConfiguration(servers[PRODUCT_IDENTITY.mcpServerKey], desired))
-        return { status: "unchanged" };
-    const backupPath = original === undefined ? undefined : `${client.configPath}.rea.backup`;
-    if (backupPath !== undefined &&
-        !(await preserveConfigBackup(transactionPath, backupPath)))
-        return { status: "failed", reason: "backup" };
-    document.mcp_servers = {
-        ...servers,
-        [PRODUCT_IDENTITY.mcpServerKey]: desired,
-    };
-    try {
-        await mkdir(dirname(client.configPath), { recursive: true });
-        await writeFileAtomic(transactionPath, stringifyToml(document), {
-            encoding: "utf8",
-            mode: 0o600,
-        });
-        const readback = objectSchema.parse(parseToml(await readFile(transactionPath, "utf8")));
-        if (!sameConfiguration(parseOptionalObject(readback.mcp_servers)[PRODUCT_IDENTITY.mcpServerKey], desired))
-            throw new Error("TOML readback mismatch");
-    }
-    catch {
-        await restoreConfig(transactionPath, original);
-        return { status: "failed", reason: "readback" };
-    }
-    return {
-        status: "configured",
-        ...(backupPath === undefined ? {} : { backupPath }),
-    };
-};
 /** Determine whether an existing client configuration matches the desired registration. */
 export const clientConfigurationAligned = async (client, providerEnvironment, command) => {
     const desired = clientConfigurationDesired(client, providerEnvironment, command);
     try {
         const original = await readFile(client.configPath, "utf8");
-        const document = client.format === "toml"
-            ? objectSchema.parse(parseToml(original))
-            : parseObject(original);
-        const servers = parseOptionalObject(client.format === "toml" ? document.mcp_servers : document.mcpServers);
-        return sameConfiguration(servers[PRODUCT_IDENTITY.mcpServerKey], desired);
+        const { servers } = parseClientConfiguration(original, client.format);
+        return clientConfigurationValuesEqual(servers[PRODUCT_IDENTITY.mcpServerKey], desired);
     }
     catch {
         return false;
@@ -166,11 +109,8 @@ export const inspectClientConfiguration = async (client, providerEnvironment, co
     }
     const desired = clientConfigurationDesired(client, providerEnvironment, command);
     try {
-        const document = client.format === "toml"
-            ? objectSchema.parse(parseToml(original))
-            : parseObject(original);
-        const servers = parseOptionalObject(client.format === "toml" ? document.mcp_servers : document.mcpServers);
-        if (sameConfiguration(servers[PRODUCT_IDENTITY.mcpServerKey], desired))
+        const { servers } = parseClientConfiguration(original, client.format);
+        if (clientConfigurationValuesEqual(servers[PRODUCT_IDENTITY.mcpServerKey], desired))
             return { status: "already_current" };
     }
     catch {
@@ -184,15 +124,7 @@ export const inspectClientConfiguration = async (client, providerEnvironment, co
         backupPath: `${client.configPath}.rea.backup`,
     };
 };
-const objectSchema = z.record(z.string(), z.unknown());
-const parseOptionalObject = (value) => value === undefined ? {} : objectSchema.parse(value);
-const parseObject = (text) => objectSchema.parse(JSON.parse(text));
 const isMissing = (cause) => cause instanceof Error && "code" in cause && cause.code === "ENOENT";
-const sameConfiguration = (left, right) => {
-    const encodedLeft = canonicalize(left);
-    const encodedRight = canonicalize(right);
-    return encodedLeft !== undefined && encodedLeft === encodedRight;
-};
 const preserveConfigBackup = async (source, destination) => {
     try {
         await copyFile(source, destination, fsConstants.COPYFILE_EXCL);
@@ -226,6 +158,3 @@ const clientConfigurationDesired = (client, providerEnvironment, command) => {
         ...(Object.keys(environment).length === 0 ? {} : { env: environment }),
     };
 };
-const normalizeProviderEnvironment = (environment) => typeof environment === "string"
-    ? { HOPPER_LAUNCHER_PATH: environment }
-    : environment;

package/dist/application/SetupRegistrationEnvironment.js

@@ -1,10 +1,3 @@
-/** Select explicit non-secret permission settings safe for managed MCP registrations. */
-export const registrationPermissionEnvironment = (environment) => {
-    const investigationRoots = environment.REA_INVESTIGATION_INPUT_ROOTS_JSON;
-    return investigationRoots === undefined
-        ? {}
-        : { REA_INVESTIGATION_INPUT_ROOTS_JSON: investigationRoots };
-};
 /** Select exact non-secret settings published by available providers. */
 export const providerRegistrationEnvironment = (inspections) => Object.fromEntries(inspections
     .filter(({ available }) => available)

package/dist/application/StoreFileLock.js

@@ -0,0 +1,119 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdtemp, open, readdir, rename, rm, rmdir, unlink, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
+class StoreFileLockOccupied extends Error {
+    code = "EEXIST";
+    constructor(cause) {
+        super("Store transaction lock is occupied", { cause });
+    }
+}
+/** Atomically publish a populated directory so another owner cannot replace a live lock. */
+export const createStoreFileLock = async (path) => {
+    if (await exists(path))
+        throw new StoreFileLockOccupied();
+    const staged = await mkdtemp(join(dirname(path), ".rea-store-lock-"));
+    const owner = `owner-${randomUUID()}`;
+    try {
+        const handle = await open(join(staged, owner), "wx", 0o600);
+        try {
+            await handle.writeFile(`${String(process.pid)}\n`, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        try {
+            // Rename cannot replace a nonempty directory: the owner entry is present before publication.
+            await rename(staged, path);
+        }
+        catch (cause) {
+            if (await exists(path))
+                throw new StoreFileLockOccupied(cause);
+            throw cause;
+        }
+        return {
+            release: async () => {
+                await removeOwner(path, owner).catch(() => undefined);
+            },
+        };
+    }
+    finally {
+        await rm(staged, { recursive: true, force: true });
+    }
+};
+/** Recover a dead owner's directory lock or a legacy PID file; leave live and unknown owners intact. */
+export const removeStaleStoreFileLock = async (path) => {
+    try {
+        const stats = await lstat(path);
+        if (stats.isFile()) {
+            if (!(await ownerIsDead(path)))
+                return false;
+            await unlink(path);
+            return true;
+        }
+        if (!stats.isDirectory())
+            return false;
+        const entries = await readdir(path);
+        if (entries.length === 0) {
+            await rmdir(path);
+            return true;
+        }
+        const owner = entries[0];
+        if (entries.length !== 1 ||
+            owner === undefined ||
+            !/^owner-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/u.test(owner) ||
+            !(await ownerIsDead(join(path, owner))))
+            return false;
+        await removeOwner(path, owner);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const removeOwner = async (path, owner) => {
+    // A successor has a different entry, so stale cleanup cannot make its directory empty.
+    await unlink(join(path, owner));
+    await rmdir(path);
+};
+const ownerIsDead = async (path) => {
+    const stats = await lstat(path);
+    if (!stats.isFile() || stats.size > 32)
+        return false;
+    const handle = await open(path, "r");
+    let bytes;
+    try {
+        bytes = await readBoundedFileBytes(handle, 32);
+    }
+    finally {
+        await handle.close();
+    }
+    const encoded = bytes?.toString("utf8").trim();
+    return (encoded !== undefined &&
+        /^[1-9][0-9]{0,9}$/u.test(encoded) &&
+        !processIsAlive(Number(encoded)));
+};
+const exists = async (path) => {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (cause) {
+        if (errorCode(cause) === "ENOENT")
+            return false;
+        throw cause;
+    }
+};
+const processIsAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (cause) {
+        return errorCode(cause) !== "ESRCH";
+    }
+};
+const errorCode = (cause) => typeof cause === "object" && cause !== null && "code" in cause
+    ? cause.code
+    : undefined;

package/dist/application/TerminalRenderer.js

@@ -4,8 +4,8 @@ const require = createRequire(import.meta.url);
 const HeadlessPackage = require("@xterm/headless");
 // SAFETY: the addon package is pinned with the compatible headless xterm release.
 const SerializePackage = require("@xterm/addon-serialize");
-/** Owns one headless terminal and serializes writes into deterministic frames. */
 /**
+ * Owns one headless terminal and serializes writes into deterministic frames.
  * Reconstructs bounded terminal states while raw PTY chunks remain authoritative.
  *
  * Rendered frames answer what an operator saw after control-sequence handling;
@@ -71,8 +71,7 @@ export class TerminalRenderer {
         const serializedState = this.options.normalize(this.#serializeAddon.serialize());
         const bytes = Buffer.byteLength(serializedState) +
             lines.reduce((total, line) => total + Buffer.byteLength(line), 0);
-        if (this.#frames.length >= this.options.maxFrames ||
-            this.#capturedBytes + bytes > this.options.maxBytes) {
+        if (this.#capturedBytes + bytes > this.options.maxBytes) {
             this.#truncated = true;
             return;
         }

package/dist/application/Uninstall.js

@@ -1,7 +1,7 @@
+import { parseClientConfiguration, serializeClientConfiguration, } from "./ClientConfigurationDocument.js";
 import { copyFile, lstat, readFile, realpath, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, isAbsolute, join } from "node:path";
-import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
@@ -65,9 +65,11 @@ const removeClient = async (client, fileSystem) => {
     let key;
     let servers;
     try {
-        document = objectSchema.parse(client.format === "toml" ? parseToml(original) : JSON.parse(original));
-        key = client.format === "toml" ? "mcp_servers" : "mcpServers";
-        servers = optionalObject(document[key]);
+        ({
+            document,
+            servers,
+            serversKey: key,
+        } = parseClientConfiguration(original, client.format));
     }
     catch {
         return item(client.name, "failed", `Configuration is not valid ${client.format === "toml" ? "TOML" : "JSON"} and was not changed. Repair it, then rerun uninstall.`);
@@ -88,14 +90,9 @@ const removeClient = async (client, fileSystem) => {
         return item(client.name, "failed", "Configuration could not be backed up, so no change was made. Check file permissions, then rerun uninstall.");
     }
     try {
-        const encoded = client.format === "toml"
-            ? stringifyToml(document)
-            : `${JSON.stringify(document, null, 2)}\n`;
-        await fileSystem.writeText(transactionPath, encoded);
-        const readback = objectSchema.parse(client.format === "toml"
-            ? parseToml(await fileSystem.readText(transactionPath))
-            : JSON.parse(await fileSystem.readText(transactionPath)));
-        if (PRODUCT_IDENTITY.mcpServerKey in optionalObject(readback[key]))
+        await fileSystem.writeText(transactionPath, serializeClientConfiguration(document, client.format));
+        const readback = parseClientConfiguration(await fileSystem.readText(transactionPath), client.format);
+        if (PRODUCT_IDENTITY.mcpServerKey in readback.servers)
             throw new Error("registration readback mismatch");
         return item(client.name, "removed", `Removed registration from ${client.configPath}.`);
     }
@@ -154,8 +151,6 @@ const removeManagedPath = async (path, name, fileSystem) => {
 };
 const removeManagedSkills = async (home, fileSystem) => removeManagedPath(join(home, ".agents/skills", PRODUCT_IDENTITY.skillName), "skill", fileSystem);
 const item = (name, status, detail) => ({ name, status, detail });
-const objectSchema = z.record(z.string(), z.unknown());
-const optionalObject = (value) => value === undefined ? {} : objectSchema.parse(value);
 const registrationSchema = z
     .object({ command: z.string(), args: z.array(z.string()) })
     .passthrough();