rea-agents 0.2.1 → 0.4.0

package/dist/hopper/HopperClient.js

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { access, mkdtemp, rm } from "node:fs/promises";
 import { createConnection } from "node:net";
 import { tmpdir } from "node:os";
@@ -57,10 +57,12 @@ export class HopperClient {
         }
         const socketPath = join(this.#directory, "bridge.sock");
         this.#token = randomBytes(32).toString("hex");
+        const runId = randomUUID();
         const launched = await this.#options.launcher.launch({
             directory: this.#directory,
             socketPath,
             token: this.#token,
+            runId,
         }, signal === undefined ? {} : { signal });
         if (!launched.ok) {
             await this.close();
@@ -81,7 +83,7 @@ export class HopperClient {
             await this.close();
             return health;
         }
-        const parsed = parseServerInfo(health.value);
+        const parsed = parseServerInfo(health.value, runId);
         if (!parsed.ok)
             await this.close();
         return parsed;
@@ -109,7 +111,13 @@ export class HopperClient {
             socket?.destroy();
             this.#socket = undefined;
             if (this.#launch?.ownsProcessLifetime === true) {
-                this.#launch.process.kill("SIGTERM");
+                if (this.#launch.cleanup !== undefined) {
+                    const cleanup = await this.#launch.cleanup();
+                    if (!cleanup.cleaned)
+                        this.#logger.warn({ reason: cleanup.reason }, "Owned launcher cleanup failed closed");
+                }
+                else
+                    this.#launch.process.kill("SIGTERM");
             }
             this.#launch = undefined;
             if (this.#directory !== undefined) {
@@ -302,12 +310,13 @@ const connectOnce = async (socketPath) => new Promise((resolve) => {
         resolve(err(new HopperStartError({ cause })));
     });
 });
-const parseServerInfo = (value) => {
+const parseServerInfo = (value, expectedRunId) => {
     if (typeof value === "object" &&
         value !== null &&
         !Array.isArray(value) &&
         value.name === "REA Hopper bridge" &&
-        typeof value.version === "string") {
+        typeof value.version === "string" &&
+        value.run_id === expectedRunId) {
         return ok({ name: value.name, version: value.version });
     }
     return err(new HopperProtocolError("Hopper bridge health result is invalid"));

package/dist/hopper/HopperProvider.js

@@ -1,36 +1,54 @@
 import { fileURLToPath } from "node:url";
+import { createAnalysisExecution } from "../application/AnalysisProvider.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/errors.js";
+import { err } from "../domain/result.js";
+import { ENHANCED_TOOL_CONTRACTS, OFFICIAL_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
 import { HopperApplicationLauncher } from "./BridgeLauncher.js";
 import { HopperClient } from "./HopperClient.js";
-const IDENTITY = {
+const IDENTITY = Object.freeze({
     id: "hopper",
     name: "Hopper Disassembler",
     version: null,
-};
-const OPERATIONS = [
-    "direct-analysis",
-    "decompilation",
-    "disassembly",
-    "cross-references",
-    "containing-procedure-resolution",
-    "procedure-references",
-    "analysis-metadata-mutation",
+});
+const MUTATING_OPERATIONS = new Set([
+    "set_address_name",
+    "set_addresses_names",
+    "set_bookmark",
+    "set_comment",
+    "set_inline_comment",
+    "unset_bookmark",
+]);
+const PROVIDER_TOOL_CONTRACTS = [
+    ...OFFICIAL_TOOL_CONTRACTS,
+    ...ENHANCED_TOOL_CONTRACTS.filter((contract) => contract.name === "analyze_function"),
 ];
-const CAPABILITIES = OPERATIONS.map((operation) => ({
-    operation,
-    version: 1,
+const CAPABILITIES = Object.freeze(PROVIDER_TOOL_CONTRACTS.map((contract) => Object.freeze({
+    provider: IDENTITY,
+    operation: contract.name,
+    inputContractVersion: 1,
+    outputContractVersion: 1,
     available: true,
-    pagination: "none",
+    reason: null,
+    pagination: "offset" in contract.inputSchema.shape ? "offset" : "none",
     exhaustive: false,
-    effects: {
-        mutatesArtifact: operation === "analysis-metadata-mutation",
+    effects: Object.freeze({
+        mutatesArtifact: MUTATING_OPERATIONS.has(contract.name),
         launchesProcess: true,
         mayShowUi: true,
         mayAccessNetwork: false,
-        mayWriteFilesystem: operation === "analysis-metadata-mutation",
-        requiresPrivileges: false,
-    },
-    limitations: ["Results depend on Hopper's completed static analysis."],
-}));
+        mayWriteFilesystem: MUTATING_OPERATIONS.has(contract.name),
+        changesPermissions: false,
+        requiresRoot: false,
+    }),
+    limits: Object.freeze({
+        maxResults: null,
+        maxPayloadBytes: null,
+        timeoutMs: null,
+    }),
+    limitations: Object.freeze([
+        "Results depend on Hopper's completed static analysis.",
+    ]),
+})));
 /** Concrete analysis provider backed by REA's private Hopper bridge. */
 export class HopperProvider {
     config;
@@ -46,6 +64,11 @@ export class HopperProvider {
         return CAPABILITIES;
     }
     createClient(target) {
+        if (target.kind !== "executable" && target.kind !== "database")
+            return {
+                execute: (operation) => Promise.resolve(err(new AnalysisCapabilityUnavailableError(IDENTITY.id, operation, `Hopper cannot open ${target.kind} targets directly. Inventory or extract the artifact first.`))),
+                close: () => Promise.resolve(),
+            };
         const client = new HopperClient({
             launcher: new HopperApplicationLauncher({
                 launcherPath: this.config.hopperLauncherPath,
@@ -59,7 +82,19 @@ export class HopperProvider {
             logger: this.logger.child({ layer: "bridge" }),
         });
         return {
-            execute: (operation, parameters, options) => client.callTool(operation, parameters, options),
+            execute: async (operation, parameters, options) => {
+                const result = await client.callTool(operation, parameters, options);
+                return result.ok
+                    ? {
+                        ok: true,
+                        value: createAnalysisExecution(result.value, IDENTITY, {
+                            limitations: [
+                                "Results depend on Hopper's completed static analysis.",
+                            ],
+                        }),
+                    }
+                    : result;
+            },
             close: () => client.close(),
         };
     }

package/dist/identity.js

@@ -10,5 +10,6 @@ export const PRODUCT_IDENTITY = {
     mcpCommand: "npx -y rea-agents mcp",
     mcpServerKey: "rea",
     skillName: "rea-analysis",
+    skillVersion: "10",
     configFileName: "rea.json",
 };

package/dist/main.js

@@ -33,7 +33,11 @@ export const run = async () => {
     }
     let handle;
     try {
-        handle = serveStdio(() => createServer(session, session, logger, config.value.processExecutionPolicy), {
+        handle = serveStdio(() => createServer(session, session, {
+            logger,
+            processPolicy: config.value.processExecutionPolicy,
+            evidenceFilePolicy: config.value.evidenceFilePolicy,
+        }), {
             onerror: () => {
                 serverLogger.error("MCP stdio transport error");
                 process.stderr.write("MCP stdio transport error\n");

package/dist/native/CommandRunner.js

@@ -0,0 +1,156 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { err, ok } from "../domain/result.js";
+export class NativeCommandFailure extends Error {
+    tool;
+    reason;
+    exitCode;
+    constructor(tool, reason, exitCode = null, options) {
+        super(`Native command ${tool} failed: ${reason}`, options);
+        this.tool = tool;
+        this.reason = reason;
+        this.exitCode = exitCode;
+    }
+}
+/** Run allowlisted Xcode tools directly with bounded output and no shell. */
+export class XcrunCommandRunner {
+    #resolved = new Map();
+    run(tool, arguments_, options) {
+        if (!ALLOWED_TOOLS.has(tool))
+            return Promise.resolve(err(new NativeCommandFailure(tool, "unavailable")));
+        return this.#resolve(tool).then(async (resolved) => {
+            if (!resolved.ok)
+                return resolved;
+            const captured = await captureProcess(resolved.value.path, arguments_, tool, options);
+            return captured.ok
+                ? ok({
+                    ...captured.value,
+                    tool,
+                    executable: resolved.value.path,
+                    executableSha256: resolved.value.sha256,
+                    toolVersion: null,
+                    versionReason: "Tool exposes no uniform stable version flag; executable digest identifies it.",
+                    arguments: [...arguments_],
+                })
+                : captured;
+        });
+    }
+    #resolve(tool) {
+        const existing = this.#resolved.get(tool);
+        if (existing !== undefined)
+            return existing;
+        const pending = resolveTool(tool);
+        this.#resolved.set(tool, pending);
+        return pending;
+    }
+}
+const ALLOWED_TOOLS = new Set([
+    "codesign",
+    "dyld_info",
+    "dwarfdump",
+    "file",
+    "lipo",
+    "nm",
+    "otool",
+    "plutil",
+    "strings",
+    "swift-demangle",
+    "vtool",
+]);
+const resolveTool = async (tool) => {
+    const found = await captureProcess("/usr/bin/xcrun", ["--find", tool], "xcrun", { timeoutMs: 5_000, maxOutputBytes: 64 * 1024 });
+    if (!found.ok || found.value.exitCode !== 0)
+        return err(new NativeCommandFailure(tool, "unavailable"));
+    const candidate = found.value.stdout.trim();
+    if (!candidate.startsWith("/"))
+        return err(new NativeCommandFailure(tool, "unavailable"));
+    try {
+        const path = await realpath(candidate);
+        return ok({ path, sha256: await hashFile(path) });
+    }
+    catch (cause) {
+        return err(new NativeCommandFailure(tool, "io", null, { cause }));
+    }
+};
+const captureProcess = (executable, arguments_, tool, options) => new Promise((resolve) => {
+    if (options.signal?.aborted === true) {
+        resolve(err(new NativeCommandFailure(tool, "cancelled")));
+        return;
+    }
+    const runToken = randomUUID();
+    const child = spawn(executable, [...arguments_], {
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+            PATH: "/usr/bin:/bin:/usr/sbin:/sbin",
+            LC_ALL: "C",
+            LANG: "C",
+            REA_NATIVE_RUN_TOKEN: runToken,
+        },
+    });
+    const stdout = [];
+    const stderr = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let settled = false;
+    let reason;
+    const finish = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timeout);
+        options.signal?.removeEventListener("abort", onAbort);
+        resolve(result);
+    };
+    const stop = (failure) => {
+        reason ??= failure;
+        child.kill("SIGKILL");
+    };
+    const onAbort = () => stop("cancelled");
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timeout = setTimeout(() => stop("timeout"), options.timeoutMs);
+    child.stdout.on("data", (chunk) => {
+        stdoutBytes += chunk.length;
+        if (stdoutBytes + stderrBytes > options.maxOutputBytes)
+            stop("output-limit");
+        else
+            stdout.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+        stderrBytes += chunk.length;
+        if (stdoutBytes + stderrBytes > options.maxOutputBytes)
+            stop("output-limit");
+        else
+            stderr.push(chunk);
+    });
+    child.once("error", (cause) => finish(err(new NativeCommandFailure(tool, "io", null, { cause }))));
+    child.once("close", (code, signal) => {
+        if (reason !== undefined) {
+            finish(err(new NativeCommandFailure(tool, reason, code)));
+            return;
+        }
+        if (code !== 0 && options.acceptNonZero !== true) {
+            finish(err(new NativeCommandFailure(tool, "nonzero-exit", code)));
+            return;
+        }
+        finish(ok({
+            stdout: Buffer.concat(stdout).toString("utf8"),
+            stderr: Buffer.concat(stderr).toString("utf8"),
+            stdoutBytes,
+            stderrBytes,
+            stdoutTruncated: false,
+            stderrTruncated: false,
+            exitCode: code,
+            signal,
+        }));
+    });
+});
+const hashFile = (path) => new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(path);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.once("error", reject);
+    stream.once("end", () => resolve(hash.digest("hex")));
+});

package/dist/native/NativeMacOSProvider.js

@@ -0,0 +1,306 @@
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { realpath, stat } from "node:fs/promises";
+import { parse as parseXmlPlist } from "plist";
+import { z } from "zod";
+import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
+import { NATIVE_TOOL_CONTRACTS, } from "../contracts/nativeToolContracts.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisTimeoutError, ProviderAdapterError, } from "../domain/errors.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { demangleSwiftSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/nativeInspection.js";
+import { err, ok } from "../domain/result.js";
+import { NativeCommandFailure, XcrunCommandRunner, } from "./CommandRunner.js";
+import { parseCodeSignature } from "./parsers/codesign.js";
+import { parseDemangledSymbols } from "./parsers/demangle.js";
+import { parseLipoArchitectures } from "./parsers/lipo.js";
+import { parsePlistJson } from "./parsers/plist.js";
+import { architectureLocations, inspectNativeMacho, } from "./NativeMachoInspection.js";
+const IDENTITY = Object.freeze({
+    id: "native-macos",
+    name: "macOS native inspection utilities",
+    version: null,
+});
+const TIMEOUT_MS = 30_000;
+const OUTPUT_LIMIT = 4 * 1024 * 1024;
+/** Read-only semantic provider composed from Xcode command-line utilities. */
+export class NativeMacOSProvider {
+    runner;
+    #capabilities;
+    constructor(runner = new XcrunCommandRunner(), platform = process.platform) {
+        this.runner = runner;
+        const available = platform === "darwin";
+        this.#capabilities = Object.freeze(NATIVE_TOOL_CONTRACTS.map((contract) => {
+            const availability = available
+                ? { available: true, reason: null }
+                : {
+                    available: false,
+                    reason: "Native macOS utilities require macOS.",
+                };
+            return Object.freeze({
+                provider: IDENTITY,
+                operation: contract.name,
+                inputContractVersion: 1,
+                outputContractVersion: 1,
+                ...availability,
+                pagination: "none",
+                exhaustive: contract.name !== "inspect_macho",
+                effects: Object.freeze({
+                    mutatesArtifact: false,
+                    launchesProcess: true,
+                    mayShowUi: false,
+                    mayAccessNetwork: false,
+                    mayWriteFilesystem: false,
+                    changesPermissions: false,
+                    requiresRoot: false,
+                }),
+                limits: Object.freeze({
+                    maxResults: contract.name === "demangle_swift" ? 500 : null,
+                    maxPayloadBytes: OUTPUT_LIMIT,
+                    timeoutMs: TIMEOUT_MS,
+                }),
+                limitations: Object.freeze([
+                    "Availability and textual formats depend on the installed macOS/Xcode toolchain.",
+                ]),
+            });
+        }));
+    }
+    identity() {
+        return IDENTITY;
+    }
+    capabilities() {
+        return this.#capabilities;
+    }
+    createClient(target) {
+        return new NativeMacOSClient(target, this.runner);
+    }
+}
+class NativeMacOSClient {
+    target;
+    runner;
+    constructor(target, runner) {
+        this.target = target;
+        this.runner = runner;
+    }
+    async execute(operation, parameters, options) {
+        if (operation === "health")
+            return ok(createAnalysisExecution(null, IDENTITY));
+        if (!isNativeOperation(operation))
+            return err(new AnalysisCapabilityUnavailableError(IDENTITY.id, operation, "Operation is not implemented by native macOS tools."));
+        try {
+            const observation = await this.#dispatch(operation, parameters, options?.signal);
+            return observation.ok
+                ? ok(createAnalysisExecution(observation.value.result, IDENTITY, {
+                    rawResult: { provenance: observation.value.provenance },
+                    limitations: observation.value.limitations,
+                    locations: observation.value.locations,
+                }))
+                : observation;
+        }
+        catch (cause) {
+            return err(new AnalysisOutputError(operation, "Native output parsing failed", {
+                cause,
+            }));
+        }
+    }
+    close() {
+        return Promise.resolve();
+    }
+    #dispatch(operation, parameters, signal) {
+        switch (operation) {
+            case "inspect_macho":
+                return this.#inspectMacho(signal);
+            case "inspect_signature":
+                return this.#inspectSignature(signal);
+            case "inspect_plist":
+                return this.#inspectPlist(parameters, signal);
+            case "list_architectures":
+                return this.#listArchitectures(signal);
+            case "demangle_swift":
+                return this.#demangle(parameters, signal);
+        }
+    }
+    async #listArchitectures(signal) {
+        const capture = await this.#run("list_architectures", "lipo", ["-detailed_info", this.target.path], { signal });
+        if (!capture.ok)
+            return capture;
+        const provenance = [invocation(capture.value, this.target.path)];
+        const result = listArchitecturesSchema.parse({
+            architectures: {
+                items: parseLipoArchitectures(capture.value.stdout),
+                total: parseLipoArchitectures(capture.value.stdout).length,
+                exhaustive: true,
+                limitations: [],
+            },
+            provenance,
+            limitations: [],
+        });
+        return ok({
+            result: jsonValueSchema.parse(result),
+            provenance,
+            limitations: [],
+            locations: architectureLocations(result.architectures.items),
+        });
+    }
+    async #demangle(parameters, signal) {
+        const symbols = z.array(z.string()).safeParse(parameters.symbols);
+        if (!symbols.success)
+            return err(new AnalysisOutputError("demangle_swift", "symbols were not parsed strings"));
+        const capture = await this.#run("demangle_swift", "swift-demangle", ["--compact", ...symbols.data], { signal });
+        if (!capture.ok)
+            return capture;
+        const provenance = [invocation(capture.value, this.target.path)];
+        const result = demangleSwiftSchema.parse({
+            symbols: parseDemangledSymbols(symbols.data, capture.value.stdout),
+            provenance,
+            limitations: [],
+        });
+        return ok({
+            result: jsonValueSchema.parse(result),
+            provenance,
+            limitations: [],
+            locations: [],
+        });
+    }
+    async #inspectSignature(signal) {
+        const display = await this.#run("inspect_signature", "codesign", ["-d", "--verbose=4", this.target.path], { signal, acceptNonZero: true });
+        if (!display.ok)
+            return display;
+        const requirements = await this.#run("inspect_signature", "codesign", ["-d", "-r-", this.target.path], { signal, acceptNonZero: true });
+        if (!requirements.ok)
+            return requirements;
+        const entitlements = await this.#run("inspect_signature", "codesign", ["-d", "--entitlements", ":-", this.target.path], { signal, acceptNonZero: true });
+        if (!entitlements.ok)
+            return entitlements;
+        const unsigned = /not signed at all|code object is not signed/iu.test(`${display.value.stdout}\n${display.value.stderr}`);
+        const parsed = parseCodeSignature(`${display.value.stdout}\n${display.value.stderr}`, unsigned);
+        const requirementText = /designated\s*=>\s*(.+)$/mu.exec(`${requirements.value.stdout}\n${requirements.value.stderr}`)?.[1] ?? null;
+        const entitlementValue = parseEntitlements(`${entitlements.value.stdout}\n${entitlements.value.stderr}`);
+        const provenance = [
+            display.value,
+            requirements.value,
+            entitlements.value,
+        ].map((capture) => invocation(capture, this.target.path));
+        const result = inspectSignatureSchema.parse({
+            ...parsed,
+            designated_requirement: requirementText,
+            entitlements: entitlementValue,
+            provenance,
+        });
+        return ok({
+            result: jsonValueSchema.parse(result),
+            provenance,
+            limitations: result.limitations,
+            locations: [],
+        });
+    }
+    async #inspectPlist(parameters, signal) {
+        const requested = parameters.relative_path;
+        if (typeof requested !== "string")
+            return err(new AnalysisOutputError("inspect_plist", "relative_path was not a string"));
+        const plist = await resolvePlistPath(this.target, requested);
+        if (!plist.ok)
+            return plist;
+        const classified = await this.#run("inspect_plist", "file", ["-b", plist.value], { signal });
+        if (!classified.ok)
+            return classified;
+        const capture = await this.#run("inspect_plist", "plutil", ["-convert", "json", "-o", "-", "--", plist.value], { signal });
+        if (!capture.ok)
+            return capture;
+        const parsed = parsePlistJson(capture.value.stdout);
+        const provenance = [classified.value, capture.value].map((item) => invocation(item, plist.value, "$PLIST"));
+        const result = inspectPlistSchema.parse({
+            format: /binary property list/iu.test(classified.value.stdout)
+                ? "binary"
+                : /XML|text/iu.test(classified.value.stdout)
+                    ? "xml"
+                    : "unknown",
+            ...parsed,
+            source_path: requested,
+            provenance,
+            limitations: [],
+        });
+        return ok({
+            result: jsonValueSchema.parse(result),
+            provenance,
+            limitations: [],
+            locations: [{ kind: "artifact-path", path: requested }],
+        });
+    }
+    async #inspectMacho(signal) {
+        if (this.target.format !== "mach-o")
+            return err(new AnalysisCapabilityUnavailableError(IDENTITY.id, "inspect_macho", "Active artifact is not Mach-O."));
+        return inspectNativeMacho({
+            target: this.target,
+            ...(signal === undefined ? {} : { signal }),
+            run: (tool, arguments_, commandSignal) => this.#run("inspect_macho", tool, arguments_, {
+                signal: commandSignal,
+            }),
+            invocation: (capture) => invocation(capture, this.target.path),
+        });
+    }
+    async #run(operation, tool, arguments_, options = {}) {
+        const captured = await this.runner.run(tool, arguments_, {
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            timeoutMs: TIMEOUT_MS,
+            maxOutputBytes: OUTPUT_LIMIT,
+            acceptNonZero: options.acceptNonZero ?? false,
+        });
+        if (captured.ok)
+            return captured;
+        return err(translateCommandFailure(operation, captured.error));
+    }
+}
+const isNativeOperation = (operation) => NATIVE_TOOL_CONTRACTS.some(({ name }) => name === operation);
+const translateCommandFailure = (operation, failure) => {
+    if (failure.reason === "unavailable")
+        return new AnalysisCapabilityUnavailableError(IDENTITY.id, operation, `${failure.tool} is unavailable through xcrun.`);
+    if (failure.reason === "cancelled")
+        return new AnalysisCancelledError(operation);
+    if (failure.reason === "timeout")
+        return new AnalysisTimeoutError(operation, TIMEOUT_MS);
+    return new ProviderAdapterError(IDENTITY.id, operation, { cause: failure });
+};
+const invocation = (capture, artifactPath, alias = "$ARTIFACT") => ({
+    tool: capture.tool,
+    command: [
+        capture.executable,
+        ...capture.arguments.map((argument) => argument === artifactPath ? alias : argument),
+    ],
+    tool_version: capture.toolVersion,
+    version_reason: capture.versionReason,
+    executable_sha256: capture.executableSha256,
+    exit: { code: capture.exitCode, signal: capture.signal },
+    stdout_bytes: capture.stdoutBytes,
+    stderr_bytes: capture.stderrBytes,
+    stdout_truncated: capture.stdoutTruncated,
+    stderr_truncated: capture.stderrTruncated,
+});
+const parseEntitlements = (output) => {
+    const start = output.indexOf("<?xml");
+    const end = output.lastIndexOf("</plist>");
+    if (start < 0 || end < start)
+        return null;
+    return jsonValueSchema.parse(parseXmlPlist(output.slice(start, end + "</plist>".length)));
+};
+const resolvePlistPath = async (target, requested) => {
+    try {
+        const source = target.sourcePath ?? target.path;
+        const sourceMetadata = await stat(source);
+        const root = sourceMetadata.isDirectory() ? source : dirname(target.path);
+        const candidate = resolve(root, requested);
+        if (!within(root, candidate))
+            return err(new ProviderAdapterError(IDENTITY.id, "inspect_plist"));
+        const canonicalRoot = await realpath(root);
+        const canonical = await realpath(candidate);
+        if (!within(canonicalRoot, canonical))
+            return err(new ProviderAdapterError(IDENTITY.id, "inspect_plist"));
+        return ok(canonical);
+    }
+    catch (cause) {
+        return err(new ProviderAdapterError(IDENTITY.id, "inspect_plist", { cause }));
+    }
+};
+const within = (root, candidate) => {
+    const child = relative(root, candidate);
+    return (child === "" ||
+        (!child.startsWith(`..${sep}`) && child !== ".." && !isAbsolute(child)));
+};