reverseport 0.0.0-stage → 1.2.0

package/dist/application/javascript/JavaScriptRecoveryService.js

@@ -0,0 +1,77 @@
+import { isAbsolute, resolve } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { javascriptRecoveryInputSchema, javascriptRecoveryResultSchema, } from "../../domain/javascript/javascriptRecovery.js";
+import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+const OPERATION = "recover_javascript_sources";
+/** Shared CLI/MCP parsing and Evidence for derived JavaScript artifacts. */
+export class JavaScriptRecoveryService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    close() {
+        return this.provider.close?.() ?? Promise.resolve();
+    }
+    /** Recover sources and bind the result to its original immutable input. */
+    async recover(input, options) {
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError(OPERATION));
+        const parsed = javascriptRecoveryInputSchema.safeParse(input);
+        if (!parsed.success)
+            return err(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, input, {
+                cause: parsed.error,
+            }));
+        const invalidPaths = ["path", "output_directory"].filter((field) => !isAbsolute(parsed.data[field]));
+        const invalidAdditional = (parsed.data.additional_paths ?? []).filter((additional) => !isAbsolute(additional));
+        if (invalidPaths.length > 0 || invalidAdditional.length > 0)
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                ...invalidPaths.map((field) => ({
+                    path: [field],
+                    reason: "invalid_format",
+                    message: `${field} must be an absolute filesystem path on this host.`,
+                })),
+                ...invalidAdditional.map((additional) => ({
+                    path: ["additional_paths"],
+                    reason: "invalid_format",
+                    message: `additional_paths entries must be absolute filesystem paths on this host: ${additional}`,
+                })),
+            ]));
+        const selectedInputs = new Set([parsed.data.path, ...(parsed.data.additional_paths ?? [])].map((path) => resolve(path)));
+        if (selectedInputs.size !== 1 + (parsed.data.additional_paths ?? []).length)
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                {
+                    path: ["additional_paths"],
+                    reason: "invalid_format",
+                    message: "additional_paths must not repeat path or each other.",
+                },
+            ]));
+        const execution = await this.provider.recover(parsed.data, options);
+        if (!execution.ok)
+            return execution;
+        const result = javascriptRecoveryResultSchema.safeParse(execution.value.result);
+        if (!result.success || execution.value.subject === null)
+            return err(new AnalysisOutputError(OPERATION, "Recovery did not return a valid result bound to the original source"));
+        if (result.data.source.path !== parsed.data.path ||
+            (result.data.additional_sources ?? []).length !==
+                (parsed.data.additional_paths ?? []).length ||
+            (parsed.data.additional_paths ?? []).some((path, index) => result.data.additional_sources?.[index]?.path !== path) ||
+            execution.value.subject.path !== result.data.source.path ||
+            execution.value.subject.sha256 !== result.data.source.sha256 ||
+            execution.value.provider.id !== result.data.engine.id ||
+            execution.value.provider.version !== result.data.engine.version)
+            return err(new AnalysisOutputError(OPERATION, "Recovery source or engine identity disagrees with its Evidence binding"));
+        return ok(createEvidence(execution.value.subject, execution.value.provider, {
+            operation: OPERATION,
+            parameters: jsonObjectSchema.parse(parsed.data),
+            result: jsonValueSchema.parse(result.data),
+            rawResult: execution.value.rawResult,
+            locations: execution.value.locations,
+            limitations: execution.value.limitations,
+            confidence: "derived",
+            authority: "shipped-artifact",
+        }));
+    }
+}

package/dist/application/javascript/JavaScriptRuntimeObservationEvidence.js

