Files
reverse-engineering-anything/tests/process-global/javascriptRuntimeObservationCli.test.ts
T
Ysopwnableandgensokyo-dev 62014b566d refactor(cli)!: dispatch commands through REA-owned execution
Run ordinary CLI commands through REA's registry, argv parser and result owner.
Remove Incur, the second admission parse, SDK error middleware, output capture
and redundant command traversal. Preserve explicit redaction, publication
receipts, incremental output, terminal notice eligibility and drain ownership.
Migrate fixtures to real registrations and retain the derived-source notices.

Validation includes unchanged public parity goldens, public and lifecycle
regressions, repaired fixture consumers, real TTY base comparisons, exports
beyond the engine string limit, four schema catalogs and final static/docs
checks. Native provider and optional validator coverage limits are in the PR.

Fixes #11654. Fixes #10583. Refs #11682, #11476 and #10511.

BREAKING CHANGE: Markdown argument diagnostics use REA's literal escaping,
table widths and token counts. Flag-shaped unknown MCP subcommands honor the
selected format. Completion --schema/--version routes use the canonical
REA-owned hook rather than the retired SDK generator. Refresh affected literal
snapshots and regenerate completion hooks with rea completions <shell>.

Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
2026-11-16 13:56:34 +00:00

188 lines
6.3 KiB
TypeScript

import { createCommandCli } from "../support/cli/commandCli.js";
import { writeFile } from "node:fs/promises";
import { join } from "node:path";
import { pathToFileURL } from "node:url";
import { afterEach, describe, expect, test, vi } from "vitest";
import { observeJavaScriptRuntime } from "../../src/application/javascript/JavaScriptRuntimeObservationService.js";
import type { JavaScriptRuntimeObservationPort } from "../../src/ports/javascript/JavaScriptRuntimeObservationPort.js";
import { V8InspectorProvider } from "../../src/inspector/V8InspectorProvider.js";
import { observeJavaScriptRuntimeInputSchema } from "../../src/domain/javascript/javascriptRuntimeObservation.js";
import { startFakeV8Inspector } from "../fixtures/inspector/fakeV8Inspector.js";
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
import { registerJavaScriptRuntimeObservationCommands } from "../../src/cli/javascriptRuntimeCommands.js";
import { ProviderCleanupError } from "../../src/domain/providerCleanupError.js";
import { ok } from "../../src/domain/result.js";
import { silentLogger } from "../../src/logger.js";
import { cliTest } from "../support/cli/cliFixture.js";
const runtimeFactory = vi.hoisted(() => ({
provider: undefined as JavaScriptRuntimeObservationPort | undefined,
}));
vi.mock("../../src/composition/javascriptRuntimeObservation.js", () => ({
createJavaScriptRuntimeObservationProvider: () => {
if (runtimeFactory.provider === undefined)
throw new Error("No runtime observation provider was configured");
return runtimeFactory.provider;
},
}));
describe("JavaScript runtime observation CLI parity", () => {
const resources: Array<{ close(): Promise<unknown> }> = [];
afterEach(async () => {
runtimeFactory.provider = undefined;
await Promise.all(resources.splice(0).map((item) => item.close()));
});
cliTest(
"returns the same passive Inspector Evidence contracts",
async ({ cli }) => {
const root = await createTestTempDirectory("rea-v8-cli-");
const entry = join(root, "entry.js");
await writeFile(entry, "export const value = 1;\n");
const inspector = await startFakeV8Inspector({
targetUrl: pathToFileURL(entry).href,
});
resources.push(inspector);
const environment = { ...process.env };
const listed = await cli.run({
arguments: [
"list-javascript-runtime-targets",
inspector.endpoint,
"--json",
],
environment,
});
expect(listed.exitCode, listed.stderr).toBe(0);
expect(listed.json).toMatchObject({
operation: "list_javascript_runtime_targets",
provider: { id: "rea-v8-inspector" },
normalized_result: {
targets: [{ target_id: inspector.targetId }],
},
});
const observed = await cli.run({
arguments: [
"observe-javascript-runtime",
inspector.endpoint,
inspector.targetId,
"--runtime-kind",
"node",
"--observation-ms",
"10",
"--json",
],
environment,
});
expect(observed.exitCode, observed.stderr).toBe(0);
expect(observed.json).toMatchObject({
operation: "observe_javascript_runtime",
provider: { id: "rea-v8-inspector" },
normalized_result: {
target: { target_id: inspector.targetId, runtime_kind: "node" },
scripts: {
items: [
expect.objectContaining({
location: { kind: "file", file_path: entry },
}),
],
},
},
});
const provider = new V8InspectorProvider();
try {
const direct = await observeJavaScriptRuntime(
provider,
observeJavaScriptRuntimeInputSchema.parse({
inspector_endpoint: inspector.endpoint,
target_id: inspector.targetId,
runtime_kind: "node",
observation_ms: 10,
}),
);
expect(direct.ok).toBe(true);
if (direct.ok)
expect(evidenceIdFrom(observed.json)).toBe(direct.value.evidence_id);
} finally {
await provider.close();
}
},
);
test("waits for provider cleanup and retains completed Evidence on failure", async () => {
let closeAttempts = 0;
runtimeFactory.provider = {
identity: () => ({
id: "rea-v8-inspector",
name: "V8 Inspector",
version: "1",
}),
listTargets: async () =>
ok({
runtime: {
product: "node.js/v24",
protocol_version: "1.3",
v8_version: "13.0",
},
targets: [],
excluded: { unsupported_location: 0, unconnectable: 0 },
limitations: [],
}),
observe: async () => {
throw new Error("No runtime observation requested");
},
close: async () => {
closeAttempts += 1;
throw new ProviderCleanupError(
"rea-v8-inspector",
["browser_transport"],
{ reason: "Inspector transport remains retained" },
{ operation: "list_javascript_runtime_targets" },
);
},
};
const previousExitCode = process.exitCode;
process.exitCode = 0;
try {
const cli = createCommandCli();
registerJavaScriptRuntimeObservationCommands(cli, silentLogger, {});
let stdout = "";
await cli.serve(
["list-javascript-runtime-targets", "http://127.0.0.1:9229", "--json"],
{ exit: () => {}, stdout: (chunk) => (stdout += chunk) },
);
expect(closeAttempts, stdout).toBe(1);
expect(JSON.parse(stdout)).toMatchObject({
code: "cleanup_incomplete",
details: {
operation: "list_javascript_runtime_targets",
partial_observation: {
operation: "list_javascript_runtime_targets",
normalized_result: {
runtime: { product: "node.js/v24" },
targets: [],
},
},
},
});
expect(process.exitCode).toBe(1);
} finally {
process.exitCode = previousExitCode;
}
});
});
const evidenceIdFrom = (value: unknown): string => {
if (typeof value !== "object" || value === null)
throw new TypeError("Missing CLI Evidence");
const id = Reflect.get(value, "evidence_id");
if (typeof id !== "string") throw new TypeError("Missing CLI Evidence ID");
return id;
};