rea-agents 4.0.1 → 5.0.0

package/dist/application/ArtifactGraphConstruction.js

@@ -1,5 +1,4 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
+import { canonicalDigest } from "../domain/comparisonSemantics.js";
 import { zipPackageFormatForPath } from "../domain/zipPackageFormat.js";
 import { mzWindowsHeaderOffset, parseDosMzHeader } from "../domain/dosMz.js";
 /** Index the first occurrence for each canonical logical path. */
@@ -11,7 +10,7 @@ export const indexOccurrencesByPath = (occurrences) => {
     return byPath;
 };
 export const createOccurrence = (entry, path, parent) => ({
-    occurrence_id: `occ_${digestCanonical({ path, kind: entry.kind })}`,
+    occurrence_id: `occ_${canonicalDigest({ path, kind: entry.kind }, "Artifact")}`,
     artifact_id: null,
     parent_occurrence_id: parent,
     logical_path: path,
@@ -59,7 +58,7 @@ export const materializeDirectoryNodes = (occurrences, nodes) => {
         }))
             .sort((left, right) => compareDirectoryChildNames(left.name, right.name));
         const node = createArtifactNode({
-            sha256: digestCanonical({ kind: "directory", children }),
+            sha256: canonicalDigest({ kind: "directory", children }, "Artifact"),
             size: 0,
             kind: directory.logical_path.toLowerCase().endsWith(".framework")
                 ? "framework"
@@ -76,13 +75,13 @@ export const materializeDirectoryNodes = (occurrences, nodes) => {
 };
 export const createRootNode = (input) => createArtifactNode({
     sha256: input.digest?.sha256 ??
-        digestCanonical({
+        canonicalDigest({
             kind: "directory-root",
             children: input.occurrences.map(({ logical_path, artifact_id }) => ({
                 logical_path,
                 artifact_id,
             })),
-        }),
+        }, "Artifact"),
     size: input.digest?.bytes ?? 0,
     kind: input.directory ||
         ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(input.format)
@@ -95,7 +94,7 @@ export const createRootNode = (input) => createArtifactNode({
     contentState: "materialized",
 });
 export const createArtifactNode = (input) => ({
-    artifact_id: `art_${digestCanonical({ sha256: input.sha256 })}`,
+    artifact_id: `art_${canonicalDigest({ sha256: input.sha256 }, "Artifact")}`,
     kind: input.kind,
     format: input.format,
     sha256: input.sha256,
@@ -107,7 +106,7 @@ export const createArtifactNode = (input) => ({
     limitations: [...(input.limitations ?? [])],
 });
 export const rootOccurrenceFor = (node, declaredSize) => ({
-    occurrence_id: `occ_${digestCanonical({ root: node.artifact_id })}`,
+    occurrence_id: `occ_${canonicalDigest({ root: node.artifact_id }, "Artifact")}`,
     artifact_id: node.artifact_id,
     parent_occurrence_id: null,
     logical_path: ".",
@@ -123,11 +122,11 @@ export const rootOccurrenceFor = (node, declaredSize) => ({
 export const rekeyOccurrences = (rootArtifactId, occurrences) => {
     const replacements = new Map();
     for (const occurrence of occurrences)
-        replacements.set(occurrence.occurrence_id, `occ_${digestCanonical({
+        replacements.set(occurrence.occurrence_id, `occ_${canonicalDigest({
             root_artifact_id: rootArtifactId,
             logical_path: occurrence.logical_path,
             entry_kind: occurrence.entry_kind,
-        })}`);
+        }, "Artifact")}`);
     for (const occurrence of occurrences) {
         occurrence.occurrence_id =
             replacements.get(occurrence.occurrence_id) ?? occurrence.occurrence_id;
@@ -161,7 +160,7 @@ export const createArtifactEdges = (rootArtifactId, occurrences, producer) => {
             logical_path: occurrence.logical_path,
         };
         edges.push({
-            edge_id: `edge_${digestCanonical(semantic)}`,
+            edge_id: `edge_${canonicalDigest(semantic, "Artifact")}`,
             ...semantic,
             producer: occurrence.entry_kind === "slice" ? (producer ?? null) : null,
             ordinal: edges.length,
@@ -255,12 +254,6 @@ export const classifyArtifactContent = (path, prefix, fileSize = prefix.length)
     }
     return byPath;
 };
-export const digestCanonical = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Artifact value is not canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};
 const relationFor = (path) => {
     const lower = path.toLowerCase();
     if (lower.endsWith(".map"))

package/dist/application/ArtifactInventory/classify.js

@@ -1,6 +1,6 @@
 import { open } from "node:fs/promises";
 import { classifyArtifactContent } from "../ArtifactGraphConstruction.js";
-import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "./hash.js";
+import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "../../artifacts/ArtifactHash.js";
 import { hasZipSignature, zipPackageFormatForPath, } from "../../domain/zipPackageFormat.js";
 const classifyContainerExtension = (path) => {
     const lower = path.toLowerCase();

package/dist/application/ArtifactInventory/scanCanonical.js

@@ -2,9 +2,10 @@ import { createReadStream } from "node:fs";
 import { lstat } from "node:fs/promises";
 import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
 import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
-import { createArtifactEdges, createRootNode, digestCanonical, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "../ArtifactGraphConstruction.js";
+import { createArtifactEdges, createRootNode, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "../ArtifactGraphConstruction.js";
+import { canonicalDigest } from "../../domain/comparisonSemantics.js";
 import { classifyRoot } from "./classify.js";
-import { hashReadable } from "./hash.js";
+import { hashReadable } from "../../artifacts/ArtifactHash.js";
 import { createReader, inventoryLimitations } from "./reader.js";
 import { scanReader, } from "./scanReader.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
@@ -62,12 +63,12 @@ const buildInventorySnapshot = async (input) => {
     const orderedOccurrences = sortOccurrences(input.occurrences);
     const orderedEdges = sortEdges(edges);
     await verifyRootDigest(path, rootDigest, signal);
-    const graphSha256 = digestCanonical({
+    const graphSha256 = canonicalDigest({
         nodes: orderedNodes,
         occurrences: orderedOccurrences,
         edges: orderedEdges,
         integrity_contradictions: integrityContradictions,
-    });
+    }, "Artifact");
     const manifest = buildManifest({
         rootNode,
         graphSha256,
@@ -94,12 +95,12 @@ const buildIntegrityContradictions = (pending, occurrenceByPath, occurrenceById,
         : occurrenceById.get(occurrence.parent_occurrence_id);
     const parentArtifactId = parent?.artifact_id ?? rootNode.artifact_id;
     return {
-        contradiction_id: `ic_${digestCanonical({
+        contradiction_id: `ic_${canonicalDigest({
             root_artifact_id: rootNode.artifact_id,
             logical_path: contradiction.logicalPath,
             declared_sha256: contradiction.declaredSha256,
             observed_sha256: contradiction.observedSha256,
-        })}`,
+        }, "Artifact")}`,
         occurrence_id: occurrence.occurrence_id,
         parent_artifact_id: parentArtifactId,
         logical_path: contradiction.logicalPath,
@@ -126,10 +127,10 @@ const sortNodes = (nodes) => nodes.sort((left, right) => left.artifact_id.locale
 const sortOccurrences = (occurrences) => occurrences.sort((left, right) => left.logical_path.localeCompare(right.logical_path, "en"));
 const sortEdges = (edges) => edges.sort((left, right) => left.edge_id.localeCompare(right.edge_id));
 const buildManifest = ({ rootNode, graphSha256, orderedNodes, orderedOccurrences, orderedEdges, }) => artifactInventoryResultSchema.shape.manifest.parse({
-    manifest_id: `agm_${digestCanonical({
+    manifest_id: `agm_${canonicalDigest({
         root_artifact_id: rootNode.artifact_id,
         graph_sha256: graphSha256,
-    })}`,
+    }, "Artifact")}`,
     root_artifact_id: rootNode.artifact_id,
     root_sha256: rootNode.sha256,
     root_format: rootNode.format,

package/dist/application/ArtifactInventory/scanReader.js

@@ -4,7 +4,7 @@ import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
 import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
 import { classifyArtifactContent, createArtifactNode, createOccurrence, nearestParent, } from "../ArtifactGraphConstruction.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
-import { hashReadable } from "./hash.js";
+import { hashReadable } from "../../artifacts/ArtifactHash.js";
 const UNAVAILABLE_UNPACKED_LIMITATION = "ASAR unpacked companion bytes were unavailable; no content hash or child artifact was produced.";
 const emptyScan = () => ({ nodes: new Map(), occurrences: [], pendingContradictions: [] });
 export const scanReader = async (reader, signal, integrity = STRICT_INTEGRITY_POLICY) => {

package/dist/application/ArtifactInventory.js

@@ -1,6 +1,6 @@
 import { realpath } from "node:fs/promises";
 import { artifactInventoryResultSchema, } from "../domain/artifactGraph.js";
-import { abortIfNeeded } from "./ArtifactInventory/hash.js";
+import { abortIfNeeded } from "../artifacts/ArtifactHash.js";
 import { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
 export { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
 /** Inventory one local artifact and return every graph collection inline. */

package/dist/application/BinaryTargetResolver.js

@@ -1,22 +1,20 @@
 import { constants } from "node:fs";
 import { createHash } from "node:crypto";
-import { access, open, readFile, realpath, stat, } from "node:fs/promises";
-import { execFile } from "node:child_process";
-import { extname, isAbsolute, join, resolve } from "node:path";
-import { promisify } from "node:util";
-import { isPathWithinRoot } from "../domain/localPath.js";
-import { BinaryTargetError } from "../domain/errors.js";
+import { access, open, realpath, stat, } from "node:fs/promises";
+import { extname, isAbsolute, resolve } from "node:path";
+import { BinaryTargetError } from "../domain/configurationErrors.js";
 import { err, ok } from "../domain/result.js";
+import { resolveAppBundleExecutable, } from "./AppBundleExecutable.js";
+import { validateDosComLength, } from "../domain/dosCom.js";
 import { mzWindowsHeaderOffset } from "../domain/dosMz.js";
 import { hasZipSignature, zipPackageFormatForPath, } from "../domain/zipPackageFormat.js";
 import { parseExecutableHeader, parsePeRecord, } from "../domain/binaryTarget.js";
-const execFileAsync = promisify(execFile);
 /**
  * Resolve and classify a readable local target before a provider is selected.
  * FAT Mach-O inputs select only a host-compatible architecture so setup remains
  * non-interactive; unsupported or ambiguous inputs are returned as typed errors.
  */
-export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitecture = process.arch, targetKind) => {
+export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitecture = process.arch, targetKind, formatHint) => {
     const candidate = isAbsolute(input) ? input : resolve(cwd, input);
     try {
         await access(candidate, constants.R_OK);
@@ -24,16 +22,33 @@ export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitec
         const resolved = await resolveAppBundle(canonical);
         if (!resolved.ok)
             return err(resolved.error);
-        const path = resolved.value;
+        const { executable: path, infoPlist } = resolved.value;
+        const bundle = infoPlist === undefined ? {} : { bundleInfoPlist: infoPlist };
         const handle = await open(path, "r");
         try {
             if (!(await handle.stat()).isFile())
                 return err(new BinaryTargetError(path, "target is not a regular file"));
+            if (formatHint === "dos-com") {
+                if (targetKind !== undefined && targetKind !== "executable")
+                    return err(new BinaryTargetError(path, "DOS COM format requires an executable target kind"));
+                const length = validateDosComLength((await handle.stat()).size);
+                if (!length.ok)
+                    return err(new BinaryTargetError(path, length.error));
+                return ok({
+                    path,
+                    sourcePath: canonical,
+                    sha256: await sha256Handle(handle),
+                    kind: "executable",
+                    format: "dos-com",
+                    architecture: "x86",
+                    availableArchitectures: ["x86"],
+                });
+            }
             if (targetKind === "database" ||
                 (targetKind === undefined && path.toLowerCase().endsWith(".hop")))
                 return ok({
                     path,
-                    sourcePath: canonical,
+                    sourcePath: process.platform === "win32" ? candidate : canonical,
                     sha256: await sha256Handle(handle),
                     kind: "database",
                     format: "analysis-database",
@@ -42,7 +57,7 @@ export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitec
             if (artifactFormat !== undefined) {
                 const identity = {
                     path,
-                    sourcePath: canonical,
+                    sourcePath: process.platform === "win32" ? candidate : canonical,
                     sha256: await sha256Handle(handle),
                 };
                 return isArchiveFormat(artifactFormat)
@@ -54,7 +69,8 @@ export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitec
                 return err(new BinaryTargetError(path, detected.error));
             return ok({
                 path,
-                sourcePath: canonical,
+                sourcePath: process.platform === "win32" ? candidate : canonical,
+                ...bundle,
                 sha256: await sha256Handle(handle),
                 kind: "executable",
                 ...detected.value,
@@ -142,65 +158,13 @@ const sha256Handle = async (handle) => {
 const resolveAppBundle = async (path) => {
     const metadata = await stat(path);
     if (!metadata.isDirectory())
-        return ok(path);
+        return ok({ executable: path });
     if (extname(path).toLowerCase() !== ".app")
-        return err(new BinaryTargetError(path, "target is not an app or file"));
-    const plistPath = join(path, "Contents", "Info.plist");
-    let name;
-    try {
-        const plist = await readFile(plistPath);
-        name =
-            plist.subarray(0, 6).toString("ascii") === "bplist"
-                ? await readBinaryPlistExecutable(plistPath)
-                : parseXmlPlistExecutable(plist.toString("utf8"));
-    }
-    catch (cause) {
-        return err(new BinaryTargetError(path, "app has no readable CFBundleExecutable", {
-            cause,
+        return err(new BinaryTargetError(path, "this opening route requires a file or app bundle", {
+            constraint: "directory_requires_file",
         }));
-    }
-    if (!isSafeExecutableName(name))
-        return err(new BinaryTargetError(path, "app has an unsafe CFBundleExecutable"));
-    const programs = join(path, "Contents", "MacOS");
-    const executable = join(programs, name);
-    try {
-        const [canonicalPrograms, canonicalExecutable] = await Promise.all([
-            realpath(programs),
-            realpath(executable),
-        ]);
-        if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable))
-            return err(new BinaryTargetError(path, "app program file leaves Contents/MacOS"));
-        return ok(canonicalExecutable);
-    }
-    catch (cause) {
-        return err(new BinaryTargetError(path, "app program file is missing", { cause }));
-    }
-};
-const parseXmlPlistExecutable = (plist) => {
-    const match = /<key>\s*CFBundleExecutable\s*<\/key>\s*<string>([^<]+)<\/string>/u.exec(plist);
-    if (match?.[1] === undefined)
-        throw new Error("CFBundleExecutable is missing");
-    return decodeXml(match[1].trim());
+    return resolveAppBundleExecutable(path);
 };
-const readBinaryPlistExecutable = async (plistPath) => (await execFileAsync("/usr/bin/plutil", [
-    "-extract",
-    "CFBundleExecutable",
-    "raw",
-    "-o",
-    "-",
-    plistPath,
-])).stdout.trim();
-const isSafeExecutableName = (name) => name.length > 0 &&
-    name !== "." &&
-    name !== ".." &&
-    !name.includes("\0") &&
-    !/[/\\]/u.test(name);
-const decodeXml = (value) => value
-    .replaceAll("&amp;", "&")
-    .replaceAll("&lt;", "<")
-    .replaceAll("&gt;", ">")
-    .replaceAll("&quot;", '"')
-    .replaceAll("&apos;", "'");
 const readExecutableMetadata = async (handle, hostArchitecture) => {
     const prefix = Buffer.alloc(4096);
     const prefixRead = await handle.read(prefix, 0, prefix.length, 0);

package/dist/application/BrowserObservationService.js

@@ -1,4 +1,5 @@
-import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { err, ok } from "../domain/result.js";
 import { createBrowserEvidence } from "./BrowserEvidence.js";
 /** List browser targets within the endpoint and origin scope in the request. */

package/dist/application/BrowserScenarioCaptureService.js

@@ -1,5 +1,6 @@
 import { createBrowserScenarioEvidence } from "./BrowserScenarioEvidence.js";
-import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { err } from "../domain/result.js";
 const OPERATION = "capture_browser_scenario";
 const PROVIDER_ID = "rea-playwright-browser-scenario";

package/dist/application/BrowserScenarioEvidence.js

@@ -1,9 +1,9 @@
+import { canonicalDigest } from "../domain/comparisonSemantics.js";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { digestCanonicalJson } from "../domain/browserScenarioNormalization.js";
 const browserScenarioParameters = (scenario) => ({
-    scenario_sha256: digestCanonicalJson(scenario),
+    scenario_sha256: canonicalDigest(scenario, "Browser scenario"),
     browser_mode: scenario.browser.mode,
     ...(scenario.browser.mode === "launch"
         ? { browser_headless: scenario.browser.headless }

package/dist/application/CallPathTracing.js

@@ -1,4 +1,5 @@
-import { projectAnalysisError } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import {} from "../domain/analysisErrorBase.js";
 import { parseRelatedAddresses } from "../domain/hopperValues.js";
 import { ok } from "../domain/result.js";
 /** Trace direct caller/callee relationships until the graph is exhausted or the goal is reached. */

package/dist/application/CapabilityInventory.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { providerCapability, } from "../contracts/toolOutputSchemaPrimitives.js";
-import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
+import { TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { clientRequirementsFor, NO_CLIENT_FEATURES, } from "./CapabilityClientRequirements.js";
 const statusSchema = z.object({
     open: z.boolean(),
@@ -55,7 +55,7 @@ const NAVIGATION_CONTEXT_MODES = [
 export const buildCapabilityInventory = (sessionStatus, policy, clientFeatures = NO_CLIENT_FEATURES) => {
     const status = statusSchema.parse(sessionStatus);
     const descriptors = new Map(status.capabilities.map((descriptor) => [descriptor.operation, descriptor]));
-    return GENERATED_MCP_TOOL_CATALOG.map((contract) => {
+    return TOOL_CONTRACTS.map((contract) => {
         const availability = availabilityFor({
             name: contract.name,
             kind: contract.kind,
@@ -107,11 +107,21 @@ export const buildCapabilityInventory = (sessionStatus, policy, clientFeatures =
     }).sort((left, right) => left.name.localeCompare(right.name));
 };
 const availabilityFor = (context) => {
+    // These built-in workflows accept a caller-selected endpoint; they do not load the optional passive provider.
+    if (context.name === "observe_web_execution" ||
+        context.name === "inspect_web_event_listeners")
+        return { reason: "available", remediation: null };
     if (context.name === "get_navigation_context")
         return navigationContextAvailability(context.descriptors);
     const javascriptApplication = javascriptApplicationAvailability(context);
     if (javascriptApplication !== null)
         return javascriptApplication;
+    const failure = optionalProviderFailureFor(context);
+    if (failure !== undefined)
+        return {
+            reason: "provider_unavailable",
+            remediation: `Adapter ${failure.providerId} could not load: ${failure.reason}. Repair the adapter installation and restart REA; other capabilities remain available.`,
+        };
     const workflowAvailability = workflowAvailabilityFor(context);
     if (workflowAvailability !== null)
         return workflowAvailability;
@@ -120,6 +130,20 @@ const availabilityFor = (context) => {
         return targetDecision;
     return providerAvailability(context);
 };
+const optionalProviderFailureFor = ({ name, kind, policy, }) => {
+    const failures = policy.optionalProviderLoadFailures;
+    if (name === "capture_browser_scenario")
+        return failures?.browserScenarioCapture;
+    if (kind === "browser-provider")
+        return failures?.browserObservation;
+    if (name === "capture_electron_scenario")
+        return failures?.electronActiveObservation;
+    if (kind === "electron-provider")
+        return failures?.electronObservation;
+    if (kind === "runtime-provider")
+        return failures?.javascriptRuntimeObservation;
+    return undefined;
+};
 const javascriptApplicationAvailability = ({ name, }) => {
     if (name === "analyze_javascript_application")
         return { reason: "available", remediation: null };
@@ -128,6 +152,58 @@ const javascriptApplicationAvailability = ({ name, }) => {
         : null;
 };
 const workflowAvailabilityFor = ({ name, kind, policy, }) => {
+    if (name === "trace_web_module_imports")
+        return {
+            reason: "available",
+            remediation: null,
+            defaultModeAvailable: policy.webModuleResolutionEnabled === true,
+            modes: [
+                {
+                    name: "sources-without-literal-imports",
+                    available: true,
+                    missing_operations: [],
+                    remediation: null,
+                },
+                policy.webModuleResolutionEnabled === true
+                    ? {
+                        name: "native-literal-resolution",
+                        available: true,
+                        missing_operations: [],
+                        remediation: null,
+                    }
+                    : {
+                        name: "native-literal-resolution",
+                        available: false,
+                        missing_operations: ["native-module-resolver"],
+                        remediation: "Provide an absolute REA_BROWSER_EXECUTABLE supporting import.meta.resolve; no binary target is required.",
+                    },
+            ],
+        };
+    if (name === "recover_javascript_sources")
+        return policy.javascriptRecoveryEnabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "provider_missing",
+                remediation: "On Linux x64, provide an absolute REA_WAKARU_COMMAND for Wakaru 1.13.0 and util-linux prlimit. No binary target is required.",
+            };
+    if (kind === "firmware-provider") {
+        const enabled = name === "inspect_firmware_regions"
+            ? policy.firmwareInspectionEnabled
+            : policy.firmwareExtractionEnabled;
+        return enabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "provider_missing",
+                remediation: "On Linux, provide an absolute REA_BINWALK_COMMAND (Binwalk 3.1.x, verified with 3.1.0) or REA_UNBLOB_COMMAND (Unblob 26.6.x, verified with 26.6.4) path and util-linux prlimit. Extraction also requires the selected format’s external extractor.",
+            };
+    }
+    if (kind === "android-provider")
+        return policy.androidAnalysisEnabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "provider_missing",
+                remediation: "Set REA_JADX_MCP_JAR to a caller-supplied jadx-headless-mcp 0.7.1 JAR and provide Java on Linux or macOS. Only Linux has real-provider verification.",
+            };
     const browser = browserProviderAvailability(name, kind, policy);
     if (browser !== null)
         return browser;

package/dist/application/ClientConfigPath.js

@@ -26,7 +26,9 @@ export const resolveClientConfigTransactionPath = async (requestedPath, fileSyst
             ? canonicalPath
             : undefined;
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: unreadable or vanishing config paths mean no registration.
+        void cause;
         return undefined;
     }
 };

package/dist/application/ClientConfigurationDocument.js

@@ -31,12 +31,16 @@ const parseDocument = (text, format) => {
     if (format === "toml")
         return objectSchema.parse(parseToml(text));
     const errors = [];
-    const document = parseJsonc(text, errors, { allowTrailingComma: true });
+    // Accept a UTF-8 BOM without shifting diagnostics or editing the original text.
+    const jsonText = text.startsWith("\uFEFF") ? ` ${text.slice(1)}` : text;
+    const document = parseJsonc(jsonText, errors, { allowTrailingComma: true });
     const firstError = errors[0];
     if (firstError !== undefined)
         throw new SyntaxError(`Invalid JSON/JSONC at offset ${firstError.offset}: ${printParseErrorCode(firstError.error)}`);
     return objectSchema.parse(document);
 };
+/** Members of OpenCode V2's `mcp` object that are not server names. */
+const OPENCODE_V2_MCP_SETTINGS = new Set(["servers", "timeout"]);
 /** Parse a client document and reject malformed roots or MCP server tables. */
 export const parseClientConfiguration = (text, format) => {
     if (format === undefined || format === "unsupported")
@@ -45,27 +49,76 @@ export const parseClientConfiguration = (text, format) => {
     const serversKey = clientConfigurationServersKey(format);
     const value = document[serversKey];
     const servers = value === undefined ? {} : objectSchema.parse(value);
-    return { document, servers, serversKey };
+    const native = servers.servers;
+    // A V1 server named `servers` has a string `type` discriminator; the V2
+    // table may instead hold a server object named `type`.
+    if (format !== "opencode" ||
+        native === undefined ||
+        (typeof native === "object" &&
+            native !== null &&
+            "type" in native &&
+            typeof native.type === "string"))
+        return {
+            document,
+            servers,
+            serversPath: [serversKey],
+            dialect: format,
+            legacyServers: {},
+        };
+    return {
+        document,
+        servers: objectSchema.parse(native),
+        serversPath: [serversKey, "servers"],
+        dialect: "opencode_v2",
+        legacyServers: Object.fromEntries(Object.entries(servers).filter(([name]) => !OPENCODE_V2_MCP_SETTINGS.has(name))),
+    };
+};
+/** The registration a client loads for `name`, including OpenCode V1 entries. */
+export const effectiveClientServer = (parsed, name) => Object.hasOwn(parsed.servers, name)
+    ? parsed.servers[name]
+    : parsed.legacyServers[name];
+/**
+ * Return `parsed.document` with `servers` at its server table. A legacy OpenCode
+ * V1 member named in `removeLegacy` is removed beside a native V2 table.
+ */
+export const withClientServers = (parsed, servers, removeLegacy) => {
+    const [key = "", nested] = parsed.serversPath;
+    if (nested === undefined)
+        return { ...parsed.document, [key]: servers };
+    const outer = { ...objectSchema.parse(parsed.document[key]) };
+    if (removeLegacy !== undefined && !OPENCODE_V2_MCP_SETTINGS.has(removeLegacy))
+        delete outer[removeLegacy];
+    return { ...parsed.document, [key]: { ...outer, [nested]: servers } };
+};
+/** Read the value at a key path, or `undefined` when any member is absent. */
+const valueAt = (document, path) => {
+    let current = document;
+    for (const key of path) {
+        const object = objectSchema.safeParse(current);
+        if (!object.success || !Object.hasOwn(object.data, key))
+            return undefined;
+        current = object.data[key];
+    }
+    return current;
 };
 /** Serialize a validated client document, retaining JSONC comments. */
-export const serializeClientConfiguration = (document, format, originalText, editedServerName) => {
+export const serializeClientConfiguration = (document, format, originalText, editedPaths) => {
     if (format === undefined || format === "unsupported")
         throw new TypeError("client does not have a supported MCP config format");
     if (format === "toml")
         return stringifyToml(document);
-    if (originalText !== undefined && editedServerName !== undefined) {
-        const serversKey = clientConfigurationServersKey(format);
-        const servers = objectSchema.parse(document[serversKey] ?? {});
-        const editedValue = Object.hasOwn(servers, editedServerName)
-            ? servers[editedServerName]
-            : undefined;
-        const edits = modify(originalText, [serversKey, editedServerName], editedValue, {
+    if (originalText !== undefined && editedPaths !== undefined)
+        return editedPaths.reduce((text, path) => applyEdits(text, modify(text, [...path], valueAt(document, path), {
             formattingOptions: { insertSpaces: true, tabSize: 2, eol: "\n" },
-        });
-        return applyEdits(originalText, edits);
-    }
+        })), originalText);
     return `${JSON.stringify(document, null, 2)}\n`;
 };
+/** Key path of a named registration in the server table. */
+export const clientServerPath = (parsed, name) => [...parsed.serversPath, name];
+/** Key path of a present OpenCode V1 entry beside a native V2 table. */
+export const legacyClientServerPath = (parsed, name) => Object.hasOwn(parsed.legacyServers, name)
+    ? [parsed.serversPath[0] ?? "mcp", name]
+    : undefined;
 /** Build the stdio entry shape expected by one client's configuration dialect. */
 export const clientRegistrationEntry = (format, command, environment) => {
     const [executable = "rea", ...args] = command;
@@ -79,6 +132,15 @@ export const clientRegistrationEntry = (format, command, environment) => {
                     ? {}
                     : { environment: { ...environment } }),
             };
+        case "opencode_v2":
+            // V2 connects servers unless `disabled` is true.
+            return {
+                type: "local",
+                command: [...command],
+                ...(Object.keys(environment).length === 0
+                    ? {}
+                    : { environment: { ...environment } }),
+            };
         case "vscode":
             return {
                 type: "stdio",
@@ -94,6 +156,14 @@ export const clientRegistrationEntry = (format, command, environment) => {
                 tools: ["*"],
                 ...(Object.keys(environment).length === 0 ? {} : { env: environment }),
             };
+        case "commandcode":
+            return {
+                transport: "stdio",
+                enabled: true,
+                command: executable,
+                args,
+                ...(Object.keys(environment).length === 0 ? {} : { env: environment }),
+            };
         default:
             return {
                 command: executable,