rea-agents 4.1.0 → 6.0.0

package/dist/android/JadxSession.js

@@ -5,13 +5,13 @@ import { jsonValueSchema } from "../domain/jsonValue.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { analyzeJadxRequest } from "./JadxAnalysis.js";
 import { JadxMcpTransport } from "./JadxMcpTransport.js";
-import { jadxLoadSchema, parseJadxEnvelope, parseJadxJson, } from "./JadxProtocol.js";
-import { JADX_RELEASE, JADX_PROVIDER_IDENTITY, JADX_LIMITATIONS, } from "./JadxRelease.js";
+import { jadxLoadSchema, jadxRuntimeSchema, parseJadxEnvelope, parseJadxJson, } from "./JadxProtocol.js";
+import { JADX_BRIDGE_IDENTITY, JADX_RELEASE, JADX_PROVIDER_IDENTITY, JADX_LIMITATIONS, } from "./JadxRelease.js";
 /** One owned engine connection; its wire protocol stays inside the Android adapter. */
 export class JadxSession {
     transport;
     #client = new Client({ name: "rea-android-adapter", version: "1" });
-    #raw = [];
+    #loaded;
     constructor(options, launcher) {
         this.transport = new JadxMcpTransport(options, launcher);
     }
@@ -24,30 +24,44 @@ export class JadxSession {
         signal.addEventListener("abort", abort, { once: true });
         try {
             signal.throwIfAborted();
-            await this.#client.connect(this.transport, { timeout: 30_000 });
+            this.transport.beginOperation();
+            const raw = [];
+            if (this.#loaded === undefined)
+                await this.#client.connect(this.transport, { timeout: 30_000 });
             const server = this.#client.getServerVersion();
-            if (server?.name !== "jadx-headless-mcp" ||
-                server.version !== JADX_RELEASE.version)
-                throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `Expected jadx-headless-mcp ${JADX_RELEASE.version}; server reported ${server?.name ?? "unknown"} ${server?.version ?? "unknown"}.`);
-            const tools = this.#tools(request, target, signal);
-            const loaded = jadxLoadSchema.parse(await tools.json("load_apk", {
-                path: snapshot,
-                threads: 1,
-                resources: "full",
-            }));
+            if (server?.name !== JADX_BRIDGE_IDENTITY.name ||
+                server.version !== JADX_BRIDGE_IDENTITY.version)
+                throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `Expected ${JADX_BRIDGE_IDENTITY.name} ${JADX_BRIDGE_IDENTITY.version}; server reported ${server?.name ?? "unknown"} ${server?.version ?? "unknown"}.`);
+            const tools = this.#tools(request, target, signal, raw);
+            const runtime = jadxRuntimeSchema.parse(await tools.json("rea_jvm_status", {}));
+            if (runtime.engine_reported_version !== JADX_RELEASE.version)
+                throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `Expected engine ${JADX_RELEASE.version}; JAR reported ${runtime.engine_reported_version}.`);
+            const loaded = this.#loaded ??
+                jadxLoadSchema.parse(await tools.json("load_apk", {
+                    path: snapshot,
+                    threads: 1,
+                    resources: "full",
+                }));
             if (loaded.apk_path !== snapshot)
                 throw new AnalysisOutputError(request.operation, "JADX loaded a different APK path than the admitted snapshot");
+            this.#loaded = loaded;
             const engine = {
                 name: "jadx-headless-mcp",
-                version: "0.7.1",
+                version: runtime.engine_reported_version,
                 artifact_sha256: jarHash,
                 source_revision: jarHash === JADX_RELEASE.sha256 ? JADX_RELEASE.revision : null,
                 worker_count: 1,
-                heap_limit_mib: 512,
+                heap_limit_mib: Math.floor(runtime.max_heap_bytes / (1024 * 1024)) || null,
             };
             const result = await analyzeJadxRequest(tools, request, loaded, engine);
             return createAnalysisExecution(result, JADX_PROVIDER_IDENTITY, {
-                rawResult: { server, jar_sha256: jarHash, calls: this.#raw },
+                rawResult: {
+                    server,
+                    bridge_sha256: context.bridgeHash,
+                    jar_sha256: jarHash,
+                    loaded,
+                    calls: raw,
+                },
                 subject: target,
                 limitations: JADX_LIMITATIONS,
                 locations: request.operation === "inspect_android_package"
@@ -68,12 +82,12 @@ export class JadxSession {
             await this.transport.close();
         }
     }
-    #tools(request, target, signal) {
+    #tools(request, target, signal, raw) {
         const call = async (name, input) => {
             signal.throwIfAborted();
             const response = await this.#client.callTool({ name, arguments: input }, { timeout: 120_000, signal });
             const envelope = parseJadxEnvelope(response, request.operation);
-            this.#raw.push({
+            raw.push({
                 operation: name,
                 input,
                 response: jsonValueSchema.parse(response),

package/dist/application/AppBundleExecutable.js

@@ -0,0 +1,141 @@
+import { execFile } from "node:child_process";
+import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { BinaryTargetError } from "../domain/configurationErrors.js";
+import { isPathWithinRoot } from "../domain/localPath.js";
+import { parseXmlPropertyList } from "../domain/propertyListKeys.js";
+import { err, ok } from "../domain/result.js";
+const execFileAsync = promisify(execFile);
+const BUNDLE_LAYOUTS = [
+    // macOS bundles keep both under Contents.
+    {
+        plist: ["Contents", "Info.plist"],
+        programs: ["Contents", "MacOS"],
+        programsLabel: "Contents/MacOS",
+    },
+    // iOS-style bundles, as extracted from an IPA, keep both at the root.
+    { plist: ["Info.plist"], programs: [], programsLabel: "the bundle root" },
+];
+/**
+ * Resolve an app bundle directory to its declared program file. macOS and
+ * flat iOS-style layouts are read directly. An iOS app installed on a Mac is
+ * a wrapper whose `Wrapper` directory holds the iOS bundle; that bundle is
+ * found by listing `Wrapper`, never by following the `WrappedBundle` link.
+ */
+export const resolveAppBundleExecutable = async (path) => {
+    const layout = await presentLayout(path);
+    if (layout !== undefined)
+        return resolveLayoutExecutable(path, layout);
+    const wrapped = await wrappedBundle(path);
+    if (wrapped !== undefined) {
+        const wrappedLayout = await presentLayout(wrapped);
+        if (wrappedLayout !== undefined)
+            return resolveLayoutExecutable(wrapped, wrappedLayout);
+    }
+    return err(new BinaryTargetError(path, "app has no readable CFBundleExecutable", {
+        cause: new Error("No Contents/Info.plist, root Info.plist, or single Wrapper/*.app bundle was found"),
+    }));
+};
+const presentLayout = async (bundle) => {
+    for (const layout of BUNDLE_LAYOUTS)
+        if (await layoutPlistPresent(join(bundle, ...layout.plist)))
+            return layout;
+    return undefined;
+};
+/**
+ * Whether a layout's Info.plist exists. Readable symlinks count, as they did
+ * when the plist was read directly; any failure other than absence, such as
+ * a permission denial, is left for the caller to report.
+ */
+const layoutPlistPresent = async (path) => {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch (cause) {
+        if (isAbsence(cause))
+            return false;
+        throw cause;
+    }
+};
+const isAbsence = (cause) => {
+    const code = cause instanceof Error ? Reflect.get(cause, "code") : undefined;
+    return code === "ENOENT" || code === "ENOTDIR";
+};
+/** The single real `.app` directory inside an iOS-on-Mac `Wrapper`. */
+const wrappedBundle = async (bundle) => {
+    const wrapper = join(bundle, "Wrapper");
+    try {
+        if (!(await lstat(wrapper)).isDirectory())
+            return undefined;
+    }
+    catch (cause) {
+        if (isAbsence(cause))
+            return undefined;
+        throw cause;
+    }
+    const apps = (await readdir(wrapper, { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name.toLowerCase().endsWith(".app"));
+    const [app] = apps;
+    return apps.length === 1 && app !== undefined
+        ? join(wrapper, app.name)
+        : undefined;
+};
+const resolveLayoutExecutable = async (bundle, layout) => {
+    const plistPath = join(bundle, ...layout.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(bundle, "app has no readable CFBundleExecutable", {
+            cause,
+        }));
+    }
+    if (!isSafeExecutableName(name))
+        return err(new BinaryTargetError(bundle, "app has an unsafe CFBundleExecutable"));
+    const programs = join(bundle, ...layout.programs);
+    const executable = join(programs, name);
+    try {
+        const [canonicalPrograms, canonicalExecutable] = await Promise.all([
+            realpath(programs),
+            realpath(executable),
+        ]);
+        if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable))
+            return err(new BinaryTargetError(bundle, `app program file leaves ${layout.programsLabel}`));
+        return ok({ executable: canonicalExecutable, infoPlist: plistPath });
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(bundle, "app program file is missing", { cause }));
+    }
+};
+/** Decode the top-level executable name with an XML parser, not a pattern. */
+const parseXmlPlistExecutable = (plist) => {
+    // An unrelated `__proto__` entry must not make the bundle unreadable.
+    const { value } = parseXmlPropertyList(plist);
+    const executable = executableEntrySchema.safeParse(value);
+    if (!executable.success)
+        throw new Error("CFBundleExecutable is missing");
+    return executable.data.CFBundleExecutable;
+};
+const executableEntrySchema = z.looseObject({ CFBundleExecutable: z.string() });
+const readBinaryPlistExecutable = async (plistPath) => 
+// `-n` strips only the newline plutil appends; it requires macOS 12+.
+(await execFileAsync("/usr/bin/plutil", [
+    "-extract",
+    "CFBundleExecutable",
+    "raw",
+    "-n",
+    "-o",
+    "-",
+    plistPath,
+])).stdout;
+const isSafeExecutableName = (name) => name.length > 0 &&
+    name !== "." &&
+    name !== ".." &&
+    !name.includes("\0") &&
+    !/[/\\]/u.test(name);

package/dist/application/BinaryTargetResolver.js

@@ -1,17 +1,14 @@
 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 { 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
@@ -25,7 +22,8 @@ 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())
@@ -72,6 +70,7 @@ export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitec
             return ok({
                 path,
                 sourcePath: process.platform === "win32" ? candidate : canonical,
+                ...bundle,
                 sha256: await sha256Handle(handle),
                 kind: "executable",
                 ...detected.value,
@@ -159,67 +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, "this opening route requires a file or macOS app bundle", {
+        return err(new BinaryTargetError(path, "this opening route requires a file or app bundle", {
             constraint: "directory_requires_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,
-        }));
-    }
-    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/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,61 @@ 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 (name === "inspect_binary_layout")
+        return policy.binaryLayoutEnabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "provider_missing",
+                remediation: "On Linux x64, set absolute REA_PWNTOOLS_PYTHON to caller-supplied Python with pwntools 4.15.0. No active binary target is required.",
+            };
+    if (name === "inspect_evm_interface")
+        return policy.evmInterfaceEnabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "provider_missing",
+                remediation: "The bundled offline EVM interface profile is currently real-verified on Linux x64. No active binary target or chain endpoint is required.",
+            };
+    if (name === "inspect_recorded_crash")
+        return policy.recordedCrashEnabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "provider_missing",
+                remediation: "On Linux x64, set absolute REA_PWNTOOLS_PYTHON to caller-supplied Python with pwntools 4.15.0. No active binary target is required.",
+            };
     if (kind === "firmware-provider") {
         const enabled = name === "inspect_firmware_regions"
             ? policy.firmwareInspectionEnabled
@@ -136,7 +215,7 @@ const workflowAvailabilityFor = ({ name, kind, policy, }) => {
             ? { reason: "available", remediation: null }
             : {
                 reason: "provider_missing",
-                remediation: "On Linux, provide an absolute REA_BINWALK_COMMAND (Binwalk 3.1.0) or REA_UNBLOB_COMMAND (Unblob 26.6.4) path and util-linux prlimit. Extraction also requires the selected format’s external extractor.",
+                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")

package/dist/application/ClientConfigurationDocument.js

@@ -39,6 +39,8 @@ const parseDocument = (text, format) => {
         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")
@@ -47,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;
@@ -81,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",

package/dist/application/ClientRegistrationStatus.js

@@ -1,4 +1,4 @@
-import { parseClientConfiguration } from "./ClientConfigurationDocument.js";
+import { effectiveClientServer, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
 import { access, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { z } from "zod";
@@ -36,8 +36,7 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
             continue;
         try {
             const content = await readFile(client.configPath, "utf8");
-            const { servers } = parseClientConfiguration(content, client.format);
-            const raw = servers[PRODUCT_IDENTITY.mcpServerKey];
+            const raw = effectiveClientServer(parseClientConfiguration(content, client.format), PRODUCT_IDENTITY.mcpServerKey);
             if (raw === undefined) {
                 statuses.push(unavailableStatus(client.name, client.configPath, "missing"));
                 continue;
@@ -63,11 +62,6 @@ const registrationAligned = (registration, client, currentCommandPath) => {
         return false;
     if (!isOwnedClientRegistrationCommand(command, currentCommandPath))
         return false;
-    if (command.length === 3 &&
-        command[2] === "mcp" &&
-        resolve(command[0] ?? "") === resolve(process.execPath) &&
-        resolve(command[1] ?? "") === currentCommandPath)
-        return true;
     if (client.name === "codex" &&
         registration.startup_timeout_sec !==
             MCP_STARTUP_POLICY.codexStartupTimeoutSeconds)
@@ -80,6 +74,11 @@ const registrationAligned = (registration, client, currentCommandPath) => {
         return false;
     if (client.format === "commandcode" && registration.transport !== "stdio")
         return false;
+    if (command.length === 3 &&
+        command[2] === "mcp" &&
+        resolve(command[0] ?? "") === resolve(process.execPath) &&
+        resolve(command[1] ?? "") === currentCommandPath)
+        return true;
     if (command.length === 4 &&
         command[0] === "npx" &&
         command[1] === "-y" &&