@@ -0,0 +1,36 @@
+import { createEvidence, } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+/** Create deterministic Evidence for one passive Inspector operation. */
+export const createJavaScriptRuntimeObservationEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
+    predicateType: operation === "list_javascript_runtime_targets"
+        ? "rea.javascript-runtime-target-list"
+        : "rea.javascript-runtime-observation",
+    operation,
+    parameters: parameters(input),
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "observed",
+    authority: "external-service",
+    environment: {
+        id: `${result.runtime.product}@${result.runtime.protocol_version}`,
+        platform: "unknown",
+        architecture: "unknown",
+        isolation: "none",
+    },
+    limitations: [
+        ...result.limitations,
+        "Runtime host platform and architecture were not observed.",
+    ],
+});
+const parameters = (input) => ({
+    inspector_endpoint: input.inspector_endpoint,
+    ...("target_id" in input
+        ? {
+            target_id: input.target_id,
+            ...(input.runtime_kind === undefined
+                ? {}
+                : { runtime_kind: input.runtime_kind }),
+            observation_ms: input.observation_ms,
+        }
+        : {}),
+});

package/dist/application/javascript/JavaScriptRuntimeObservationPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/javascript/JavaScriptRuntimeObservationService.js

@@ -0,0 +1,28 @@
+import { createJavaScriptRuntimeObservationEvidence } from "./JavaScriptRuntimeObservationEvidence.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../../domain/analysisErrorCore.js";
+import { err, ok } from "../../domain/result.js";
+/** List targets exposed by the explicitly selected loopback Inspector. */
+export const listJavaScriptRuntimeTargets = async (provider, input, options = {}) => {
+    const ready = requireProvider(provider, "list_javascript_runtime_targets");
+    if (!ready.ok)
+        return ready;
+    const result = await ready.value.listTargets(input, options);
+    return result.ok
+        ? ok(createJavaScriptRuntimeObservationEvidence("list_javascript_runtime_targets", input, result.value, ready.value.identity()))
+        : result;
+};
+/** Observe one attach-only Inspector target selected by the request. */
+export const observeJavaScriptRuntime = async (provider, input, options = {}) => {
+    const ready = requireProvider(provider, "observe_javascript_runtime");
+    if (!ready.ok)
+        return ready;
+    const result = await ready.value.observe(input, options);
+    if (!result.ok)
+        return result;
+    if (options.signal?.aborted === true)
+        return err(new AnalysisCancelledError("observe_javascript_runtime"));
+    return ok(createJavaScriptRuntimeObservationEvidence("observe_javascript_runtime", input, result.value, ready.value.identity()));
+};
+const requireProvider = (provider, operation) => provider === undefined
+    ? err(new AnalysisCapabilityUnavailableError("rea-v8-inspector", operation, "V8 Inspector observation provider is not configured"))
+    : ok(provider);

package/dist/application/javascript/JavaScriptRuntimeReconciliationEvidence.js

@@ -0,0 +1,24 @@
+import { createEvidence, } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER } from "../InvestigationProviders.js";
+/** Create derived Evidence for one exact set of static/runtime inputs. */
+export const createJavaScriptRuntimeReconciliationEvidence = (input, result) => createEvidence(undefined, JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER, {
+    predicateType: "rea.javascript-runtime-reconciliation",
+    operation: "reconcile_javascript_runtime",
+    parameters: parameters(input),
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    evidenceLinks: result.evidence_links,
+});
+const parameters = (input) => ({
+    static_layers: input.static_layers.map((layer) => ({
+        role: layer.role,
+        evidence_id: layer.analysis.evidence_id,
+        runtime_mappings: layer.runtime_mappings,
+    })),
+    runtime_evidence_ids: input.runtime_observations.map(({ evidence_id: id }) => id),
+});

package/dist/application/javascript/JavaScriptRuntimeReconciliationService.js

