reverseport 0.0.0-stage → 1.0.0

package/dist/cli-runtime/managedToolContracts-BSy4TRaK.js

@@ -0,0 +1,80 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { err, init_localPath, init_result, localPathStringSchema, ok } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { init_toolEffects, init_toolOutputSchemaGroups, init_toolOutputSchemaPrimitives, managedOutputSchemas, requireOutputSchema, toolContractMetadata } from "./toolEffects-DW31yTSx.js";
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+
+//#region dist/domain/dosCom.js
+var executableFormatHintSchema, validateDosComLength;
+function init_dosCom() {
+	return (init_dosCom = __esmMin((() => {
+		init_result();
+		executableFormatHintSchema = z.enum(["dos-com", "raw-binary"]);
+		validateDosComLength = (length) => Number.isSafeInteger(length) && length >= 1 && length <= 65280 ? ok(null) : err("DOS COM requires 1..65280 file bytes (64 KiB segment minus the 256-byte PSP prefix)");
+	})))();
+}
+
+//#endregion
+//#region dist/contracts/managed/managedToolContracts.js
+var managedTargetInputSchema, managedMembersInputSchema, outputSchema, memberOutputSchema, nativeBoundaryOutputSchema, MANAGED_TOOL_CONTRACTS, isManagedToolName;
+function init_managedToolContracts() {
+	return (init_managedToolContracts = __esmMin((() => {
+		init_toolOutputSchemaGroups();
+		init_toolEffects();
+		init_toolOutputSchemaPrimitives();
+		init_localPath();
+		managedTargetInputSchema = z.strictObject({ path: localPathStringSchema.refine(isAbsolute, { message: "path must be an absolute local filesystem path (for example /tmp/Example.dll or C:\\Example.dll)" }).describe("Explicit absolute managed PE/CLI path; omit to reuse the previously selected managed target").optional() });
+		managedMembersInputSchema = managedTargetInputSchema.extend({ type_names: z.array(z.string().min(1).describe("Exact declaring-type full_name: namespace-qualified for top-level types (System.Threading.Monitor); nested types report their bare name, so it selects every nested type of that name")).min(1).refine((names) => new Set(names).size === names.length, { message: "type_names must not repeat a name" }).meta({ uniqueItems: true }).describe("Inspect only the fields, methods, call edges, and field accesses declared by these exact type full names; omit to inspect every type. Unmatched names are reported in selection.unmatched_type_names.").optional() });
+		outputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_artifact");
+		memberOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_members");
+		nativeBoundaryOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_native_boundaries");
+		MANAGED_TOOL_CONTRACTS = [
+			{
+				name: "inspect_managed_artifact",
+				...toolContractMetadata("inspect_managed_artifact"),
+				description: "Open and classify an explicit managed PE/CLI path, or inspect the active managed target, then inventory exact assembly/module identity, target framework evidence, references, resources, and custom attributes without loading or executing target code. Returns complete inline inventories when metadata is admitted and explicit partial or malformed coverage otherwise.",
+				kind: "managed-provider",
+				inputSchema: managedTargetInputSchema,
+				outputSchema,
+				examples: [{
+					title: "Example inspect managed artifact request",
+					input: { path: "/tmp/Example.dll" }
+				}]
+			},
+			{
+				name: "inspect_managed_members",
+				...toolContractMetadata("inspect_managed_members"),
+				description: "Inspect PE/CLI metadata members, signatures, raw CIL hashes, decoded-instruction-tuple hashes, separately reported exception regions, call edges, and field-access anchors without loading or executing target code. Select type_names to decode only the members of those exact declaring types, which keeps large assemblies such as a base class library within the representation budget. Metadata tokens are reported as build-local coordinates bound to the artifact SHA-256 and MVID; the tuple hash does not resolve them or fully commit control flow.",
+				kind: "managed-provider",
+				inputSchema: managedMembersInputSchema,
+				outputSchema: memberOutputSchema,
+				examples: [{
+					title: "Example inspect managed members request",
+					input: {}
+				}, {
+					title: "Example inspect selected managed types request",
+					input: {
+						path: "/tmp/mscorlib.dll",
+						type_names: ["System.Threading.Monitor"]
+					}
+				}]
+			},
+			{
+				name: "inspect_managed_native_boundaries",
+				...toolContractMetadata("inspect_managed_native_boundaries"),
+				description: "Inspect PE/CLI ModuleRef, ImplMap/PInvoke declarations, CLI native-header indicators, and non-IL method implementation flags without loading or executing target code. Results are managed declarations and degraded native-boundary observations, not verified native exports or addresses.",
+				kind: "managed-provider",
+				inputSchema: managedTargetInputSchema,
+				outputSchema: nativeBoundaryOutputSchema,
+				examples: [{
+					title: "Example inspect managed/native boundary request",
+					input: {}
+				}]
+			}
+		];
+		isManagedToolName = (name) => MANAGED_TOOL_CONTRACTS.some((contract) => contract.name === name);
+	})))();
+}
+
+//#endregion
+export { MANAGED_TOOL_CONTRACTS, executableFormatHintSchema, init_dosCom, init_managedToolContracts, isManagedToolName, managedMembersInputSchema, managedTargetInputSchema, validateDosComLength };

