rea-agents 6.4.0 → 6.5.0

package/dist/mcp/ArtifactProviderMetadata-b7pOK5_t.js

@@ -0,0 +1,76 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { P as init_InvestigationProviders, v as ARTIFACT_GRAPH_PROVIDER } from "./InterfaceBuilderDecodeBudget-5F2AkxJT.js";
+import { o as init_artifactToolContracts, t as ARTIFACT_ANALYSIS_OPERATIONS } from "./artifactToolContracts-Di4qZlEt.js";
+import { Readable } from "node:stream";
+
+//#region dist/filesystem/readFileHandleChunks.js
+var readFileHandleChunks, fileOffset;
+function init_readFileHandleChunks() {
+	return (init_readFileHandleChunks = __esmMin((() => {
+		readFileHandleChunks = (handle, options = {}) => {
+			const start = fileOffset(options.start ?? 0);
+			const unlimited = options.end === undefined || options.end === Infinity;
+			const end = unlimited ? undefined : fileOffset(options.end);
+			if (start === undefined || !unlimited && end === undefined || end !== undefined && end < start) throw new RangeError("Invalid file read range");
+			return Readable.from((async function* () {
+				let position = start;
+				while (end === undefined || position <= end) {
+					options.signal?.throwIfAborted();
+					const remaining = end === undefined ? undefined : end - position + 1n;
+					const chunk = Buffer.allocUnsafe(remaining === undefined || remaining > 64n * 1024n ? 64 * 1024 : Number(remaining));
+					const { bytesRead } = await handle.read(chunk, 0, chunk.length, position);
+					options.signal?.throwIfAborted();
+					if (bytesRead === 0) return;
+					position += BigInt(bytesRead);
+					yield chunk.subarray(0, bytesRead);
+				}
+			})(), {
+				objectMode: false,
+				...options.signal === undefined ? {} : { signal: options.signal }
+			});
+		};
+		fileOffset = (value) => {
+			if (typeof value === "bigint") return value >= 0n ? value : undefined;
+			return Number.isSafeInteger(value) && value >= 0 ? BigInt(value) : undefined;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/artifacts/ArtifactProviderMetadata.js
+var artifactCapabilities;
+function init_ArtifactProviderMetadata() {
+	return (init_ArtifactProviderMetadata = __esmMin((() => {
+		init_InvestigationProviders();
+		init_artifactToolContracts();
+		artifactCapabilities = (platform = process.platform) => Object.freeze(ARTIFACT_ANALYSIS_OPERATIONS.map((operation) => {
+			const common = {
+				provider: ARTIFACT_GRAPH_PROVIDER,
+				operation,
+				effects: Object.freeze({
+					mutatesArtifact: false,
+					launchesProcess: operation !== "decode_interface_builder" && operation !== "inspect_keyed_archive" && operation !== "trace_dylib_resolution",
+					mayShowUi: false,
+					mayAccessNetwork: false,
+					mayWriteFilesystem: operation === "extract_artifact" || operation === "inspect_artifact" || operation === "inventory_artifact",
+					changesPermissions: false,
+					requiresRoot: false
+				}),
+				limitations: Object.freeze(["DMG child inventory automatically uses a read-only native macOS mount; PKG remains root-hash-only.", "ASAR files discovered in filesystem-backed inventories are expanded without bulk extraction; other nested containers remain recorded only."])
+			};
+			return Object.freeze(operation === "inspect_asset_catalog" && platform !== "darwin" ? {
+				...common,
+				available: false,
+				availabilityCode: "unsupported_host",
+				reason: "Apple asset catalogs require macOS assetutil."
+			} : {
+				...common,
+				available: true,
+				reason: null
+			});
+		}));
+	})))();
+}
+
+//#endregion
+export { readFileHandleChunks as i, init_ArtifactProviderMetadata as n, init_readFileHandleChunks as r, artifactCapabilities as t };

package/dist/mcp/ArtifactReader-OyM03Gjn.js

@@ -0,0 +1,55 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+
+//#region dist/artifacts/ArtifactReader.js
+var sameArtifactSourceIdentity, copyArtifactEntry, sameArtifactEntry, ArtifactReaderFailure, combineCleanup, errorMessage;
+function init_ArtifactReader() {
+	return (init_ArtifactReader = __esmMin((() => {
+		sameArtifactSourceIdentity = (expected, observed) => expected !== undefined && observed.dev === expected.device && observed.ino === expected.inode && observed.size === expected.size && observed.mode === expected.mode && observed.mtimeNs === expected.mtimeNs && observed.ctimeNs === expected.ctimeNs;
+		copyArtifactEntry = (entry) => ({
+			...entry,
+			limitations: [...entry.limitations],
+			...entry.sourceIdentity === undefined ? {} : { sourceIdentity: { ...entry.sourceIdentity } }
+		});
+		sameArtifactEntry = (entry, produced) => entry.path === produced.path && entry.kind === produced.kind && entry.declaredSize === produced.declaredSize && entry.compressedSize === produced.compressedSize && entry.executable === produced.executable && entry.encrypted === produced.encrypted && entry.byteOffset === produced.byteOffset && entry.declaredSha256 === produced.declaredSha256 && entry.unpacked === produced.unpacked && entry.adapterKey === produced.adapterKey && entry.limitations.length === produced.limitations.length && entry.limitations.every((limitation, index) => limitation === produced.limitations[index]) && entry.sourceIdentity?.device === produced.sourceIdentity?.device && entry.sourceIdentity?.inode === produced.sourceIdentity?.inode && entry.sourceIdentity?.size === produced.sourceIdentity?.size && entry.sourceIdentity?.mode === produced.sourceIdentity?.mode && entry.sourceIdentity?.mtimeNs === produced.sourceIdentity?.mtimeNs && entry.sourceIdentity?.ctimeNs === produced.sourceIdentity?.ctimeNs;
+		ArtifactReaderFailure = class ArtifactReaderFailure extends Error {
+			reason;
+			details;
+			cleanup;
+			partialObservation;
+			constructor(reason, message, options, details) {
+				super(message, options);
+				this.reason = reason;
+				this.details = details;
+				this.name = "ArtifactReaderFailure";
+				this.cleanup = options?.cleanup;
+				this.partialObservation = options?.partialObservation;
+			}
+			/** Preserve the primary failure while attaching cleanup and any complete observation. */
+			static withCleanup(cause, cleanup, partialObservation) {
+				const primary = cause instanceof ArtifactReaderFailure ? cause : new ArtifactReaderFailure("io", errorMessage(cause), { cause });
+				const mergedObservation = partialObservation ?? primary.partialObservation;
+				return new ArtifactReaderFailure(primary.reason, primary.message, {
+					cause: primary,
+					cleanup: combineCleanup(primary.cleanup, cleanup),
+					...mergedObservation === undefined ? {} : { partialObservation: mergedObservation }
+				}, primary.details);
+			}
+			/** Give otherwise opaque cleanup failures a concrete owned resource. */
+			static cleanupObservation(cause, resource) {
+				if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined) return cause.cleanup;
+				return {
+					reason: errorMessage(cause),
+					resources: [resource]
+				};
+			}
+		};
+		combineCleanup = (primary, cleanup) => primary === undefined || primary === cleanup ? cleanup : {
+			reason: `${primary.reason}; ${cleanup.reason}`,
+			resources: [...new Set([...primary.resources, ...cleanup.resources])]
+		};
+		errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+	})))();
+}
+
+//#endregion
+export { sameArtifactSourceIdentity as a, sameArtifactEntry as i, copyArtifactEntry as n, init_ArtifactReader as r, ArtifactReaderFailure as t };

package/dist/mcp/ArtifactResourceScope-P3tq5z8Z.js

@@ -0,0 +1,162 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { rn as relationshipCoverageSchema, tn as init_relationshipCoverage } from "./nativeValueTrace-DR9UE62L.js";
+import { c as jsonValueSchema, o as init_jsonValue } from "./digests-BFoWUT_-.js";
+import { n as init_providerAdapterError, t as ProviderAdapterError } from "./providerAdapterError-sDxToNal.js";
+import { r as init_ArtifactReader, t as ArtifactReaderFailure } from "./ArtifactReader-OyM03Gjn.js";
+
+//#region dist/application/AnalysisProvider.js
+function createAnalysisExecution(result, provider, options = {}) {
+	return {
+		result: jsonValueSchema.parse(result),
+		rawResult: options.rawResult === undefined ? null : jsonValueSchema.parse(options.rawResult),
+		provider,
+		...options.analysisProfile === undefined ? {} : { analysisProfile: structuredClone(options.analysisProfile) },
+		limitations: [...options.limitations ?? []],
+		...options.relationshipCoverage === undefined ? {} : { relationshipCoverage: relationshipCoverageSchema.parse(options.relationshipCoverage) },
+		...options.referencesTruncated === undefined ? {} : { referencesTruncated: options.referencesTruncated },
+		locations: [...options.locations ?? []],
+		subject: options.subject ?? null
+	};
+}
+function init_AnalysisProvider() {
+	return (init_AnalysisProvider = __esmMin((() => {
+		init_jsonValue();
+		init_relationshipCoverage();
+	})))();
+}
+
+//#endregion
+//#region dist/domain/providerCleanupError.js
+var ProviderCleanupError;
+function init_providerCleanupError() {
+	return (init_providerCleanupError = __esmMin((() => {
+		init_providerAdapterError();
+		ProviderCleanupError = class extends ProviderAdapterError {
+			cleanupIncomplete = true;
+			cleanupResources;
+			userMessage = "Provider cleanup could not be fully confirmed. Review the reported local resources before opening another target.";
+			constructor(providerId, resources, diagnostics, options) {
+				const { operation = "close_binary", partialObservation, ...errorOptions } = options ?? {};
+				super(providerId, operation, {
+					...errorOptions,
+					...partialObservation === undefined ? {} : { partialObservation },
+					diagnostics
+				});
+				this.cleanupResources = [...resources];
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/artifacts/ArtifactResourceScope.js
+var ArtifactResourceScope, cleanup;
+function init_ArtifactResourceScope() {
+	return (init_ArtifactResourceScope = __esmMin((() => {
+		init_ArtifactReader();
+		ArtifactResourceScope = class {
+			#pending = new Set();
+			#active = new Set();
+			#draining;
+			#closed = false;
+			get hasPending() {
+				return this.#pending.size > 0;
+			}
+			/** Admit a resource operation while the scope remains open. */
+			async run(operation) {
+				while (true) {
+					if (this.#closed) throw new ArtifactReaderFailure("unavailable", "Artifact resource scope is closed");
+					if (this.#draining !== undefined) await this.#draining;
+					if (this.#closed) throw new ArtifactReaderFailure("unavailable", "Artifact resource scope is closed");
+					if (this.#pending.size > 0) {
+						await this.retryCleanup();
+						continue;
+					}
+					const running = Promise.resolve().then(operation);
+					this.#active.add(running);
+					try {
+						return await running;
+					} finally {
+						this.#active.delete(running);
+					}
+				}
+			}
+			/** Attempt cleanup now and retain the same owner if it fails. */
+			async release(owner) {
+				try {
+					await cleanup(owner);
+					this.#pending.delete(owner);
+					return { kind: "released" };
+				} catch (cause) {
+					this.#pending.add(owner);
+					return {
+						kind: "failed",
+						cause
+					};
+				}
+			}
+			/** Retry retained owners without closing resource admission. */
+			retryCleanup() {
+				if (this.#draining !== undefined) return this.#draining;
+				this.#draining = this.#drainAndRetry().finally(() => {
+					this.#draining = undefined;
+				});
+				return this.#draining;
+			}
+			/** Stop admission, wait for active operations, and retry every retained owner. */
+			close() {
+				this.#closed = true;
+				return this.retryCleanup();
+			}
+			async #drainAndRetry() {
+				while (this.#active.size > 0) await Promise.allSettled(this.#active);
+				const failures = [];
+				for (const owner of this.#pending) {
+					try {
+						await cleanup(owner);
+						this.#pending.delete(owner);
+					} catch (cause) {
+						failures.push({
+							owner,
+							cause
+						});
+					}
+				}
+				if (failures.length === 0) return;
+				const observations = failures.map(({ owner, cause }) => ArtifactReaderFailure.cleanupObservation(cause, owner.resource));
+				const resources = [...new Set(observations.flatMap(({ resources }) => resources))];
+				throw new ArtifactReaderFailure("unavailable", `Artifact cleanup remains incomplete: ${resources.join(", ")}`, {
+					cause: new AggregateError(failures.map(({ cause }) => cause), "One or more artifact resources remain owned"),
+					cleanup: {
+						reason: observations.map(({ reason }) => reason).join("; "),
+						resources
+					}
+				});
+			}
+		};
+		cleanup = async (owner) => {
+			switch (owner.kind) {
+				case "javascript-source-analysis":
+					await owner.analysis.close();
+					return;
+				case "reader":
+					await owner.reader.close();
+					return;
+				case "file-handle":
+				case "directory-handle":
+					await owner.handle.close();
+					return;
+				case "output-tree":
+					await owner.tree.rollback();
+					return;
+				case "staged-output":
+					await owner.output.close();
+					return;
+				case "private-runtime-root": await owner.root.close();
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { createAnalysisExecution as a, init_providerCleanupError as i, init_ArtifactResourceScope as n, init_AnalysisProvider as o, ProviderCleanupError as r, ArtifactResourceScope as t };

package/dist/mcp/AsarHeader-WsPgoooH.js

@@ -0,0 +1,31 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { r as init_ArtifactReader, t as ArtifactReaderFailure } from "./ArtifactReader-OyM03Gjn.js";
+
+//#region dist/artifacts/AsarHeader.js
+var MAX_ASAR_HEADER_BYTES, admitAsarHeader;
+function init_AsarHeader() {
+	return (init_AsarHeader = __esmMin((() => {
+		init_ArtifactReader();
+		MAX_ASAR_HEADER_BYTES = 16 * 1024 * 1024;
+		admitAsarHeader = async (handle) => {
+			const observed = await handle.stat();
+			if (!observed.isFile()) throw new ArtifactReaderFailure("format", "ASAR container is not a regular file");
+			const prefix = Buffer.alloc(16);
+			const read = await handle.read(prefix, 0, prefix.length, 0);
+			if (read.bytesRead !== prefix.length || prefix.readUInt32LE(0) !== 4) throw new ArtifactReaderFailure("format", "Truncated or invalid ASAR size pickle");
+			const headerBytes = prefix.readUInt32LE(4);
+			const payloadBytes = prefix.readUInt32LE(8);
+			const jsonBytes = prefix.readUInt32LE(12);
+			if (headerBytes < 8 || headerBytes > observed.size - 8 || payloadBytes !== headerBytes - 4 || jsonBytes > payloadBytes - 4) throw new ArtifactReaderFailure("format", "ASAR header leaves its container or has invalid pickle extents");
+			if (headerBytes > 16777216) throw new ArtifactReaderFailure("limit", `ASAR header exceeds the ${String(MAX_ASAR_HEADER_BYTES)} byte decode budget`);
+			return {
+				archiveBytes: observed.size,
+				headerBytes,
+				jsonBytes
+			};
+		};
+	})))();
+}
+
+//#endregion
+export { admitAsarHeader as n, init_AsarHeader as r, MAX_ASAR_HEADER_BYTES as t };

package/dist/mcp/BinarySessionStatus-B4P9gf-S.js

@@ -0,0 +1,212 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { D as PROVIDER_EFFECT_NAMES, R as init_toolOutputSchemaPrimitives } from "./nativeValueTrace-DR9UE62L.js";
+import { r as init_unicodeCodePointOrder, t as compareUnicodeCodePoints } from "./unicodeCodePointOrder-BezCbTpg.js";
+
+//#region dist/application/binary/BinaryTargetSummary.js
+var binaryTargetSummary;
+function init_BinaryTargetSummary() {
+	return (init_BinaryTargetSummary = __esmMin((() => {
+		binaryTargetSummary = (target) => ({
+			path: target.path,
+			format: target.format,
+			kind: target.kind,
+			sha256: target.sha256,
+			architecture: target.architecture ?? null,
+			...target.format === "raw-binary" ? { entry_point: target.entryPoint } : {}
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/application/binary/BinarySessionStatus.js
+var binarySessionStatus, requestActivityStatus, providerSummary, processLineageStatus, providerCapabilitySets, commonLimitationsPrefix, enabledCapabilityEffects, providerOperationHealthStatus;
+function init_BinarySessionStatus() {
+	return (init_BinarySessionStatus = __esmMin((() => {
+		init_BinaryTargetSummary();
+		init_toolOutputSchemaPrimitives();
+		init_unicodeCodePointOrder();
+		binarySessionStatus = ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, providerOperationHealth }) => {
+			const routeCapabilities = [...route.capabilities.values()].filter(({ operation }) => operation !== "inventory_artifact").sort((left, right) => compareUnicodeCodePoints(left.operation, right.operation)).map((descriptor) => {
+				const unavailable = runtimeUnavailability.get(descriptor.operation);
+				return unavailable === undefined ? descriptor : {
+					...descriptor,
+					available: false,
+					reason: unavailable.reason
+				};
+			});
+			const capabilities = providerCapabilitySets(routeCapabilities);
+			const analysisProviderBinding = route.binding === null ? null : {
+				provider: providerSummary(route.binding.identity),
+				selection_source: route.binding.selectionSource,
+				analysis_profile: structuredClone(route.binding.profile)
+			};
+			const analysisProviderCandidates = router.candidateStatuses(route).map((candidate) => ({
+				provider: providerSummary(candidate.provider),
+				availability: structuredClone(candidate.availability),
+				target_support: structuredClone(candidate.targetSupport),
+				selected: candidate.selected,
+				capabilities: providerCapabilitySets(candidate.capabilities.slice().filter(({ operation }) => operation !== "inventory_artifact").sort((left, right) => compareUnicodeCodePoints(left.operation, right.operation)))
+			}));
+			const common = {
+				capabilities,
+				analysis_provider_binding: analysisProviderBinding,
+				analysis_provider_candidates: analysisProviderCandidates,
+				analysis_run: runId === undefined ? null : {
+					run_id: runId,
+					process_lineage: processLineageStatus(runtimeLineageSnapshots)
+				},
+				analysis_activity: requestActivityStatus(requestActivitySnapshots),
+				provider_operation_health: providerOperationHealthStatus(providerOperationHealth)
+			};
+			return target === undefined ? {
+				open: false,
+				...common
+			} : {
+				open: true,
+				...common,
+				...binaryTargetSummary(target)
+			};
+		};
+		requestActivityStatus = (snapshots) => {
+			const providers = snapshots.slice().sort((left, right) => compareUnicodeCodePoints(left.provider.id, right.provider.id)).map(({ provider, active, queuedRequests }) => ({
+				provider: providerSummary(provider),
+				active: active === null ? null : {
+					request_id: active.requestId,
+					operation: active.operation,
+					elapsed_ms: active.elapsedMs,
+					caller_state: active.callerState
+				},
+				queued_requests: queuedRequests
+			}));
+			const active = snapshots.flatMap((snapshot) => snapshot.active === null ? [] : [snapshot.active]);
+			return {
+				status: snapshots.length === 0 ? "not_observed" : active.length > 0 ? "busy" : "idle",
+				providers
+			};
+		};
+		providerSummary = ({ id, name, version }) => ({
+			id,
+			name,
+			version
+		});
+		processLineageStatus = (snapshots) => snapshots.length === 0 ? { status: "not_observed" } : {
+			status: "snapshots",
+			snapshots: snapshots.slice().sort((left, right) => compareUnicodeCodePoints(left.provider.id, right.provider.id)).map(({ provider, observation }) => ({
+				provider: providerSummary(provider),
+				observation: observation.status === "unavailable" ? {
+					status: observation.status,
+					observed_at: observation.observedAt,
+					launcher_pid: observation.launcherPid,
+					process_group_id: observation.processGroupId,
+					reason: observation.reason
+				} : {
+					status: observation.status,
+					observed_at: observation.observedAt,
+					launcher_pid: observation.lineage.launcherPid,
+					launcher_parent_pid: observation.lineage.launcherParentPid,
+					process_group_id: observation.lineage.processGroupId,
+					descendants: observation.lineage.descendants.map(({ pid, parentPid, processGroupId }) => ({
+						pid,
+						parent_pid: parentPid,
+						process_group_id: processGroupId
+					}))
+				}
+			}))
+		};
+		providerCapabilitySets = (descriptors) => {
+			const providers = new Map();
+			for (const descriptor of descriptors) {
+				const key = JSON.stringify([
+					descriptor.provider.id,
+					descriptor.provider.name,
+					descriptor.provider.version
+				]);
+				const provider = providers.get(key);
+				if (provider === undefined) providers.set(key, {
+					identity: descriptor.provider,
+					descriptors: [descriptor]
+				});
+				else provider.descriptors.push(descriptor);
+			}
+			return [...providers.values()].map(({ identity, descriptors: owned }) => {
+				const sharedLimitations = commonLimitationsPrefix(owned);
+				const groups = new Map();
+				for (const descriptor of owned) {
+					const effects = enabledCapabilityEffects(descriptor);
+					const limitations = descriptor.limitations.slice(sharedLimitations.length);
+					const availabilityCode = descriptor.availabilityCode ?? null;
+					const status = descriptor.available ? {
+						available: true,
+						reason: null,
+						availability_code: null
+					} : {
+						available: false,
+						reason: descriptor.reason,
+						availability_code: availabilityCode
+					};
+					const key = JSON.stringify([
+						effects,
+						limitations,
+						status.available,
+						status.reason,
+						status.availability_code
+					]);
+					const group = groups.get(key);
+					if (group === undefined) groups.set(key, {
+						operations: [descriptor.operation],
+						effects,
+						limitations,
+						...status
+					});
+					else group.operations.push(descriptor.operation);
+				}
+				return {
+					provider: providerSummary(identity),
+					shared_limitations: sharedLimitations,
+					groups: [...groups.values()]
+				};
+			});
+		};
+		commonLimitationsPrefix = (descriptors) => {
+			const first = descriptors[0]?.limitations;
+			if (first === undefined) return [];
+			let length = first.length;
+			for (const descriptor of descriptors.slice(1)) {
+				length = Math.min(length, descriptor.limitations.length);
+				let index = 0;
+				while (index < length && first[index] === descriptor.limitations[index]) index++;
+				length = index;
+			}
+			return first.slice(0, length);
+		};
+		enabledCapabilityEffects = (descriptor) => {
+			const effectValues = {
+				mutates_artifact: descriptor.effects.mutatesArtifact,
+				launches_process: descriptor.effects.launchesProcess,
+				may_show_ui: descriptor.effects.mayShowUi,
+				may_access_network: descriptor.effects.mayAccessNetwork,
+				may_write_filesystem: descriptor.effects.mayWriteFilesystem,
+				changes_permissions: descriptor.effects.changesPermissions,
+				requires_root: descriptor.effects.requiresRoot
+			};
+			return PROVIDER_EFFECT_NAMES.filter((name) => effectValues[name]);
+		};
+		providerOperationHealthStatus = (health) => {
+			if (health === undefined || health === null) return null;
+			return {
+				state: health.state,
+				stage: health.stage,
+				retry_action: health.retryAction,
+				exit_code: health.exitCode,
+				requests: health.requests.map((request) => ({
+					request_id: request.requestId,
+					operation: request.operation,
+					stage: request.stage
+				}))
+			};
+		};
+	})))();
+}
+
+//#endregion
+export { init_BinaryTargetSummary as a, binaryTargetSummary as i, init_BinarySessionStatus as n, providerCapabilitySets as r, binarySessionStatus as t };