@@ -0,0 +1,52 @@
+import { resolve } from "node:path";
+import { z } from "zod";
+import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { parseRuntimeReconciliationInput, reconcileJavaScriptRuntime, } from "../../domain/javascript/javascriptRuntimeReconciliation.js";
+import { reconcileJavaScriptRuntimeInputSchema } from "../../domain/javascript/javascriptRuntimeReconciliationSchemas.js";
+import { err, ok } from "../../domain/result.js";
+import { createJavaScriptRuntimeReconciliationEvidence } from "./JavaScriptRuntimeReconciliationEvidence.js";
+const OPERATION = "reconcile_javascript_runtime";
+/** Derive a combined JAG from verified static and passive-runtime Evidence. */
+export const reconcileJavaScriptRuntimeEvidence = (rawInput) => {
+    const parsed = reconcileJavaScriptRuntimeInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, rawInput));
+    return reconcileJavaScriptRuntimeEvidenceValidated(parsed.data);
+};
+/** Reconcile input already parsed by a trusted adapter boundary. */
+export const reconcileJavaScriptRuntimeEvidenceValidated = (parsedInput) => {
+    let parsed;
+    try {
+        parsed = parseRuntimeReconciliationInput(normalizeRuntimeMappingRoots(parsedInput));
+    }
+    catch (cause) {
+        if (cause instanceof z.ZodError)
+            return err(analysisInputErrorFromIssues(OPERATION, cause.issues, parsedInput));
+        return err(new AnalysisProtocolError("JavaScript runtime reconciliation input parsing failed", { cause }));
+    }
+    try {
+        const result = reconcileJavaScriptRuntime(parsed);
+        return ok(createJavaScriptRuntimeReconciliationEvidence(parsed.input, result));
+    }
+    catch (cause) {
+        return err(new AnalysisProtocolError("JavaScript runtime reconciliation produced an invalid result", { cause }));
+    }
+};
+const normalizeRuntimeMappingRoots = (input) => ({
+    ...input,
+    static_layers: input.static_layers.map((layer) => ({
+        ...layer,
+        runtime_mappings: layer.runtime_mappings.map((mapping) => mapping.kind === "file-root"
+            ? {
+                ...mapping,
+                root: isPortableAbsolutePath(mapping.root)
+                    ? mapping.root
+                    : resolve(mapping.root),
+            }
+            : mapping),
+    })),
+});
+const isPortableAbsolutePath = (path) => path.startsWith("/") ||
+    /^[a-z]:[\\/]/iu.test(path) ||
+    /^(?:\\\\|\/\/)[^\\/]+[\\/][^\\/]+(?:[\\/]|$)/u.test(path);

package/dist/application/javascript/JavaScriptSemanticGraphAsyncProjection.js