package/dist/cli-runtime/mcpDoctor.js

@@ -0,0 +1,342 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { PRODUCT_IDENTITY, err, init_identity, init_result, ok } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { CATALOG_IDENTITY, PROMPT_CONTRACTS, init_catalogIdentity, init_promptContracts } from "./catalogIdentity-EYVhBUYJ.js";
+import { TOOL_CONTRACTS, init_toolContracts } from "./toolContracts-C7pvYKxF.js";
+import { MCP_STARTUP_POLICY, init_mcpStartupPolicy } from "./mcpStartupPolicy-Bb7TMLzn.js";
+import { Formatter, Help, z } from "incur";
+import { resolve } from "node:path";
+import { Client } from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+
+//#region dist/mcpDoctor.js
+var OUTPUT_FORMATS, MCP_DOCTOR_OPTIONS, MCP_DOCTOR_ALIAS, MCP_DOCTOR_COMMAND, MCP_DOCTOR_DESCRIPTION, HELP_FLAGS, renderMcpDoctorHelp, runProductionMcpDoctor, inspectProductionMcpSession, runProductionMcpDoctorCli, compareInventory, inventoryCheck, parseIdentityToolResult, parseOutputArguments, hasHelpInOptionPosition, isOutputFormat, requestOptions, targetFreeEnvironment, captureStderr, isRecord, errorMessage, TrackedStdioClientTransport, closeMcpChild, terminateProcess, waitForProcessExit, processExists;
+function init_mcpDoctor() {
+	return (init_mcpDoctor = __esmMin((() => {
+		init_catalogIdentity();
+		init_promptContracts();
+		init_toolContracts();
+		init_result();
+		init_identity();
+		init_mcpStartupPolicy();
+		OUTPUT_FORMATS = [
+			"toon",
+			"json",
+			"yaml",
+			"md",
+			"jsonl"
+		];
+		MCP_DOCTOR_OPTIONS = z.object({
+			format: z.enum(OUTPUT_FORMATS).optional().describe("Output format"),
+			json: z.boolean().optional().describe("Emit the report as JSON"),
+			fullOutput: z.boolean().optional().describe("Show the full output envelope"),
+			help: z.boolean().optional().describe("Show help")
+		});
+		MCP_DOCTOR_ALIAS = { help: "h" };
+		MCP_DOCTOR_COMMAND = "rea mcp doctor";
+		MCP_DOCTOR_DESCRIPTION = "Validate MCP server startup and tool listing";
+		HELP_FLAGS = new Set(["--help", "-h"]);
+		renderMcpDoctorHelp = () => Help.formatCommand(MCP_DOCTOR_COMMAND, {
+			description: MCP_DOCTOR_DESCRIPTION,
+			hideGlobalOptions: true,
+			options: MCP_DOCTOR_OPTIONS,
+			alias: MCP_DOCTOR_ALIAS,
+			hint: "This entry accepts only the options above."
+		});
+		runProductionMcpDoctor = async (options) => {
+			const deadline = Date.now() + (options.deadlineMs ?? MCP_STARTUP_POLICY.doctorDeadlineMs);
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(new Error("Production MCP doctor deadline expired")), Math.max(1, deadline - Date.now()));
+			const stderr = captureStderr();
+			const transport = new TrackedStdioClientTransport({
+				command: options.command,
+				args: [...options.args],
+				cwd: options.cwd,
+				env: targetFreeEnvironment(options.environment),
+				stderr: "pipe"
+			});
+			transport.stderr?.on("data", stderr.append);
+			const client = new Client({
+				name: "rea-mcp-doctor",
+				version: "1"
+			});
+			try {
+				await client.connect(transport, requestOptions(deadline, controller.signal));
+				return {
+					...await inspectProductionMcpSession(client, deadline, controller.signal),
+					diagnostics: stderr.value()
+				};
+			} catch (cause) {
+				return {
+					healthy: false,
+					adapter: "production-stdio",
+					server: null,
+					inventory: null,
+					identity: null,
+					request_flow: {
+						tool: "binary_session",
+						ok: false
+					},
+					checks: [{
+						name: "transport",
+						ok: false,
+						detail: errorMessage(cause)
+					}],
+					diagnostics: stderr.value()
+				};
+			} finally {
+				clearTimeout(timer);
+				await closeMcpChild(client, transport);
+			}
+		};
+		inspectProductionMcpSession = async (client, deadline, signal) => {
+			const request = requestOptions(deadline, signal);
+			const [tools, prompts] = await Promise.all([client.listTools(undefined, request), client.listPrompts(undefined, request)]);
+			const sessionTool = tools.tools.find(({ name }) => name === "binary_session");
+			const requestFlow = await client.callTool({
+				name: "binary_session",
+				arguments: {}
+			}, {
+				...requestOptions(deadline, signal),
+				...sessionTool === undefined ? {} : { toolDefinition: sessionTool }
+			}).then(ok, (cause) => err({
+				kind: "request-flow",
+				detail: errorMessage(cause)
+			}));
+			const inventory = {
+				tools: compareInventory(TOOL_CONTRACTS.map(({ name }) => name), tools.tools.map(({ name }) => name)),
+				prompts: compareInventory(PROMPT_CONTRACTS.map(({ name }) => name), prompts.prompts.map(({ name }) => name))
+			};
+			const observedIdentity = parseIdentityToolResult(requestFlow.ok ? requestFlow.value.structuredContent : undefined);
+			const serverVersion = client.getServerVersion();
+			const protocolVersion = client.getNegotiatedProtocolVersion();
+			const checks = [
+				{
+					name: "initialize",
+					ok: serverVersion?.name === PRODUCT_IDENTITY.mcpServerKey && serverVersion.version === PRODUCT_IDENTITY.packageVersion && protocolVersion !== undefined,
+					detail: `${serverVersion?.name ?? "unknown"}@${serverVersion?.version ?? "unknown"}; protocol=${protocolVersion ?? "unknown"}`
+				},
+				...Object.entries(inventory).map(([name, comparison]) => inventoryCheck(name, comparison)),
+				{
+					name: "server-identity",
+					ok: observedIdentity.packageVersion === PRODUCT_IDENTITY.packageVersion && observedIdentity.catalogDigest === CATALOG_IDENTITY.digests.combined_sha256,
+					detail: `package=${observedIdentity.packageVersion ?? "missing"}; catalog=${observedIdentity.catalogDigest ?? "missing"}`
+				},
+				{
+					name: "request-flow",
+					ok: requestFlow.ok && requestFlow.value.isError !== true,
+					detail: requestFlow.ok ? "binary_session target-free request" : requestFlow.error.detail
+				}
+			];
+			return {
+				healthy: checks.every(({ ok }) => ok),
+				adapter: "production-stdio",
+				server: {
+					name: serverVersion?.name ?? null,
+					version: serverVersion?.version ?? null,
+					protocol_version: protocolVersion ?? null
+				},
+				inventory,
+				identity: {
+					expected_package_version: PRODUCT_IDENTITY.packageVersion,
+					observed_package_version: observedIdentity.packageVersion,
+					expected_catalog_digest: CATALOG_IDENTITY.digests.combined_sha256,
+					observed_catalog_digest: observedIdentity.catalogDigest
+				},
+				request_flow: {
+					tool: "binary_session",
+					ok: requestFlow.ok && requestFlow.value.isError !== true
+				},
+				checks
+			};
+		};
+		runProductionMcpDoctorCli = async (arguments_, input) => {
+			const parsed = parseOutputArguments(arguments_);
+			if (!parsed.ok) {
+				if (parsed.help) return {
+					output: `${renderMcpDoctorHelp()}\n`,
+					exitCode: 0
+				};
+				return {
+					output: `${Formatter.format({
+						code: "VALIDATION_ERROR",
+						message: parsed.message
+					}, parsed.format)}\n`,
+					exitCode: 1
+				};
+			}
+			const result = await runProductionMcpDoctor({
+				command: process.execPath,
+				args: [resolve(input.dispatcherPath), "mcp"],
+				cwd: input.packageRoot,
+				environment: process.env
+			});
+			return {
+				output: `${Formatter.format(result, parsed.format)}\n`,
+				exitCode: result.healthy ? 0 : 1
+			};
+		};
+		compareInventory = (expectedNames, observedNames) => {
+			const expected = new Set(expectedNames);
+			const observed = new Set(observedNames);
+			return {
+				expected: expectedNames.length,
+				observed: observedNames.length,
+				missing: [...expected].filter((name) => !observed.has(name)).sort(),
+				unexpected: [...observed].filter((name) => !expected.has(name)).sort(),
+				duplicates: [...observed].filter((name) => observedNames.filter((candidate) => candidate === name).length > 1).sort()
+			};
+		};
+		inventoryCheck = (name, comparison) => ({
+			name: `inventory:${name}`,
+			ok: comparison.expected === comparison.observed && comparison.missing.length === 0 && comparison.unexpected.length === 0 && comparison.duplicates.length === 0,
+			detail: `expected=${String(comparison.expected)} observed=${String(comparison.observed)} missing=${comparison.missing.join(",") || "none"} unexpected=${comparison.unexpected.join(",") || "none"} duplicates=${comparison.duplicates.join(",") || "none"}`
+		});
+		parseIdentityToolResult = (input) => {
+			if (!isRecord(input) || !isRecord(input.result)) return {
+				packageVersion: null,
+				catalogDigest: null
+			};
+			const identity = input.result.server_identity;
+			if (!isRecord(identity)) return {
+				packageVersion: null,
+				catalogDigest: null
+			};
+			const packageIdentity = identity.package;
+			const catalog = identity.catalog;
+			const digests = isRecord(catalog) ? catalog.digests : undefined;
+			return {
+				packageVersion: isRecord(packageIdentity) && typeof packageIdentity.version === "string" ? packageIdentity.version : null,
+				catalogDigest: isRecord(digests) && typeof digests.combined_sha256 === "string" ? digests.combined_sha256 : null
+			};
+		};
+		parseOutputArguments = (arguments_) => {
+			if (hasHelpInOptionPosition(arguments_)) return {
+				ok: false,
+				help: true
+			};
+			let format = "toon";
+			for (let index = 0; index < arguments_.length; index += 1) {
+				const argument = arguments_[index];
+				if (argument === "--json") {
+					format = "json";
+					continue;
+				}
+				const inline = argument?.startsWith("--format=") ? argument.slice("--format=".length) : undefined;
+				if (argument === "--format" || inline !== undefined) {
+					const candidate = inline ?? arguments_[index + 1];
+					if (inline === undefined) index += 1;
+					if (!isOutputFormat(candidate)) return {
+						ok: false,
+						help: false,
+						format,
+						message: `Invalid output format: ${candidate ?? "missing"}`
+					};
+					format = candidate;
+					continue;
+				}
+				if (argument === "--full-output") continue;
+				if (HELP_FLAGS.has(argument ?? "")) return {
+					ok: false,
+					help: true
+				};
+				return {
+					ok: false,
+					help: false,
+					format,
+					message: `Unknown mcp doctor option: ${argument ?? "missing"}`
+				};
+			}
+			return {
+				ok: true,
+				format
+			};
+		};
+		hasHelpInOptionPosition = (arguments_) => {
+			for (let index = 0; index < arguments_.length; index += 1) {
+				const argument = arguments_[index];
+				if (argument === "--format") {
+					index += 1;
+					continue;
+				}
+				if (HELP_FLAGS.has(argument ?? "")) return true;
+			}
+			return false;
+		};
+		isOutputFormat = (value) => OUTPUT_FORMATS.some((candidate) => candidate === value);
+		requestOptions = (deadline, signal) => ({
+			signal,
+			timeout: Math.max(1, deadline - Date.now())
+		});
+		targetFreeEnvironment = (environment) => {
+			const result = Object.fromEntries(Object.entries(environment).filter((entry) => entry[1] !== undefined));
+			for (const name of [
+				"HOPPER_TARGET_PATH",
+				"HOPPER_TARGET_KIND",
+				"HOPPER_LOADER_ARGS_JSON"
+			]) delete result[name];
+			return result;
+		};
+		captureStderr = () => {
+			const chunks = [];
+			let bytes = 0;
+			return {
+				append(chunk) {
+					const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), "utf8");
+					bytes += buffer.byteLength;
+					chunks.push(Buffer.from(buffer));
+				},
+				value: () => ({
+					stderr: Buffer.concat(chunks, bytes).toString("utf8"),
+					stderr_bytes: bytes
+				})
+			};
+		};
+		isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+		errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+		TrackedStdioClientTransport = class extends StdioClientTransport {
+			spawnedPid = null;
+			async start() {
+				await super.start();
+				this.spawnedPid = this.pid;
+			}
+		};
+		closeMcpChild = async (client, transport) => {
+			const pid = transport.spawnedPid ?? transport.pid;
+			await Promise.allSettled([client.close()]);
+			await Promise.allSettled([transport.close()]);
+			if (pid === null || !await processExists(pid)) return;
+			await terminateProcess(pid, "SIGTERM");
+			if (await waitForProcessExit(pid, 1e3)) return;
+			await terminateProcess(pid, "SIGKILL");
+			await waitForProcessExit(pid, 1e3);
+		};
+		terminateProcess = async (pid, signal) => {
+			try {
+				process.kill(pid, signal);
+			} catch (cause) {
+				if (!(cause instanceof Error && "code" in cause && cause.code === "ESRCH")) throw cause;
+			}
+		};
+		waitForProcessExit = async (pid, timeoutMs) => {
+			const deadline = Date.now() + timeoutMs;
+			do {
+				if (!await processExists(pid)) return true;
+				await new Promise((resolve) => setTimeout(resolve, 20));
+			} while (Date.now() < deadline);
+			return !await processExists(pid);
+		};
+		processExists = async (pid) => {
+			try {
+				process.kill(pid, 0);
+				return true;
+			} catch (cause) {
+				if (cause instanceof Error && "code" in cause && cause.code === "ESRCH") return false;
+				throw cause;
+			}
+		};
+	})))();
+}
+
+//#endregion
+init_mcpDoctor();
+export { compareInventory, runProductionMcpDoctor, runProductionMcpDoctorCli };

package/dist/cli-runtime/mcpStartupPolicy-Bb7TMLzn.js

@@ -0,0 +1,18 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+
+//#region dist/mcpStartupPolicy.js
+var MCP_STARTUP_POLICY;
+function init_mcpStartupPolicy() {
+	return (init_mcpStartupPolicy = __esmMin((() => {
+		MCP_STARTUP_POLICY = {
+			codexStartupTimeoutSeconds: 30,
+			initializeBudgetMs: 15e3,
+			toolsListBudgetMs: 5e3,
+			firstCatalogBudgetMs: 2e4,
+			doctorDeadlineMs: 3e4
+		};
+	})))();
+}
+
+//#endregion
+export { MCP_STARTUP_POLICY, init_mcpStartupPolicy };