#!/usr/bin/env node

import { access } from "node:fs/promises";

import { dirname, join, resolve } from "node:path";

import { fileURLToPath } from "node:url";

const args = process.argv.slice(2);

const { default: packageJson } = await import("../package.json", {

with: { type: "json" },

process.env.REA_PACKAGE_VERSION = packageJson.version;

const isMcpEntry = args[0] === "--mcp" || args[0] === "mcp";

const isMcpMode = isMcpEntry && args.length === 1;

const isMcpDoctorMode = args[0] === "mcp" && args[1] === "doctor";

const isMcpHttpMode =

isMcpEntry &&

(args[1]?.startsWith("-") ?? false) &&

args.slice(1).includes("--http");

const SIGPIPE_EXIT_STATUS = 141;

let stdoutClosed = false;

const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");

if (process.platform === "win32" && process.env.USERPROFILE === "") {

delete process.env.USERPROFILE;

if (

process.platform === "android" &&

process.env.PLAYWRIGHT_BROWSERS_PATH === undefined

) {

const cacheRoot =

process.env.XDG_CACHE_HOME ?? join(process.env.HOME ?? ".", ".cache");

process.env.PLAYWRIGHT_BROWSERS_PATH = join(cacheRoot, "ms-playwright");

const runtimeFiles =

isMcpMode || isMcpHttpMode

? ["dist/mcp/main.js"]

: isMcpDoctorMode

? ["dist/mcp/main.js", "dist/cli-runtime/mcpDoctor.js"]

: [

"dist/cli-runtime/cli.js",

"dist/cli-runtime/cliOutput.js",

"dist/cli-runtime/cliResultOutput.js",

];

if (!(await compiledRuntimeExists(runtimeFiles))) {

process.stderr.write(

`REA's compiled runtime is missing. Run \`npm ci && npm run build:cached\` in ${packageRoot} to install dependencies and build REA, then restart it. If this is an installed package, reinstall rea-agents.\n`,

);

process.exitCode = 1;

} else if (isMcpMode) {

const { runEntrypoint } = await import("../dist/mcp/main.js");

await runEntrypoint();

} else if (isMcpHttpMode) {

const { runMcpHttpEntrypoint } = await import("../dist/mcp/main.js");

await runMcpHttpEntrypoint(args.slice(1));

} else if (isMcpDoctorMode) {

guardClosedStdout();

const { runProductionMcpDoctorCli } =

await import("../dist/cli-runtime/mcpDoctor.js");

const result = await runProductionMcpDoctorCli(args.slice(2), {

dispatcherPath: fileURLToPath(import.meta.url),

packageRoot,

});

writeStdout(result.output);

process.exitCode = result.exitCode;

} else {

const { cliConfigurationError, closeCliJavaScriptResources, createCli } =

await import("../dist/cli-runtime/cli.js");

const { createCliResultOutput } =

await import("../dist/cli-runtime/cliResultOutput.js");

const {

normalizeCliArguments,

renderCliOutputArgumentError,

renderEmptyFilteredCliOutput,

validateCliOutputArguments,

} = await import("../dist/cli-runtime/cliOutput.js");

guardClosedStdout();

const cliArgs = normalizeCliArguments(args);

const outputArguments = validateCliOutputArguments(cliArgs);

const configurationError = cliConfigurationError(process.env);

let dispatchFailure;

// Incur can exit from the callback below before this function returns.

// That callback owns the status, including a closed-pipe exit of 141.

let exiting = false;

try {

// Doctor is the readiness report for this failure. Other commands still stop

// here so they do not run with an unusable log level.

if (configurationError !== undefined && !isDoctorCommand(cliArgs)) {

process.stderr.write(`${configurationError}\n`);

process.exitCode = 1;

} else if (!outputArguments.ok) {

writeStdout(renderCliOutputArgumentError(outputArguments));

process.exitCode = 1;

} else {

let wroteOutput = false;

const resultOutput = createCliResultOutput(cliArgs, process.stdout);

try {

await createCli(process.env, resultOutput).serve(cliArgs, {

stdout: (output) => {

},

// A command failure caused by the closed pipe keeps the pipe's status.

// Worker shutdown is shared with the dispatch finally below. A failed

// shutdown is reported here because this callback is what exits.

exit: (code) => {

},

});

} catch (cause) {

if (wroteOutput) throw cause;

const recovered = await resultOutput

?.recoverFormattingFailure(cause)

.catch((writeFailure) => {

// Recovery writes outside Incur's command boundary. A reader that

// declined this document keeps the same quiet SIGPIPE outcome.

if (!stdoutClosed) throw writeFailure;

return true;

});

if (!recovered) throw cause;

process.exitCode = stdoutClosed ? SIGPIPE_EXIT_STATUS : 1;

}

if (!wroteOutput && !resultOutput?.handled)

writeStdout(renderEmptyFilteredCliOutput(cliArgs) ?? "");

}

} catch (cause) {

dispatchFailure = cause;

} finally {

// Serve and output rendering can throw after a worker is parked. Stop it

// on that path too, and keep the dispatch failure when both fail.

try {

await closeCliJavaScriptResources();

} catch (cleanup) {

// The exit callback reports this same shared failure and then exits.

if (!exiting) {

dispatchFailure =

dispatchFailure === undefined

? cleanup

: new AggregateError(

[dispatchFailure, cleanup],

"CLI dispatch failed and the JavaScript analysis worker remained owned",

);

}

}

}

if (!exiting && dispatchFailure !== undefined) throw dispatchFailure;

function isDoctorCommand(arguments_) {

function cleanupFailureText(cleanup) {

if (cleanup instanceof Error) return cleanup.stack ?? cleanup.message;

return String(cleanup);

function guardClosedStdout() {

function writeStdout(output) {

if (!stdoutClosed) process.stdout.write(output);

async function compiledRuntimeExists(paths) {

function isMissing(cause) {