@@ -0,0 +1,163 @@
+import { compactStringIdentityKey } from "../../domain/compactStringIdentity.js";
+import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
+import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+/** Project literal EventEmitter registrations, removals, and dispatches. */
+export const projectSemanticEvents = (context) => {
+    const eventNodes = new Map();
+    for (const operation of context.ir.eventOperations) {
+        const eventKey = operation.eventName === null
+            ? operation.eventId
+            : `${operation.emitterKey}\u0000${compactStringIdentityKey(operation.eventName)}`;
+        const event = eventNodes.get(eventKey) ?? addEventNode(context, operation, eventKey);
+        if (event === null)
+            continue;
+        eventNodes.set(eventKey, event);
+        const relation = eventRelation(operation);
+        if (operation.kind === "dispatch")
+            addSemanticGraphRelation(context.state, {
+                source: eventEmitterNode(context, operation),
+                target: event,
+                relation,
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        else {
+            const listener = addListenerNode(context, operation);
+            addSemanticGraphRelation(context.state, {
+                source: event,
+                target: listener,
+                relation,
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        }
+        if (operation.resolution !== "complete")
+            addEventUnknown(context, operation, event, relation);
+    }
+};
+const addEventNode = (context, operation, eventKey) => retainSemanticGraphNode(context.state, context.file, {
+    kind: "event",
+    roleKey: `event:${eventKey}`,
+    location: operation.eventName === null ? operation.location : null,
+    label: operation.eventName === null ||
+        operation.eventName.length <= "event".length
+        ? operation.eventName
+        : "event",
+    functionNodeId: null,
+    properties: {
+        emitter_key: operation.emitterKey,
+        event_name: operation.eventName,
+    },
+});
+const addListenerNode = (context, operation) => retainSemanticGraphNode(context.state, context.file, {
+    kind: "listener",
+    roleKey: `listener:${operation.eventId}`,
+    location: operation.listenerLocation ?? operation.location,
+    label: operation.eventName === null
+        ? operation.method
+        : operation.eventName.length <= "listener".length
+            ? `${operation.method}:${operation.eventName}`
+            : `${operation.method}:listener`,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: {
+        emitter_key: operation.emitterKey,
+        event_name: operation.eventName,
+        method: operation.method,
+    },
+});
+const eventEmitterNode = (context, operation) => (operation.emitterBindingId === null
+    ? undefined
+    : context.bindingNodes.get(operation.emitterBindingId)) ??
+    (operation.ownerCallableId === null
+        ? context.moduleNode
+        : (context.callableNodes.get(operation.ownerCallableId) ??
+            context.moduleNode));
+const eventRelation = (operation) => operation.kind === "register"
+    ? "registers-listener"
+    : operation.kind === "remove"
+        ? "removes-listener"
+        : "dispatches-candidate";
+const addEventUnknown = (context, operation, event, relation) => {
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: event.node_id,
+        family: "event",
+        relation_kinds: [relation],
+        reason: "ambiguous-target",
+        detail: operation.eventName === null
+            ? `Dynamic ${operation.method} event name remains unresolved.`
+            : `Static ${operation.method} emitter identity is partial.`,
+        candidate_node_ids: [],
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }, context.state.evidenceContexts));
+};
+/** Project Node timer scheduling and exact local handle cancellation. */
+export const projectSemanticTimers = (context) => {
+    const timerNodes = new Map(context.ir.timerOperations.flatMap((operation) => {
+        if (operation.kind !== "schedule")
+            return [];
+        const owner = operation.ownerCallableId === null
+            ? undefined
+            : context.callableNodes.get(operation.ownerCallableId);
+        const timer = retainSemanticGraphNode(context.state, context.file, {
+            kind: "timer",
+            roleKey: operation.timerId,
+            location: operation.location,
+            label: operation.method,
+            functionNodeId: owner?.node_id ?? null,
+            properties: {
+                delay_milliseconds: operation.delayMilliseconds,
+                method: operation.method,
+            },
+        });
+        return timer === null ? [] : [[operation.timerId, timer]];
+    }));
+    for (const operation of context.ir.timerOperations)
+        if (operation.kind === "schedule")
+            projectTimerSchedule(context, operation, timerNodes);
+        else
+            projectTimerCancellation(context, operation, timerNodes);
+};
+const projectTimerSchedule = (context, operation, timerNodes) => {
+    addSemanticGraphRelation(context.state, {
+        source: context.callSiteAt(operation.location),
+        target: timerNodes.get(operation.timerId),
+        relation: "schedules-timer",
+        resolution: "resolved",
+    });
+    for (const projected of operation.projectedResultBindings)
+        addSemanticGraphRelation(context.state, {
+            source: timerNodes.get(operation.timerId),
+            target: context.bindingNodes.get(projected.bindingId),
+            relation: "destructures",
+            resolution: projected.resolution === "complete" ? "resolved" : "candidate",
+            properties: {
+                projection_path: [...projected.projectionPath],
+                projection_resolution: projected.resolution,
+            },
+        });
+};
+const projectTimerCancellation = (context, operation, timerNodes) => {
+    const callSite = context.callSiteAt(operation.location);
+    const target = operation.linkedTimerId === null
+        ? undefined
+        : timerNodes.get(operation.linkedTimerId);
+    addSemanticGraphRelation(context.state, {
+        source: callSite,
+        target,
+        relation: "cancels-timer",
+        resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+    });
+    if (operation.resolution === "complete")
+        return;
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: callSite?.node_id ?? null,
+        family: "timer",
+        relation_kinds: ["cancels-timer"],
+        reason: "ambiguous-target",
+        detail: `Static ${operation.method} handle resolution was ${operation.resolution}.`,
+        candidate_node_ids: [],
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }, context.state.evidenceContexts));
+};