rea-agents 4.1.0 → 6.0.0

package/dist/domain/bytecodeProvider.js

@@ -1,178 +0,0 @@
-import { z } from "zod";
-/** Supported managed-runtime bytecode families. */
-export const bytecodeFamilySchema = z.enum(["jvm", "python"]);
-/** Classification of bytecode provenance. */
-export const bytecodeProvenanceSchema = z.enum([
-    "application",
-    "generated",
-    "vendored",
-    "bundled",
-    "standard_library",
-]);
-/** A bytecode symbol discovered through static analysis. */
-export const bytecodeSymbolSchema = z.strictObject({
-    /** Fully qualified name. */
-    name: z.string().min(1),
-    /** Raw bytecode location or offset. */
-    raw_location: z.string().min(1),
-    /** Normalized symbol type. */
-    kind: z.enum([
-        "class",
-        "interface",
-        "method",
-        "field",
-        "function",
-        "module",
-        "variable",
-    ]),
-    /** Bytecode version if known. */
-    bytecode_version: z.number().int().nullable(),
-    /** Provenance classification. */
-    provenance: bytecodeProvenanceSchema,
-    /** Whether the symbol is accessible (public). */
-    is_public: z.boolean().default(false),
-});
-/** A discovered bytecode artifact (class file, wheel, etc). */
-export const bytecodeArtifactSchema = z.strictObject({
-    /** Artifact path relative to the analysis root. */
-    path: z.string().min(1),
-    /** Bytecode family. */
-    family: bytecodeFamilySchema,
-    /** Artifact format. */
-    format: z.enum(["class", "jar", "war", "ear", "pyc", "pyo", "whl", "zipapp"]),
-    /** Size in bytes. */
-    size: z.number().int().nonnegative(),
-    /** SHA-256 digest. */
-    digest: z.string().regex(/^[a-f0-9]{64}$/u),
-    /** Discovered symbols. */
-    symbols: z.array(bytecodeSymbolSchema).default([]),
-    /** Whether this is a standard library artifact. */
-    is_standard_library: z.boolean().default(false),
-    /** Whether this is a generated artifact. */
-    is_generated: z.boolean().default(false),
-    /** Whether this is a vendored artifact. */
-    is_vendored: z.boolean().default(false),
-});
-/** Static bytecode analysis result. */
-export const bytecodeAnalysisSchema = z.strictObject({
-    /** Bytecode family. */
-    family: bytecodeFamilySchema,
-    /** All discovered artifacts. */
-    artifacts: z.array(bytecodeArtifactSchema),
-    /** Total symbols across all artifacts. */
-    total_symbols: z.number().int().nonnegative(),
-    /** Symbols classified as application code. */
-    application_symbols: z.number().int().nonnegative(),
-    /** Symbols classified as generated code. */
-    generated_symbols: z.number().int().nonnegative(),
-    /** Symbols classified as vendored code. */
-    vendored_symbols: z.number().int().nonnegative(),
-    /** Symbols classified as standard library. */
-    standard_library_symbols: z.number().int().nonnegative(),
-});
-/** Detect bytecode family from file extension. */
-export function detectBytecodeFamily(path) {
-    const lower = path.toLowerCase();
-    if (lower.endsWith(".class") ||
-        lower.endsWith(".jar") ||
-        lower.endsWith(".war") ||
-        lower.endsWith(".ear")) {
-        return "jvm";
-    }
-    if (lower.endsWith(".pyc") ||
-        lower.endsWith(".pyo") ||
-        lower.endsWith(".whl") ||
-        lower.endsWith(".pyz") ||
-        lower.endsWith(".zipapp")) {
-        return "python";
-    }
-    return null;
-}
-/** Detect artifact format from file path. */
-export function detectArtifactFormat(path) {
-    const lower = path.toLowerCase();
-    if (lower.endsWith(".class"))
-        return "class";
-    if (lower.endsWith(".jar"))
-        return "jar";
-    if (lower.endsWith(".war"))
-        return "war";
-    if (lower.endsWith(".ear"))
-        return "ear";
-    if (lower.endsWith(".pyc"))
-        return "pyc";
-    if (lower.endsWith(".pyo"))
-        return "pyo";
-    if (lower.endsWith(".whl"))
-        return "whl";
-    if (lower.endsWith(".pyz") || lower.endsWith(".zipapp"))
-        return "zipapp";
-    return null;
-}
-const STANDARD_LIBRARY_PATH_MARKERS = [
-    "/stdlib/",
-    "/site-packages/",
-    "java/",
-    "javax/",
-    "sun/",
-];
-const STANDARD_LIBRARY_SYMBOL_MARKERS = ["java.", "javax.", "sun.", "__"];
-const GENERATED_PATH_MARKERS = [
-    "/generated/",
-    "_generated",
-    "/build/",
-    "/target/",
-    "/dist-packages/",
-    "/__pycache__/",
-];
-const GENERATED_SYMBOL_MARKERS = ["Generated", "_generated"];
-const VENDORED_PATH_MARKERS = [
-    "/vendor/",
-    "/vendored/",
-    "/third_party/",
-    "/3rdparty/",
-    "/node_modules/",
-];
-const BUNDLED_PATH_MARKERS = ["/bundle/", "/bundled/", ".jar!", ".war!"];
-const includesAny = (value, markers) => markers.some((marker) => value.includes(marker));
-const startsWithAny = (value, markers) => markers.some((marker) => value.startsWith(marker));
-/** Classify bytecode symbol provenance. */
-export function classifyProvenance(path, symbolName) {
-    const lower = path.toLowerCase();
-    if (includesAny(lower, STANDARD_LIBRARY_PATH_MARKERS) ||
-        startsWithAny(symbolName, STANDARD_LIBRARY_SYMBOL_MARKERS))
-        return "standard_library";
-    if (includesAny(lower, GENERATED_PATH_MARKERS) ||
-        includesAny(symbolName, GENERATED_SYMBOL_MARKERS))
-        return "generated";
-    if (includesAny(lower, VENDORED_PATH_MARKERS))
-        return "vendored";
-    if (includesAny(lower, BUNDLED_PATH_MARKERS))
-        return "bundled";
-    return "application";
-}
-/** Analyze a set of bytecode artifacts and produce a summary. */
-export function analyzeBytecodeArtifacts(artifacts, family) {
-    const totals = artifacts.reduce((counts, artifact) => {
-        counts.total += artifact.symbols.length;
-        for (const symbol of artifact.symbols)
-            counts[symbol.provenance] += 1;
-        return counts;
-    }, {
-        total: 0,
-        application: 0,
-        generated: 0,
-        vendored: 0,
-        standard_library: 0,
-        bundled: 0,
-    });
-    return {
-        family,
-        artifacts: [...artifacts],
-        total_symbols: totals.total,
-        application_symbols: totals.application,
-        generated_symbols: totals.generated,
-        vendored_symbols: totals.vendored,
-        standard_library_symbols: totals.standard_library,
-    };
-}

package/dist/domain/customProtocolCapture.js

@@ -1,137 +0,0 @@
-import { z } from "zod";
-import { jsonValueSchema } from "./jsonValue.js";
-/** Supported transport types for custom protocol capture. */
-export const transportTypeSchema = z.enum([
-    "tcp",
-    "udp",
-    "ipc",
-    "unix-socket",
-    "named-pipe",
-    "xpc",
-]);
-/** Direction of a protocol frame. */
-export const frameDirectionSchema = z.enum(["sent", "received", "intercepted"]);
-/** A captured protocol frame. */
-export const protocolFrameSchema = z.strictObject({
-    /** Monotonic sequence number. */
-    sequence: z.number().int().nonnegative(),
-    /** Timestamp in milliseconds. */
-    at_ms: z.number().int().nonnegative(),
-    /** Transport type. */
-    transport: transportTypeSchema,
-    /** Direction of the frame. */
-    direction: frameDirectionSchema,
-    /** Source process identity. */
-    source_pid: z.number().int().nullable(),
-    /** Destination process identity. */
-    dest_pid: z.number().int().nullable(),
-    /** Endpoint address (IP:port, socket path, pipe name). */
-    source_endpoint: z.string().nullable(),
-    /** Destination endpoint. */
-    dest_endpoint: z.string().nullable(),
-    /** Raw frame data as base64. */
-    raw_data: z.string().nullable(),
-    /** Decoded/parsed frame content if known. */
-    decoded_content: jsonValueSchema.nullable(),
-    /** Frame size in bytes. */
-    size: z.number().int().nonnegative(),
-    /** Whether the frame was truncated. */
-    truncated: z.boolean().default(false),
-});
-/** Authentication flow stage. */
-export const authStageSchema = z.enum([
-    "init",
-    "challenge",
-    "response",
-    "token_exchange",
-    "renewal",
-    "revocation",
-    "failure",
-    "success",
-]);
-/** Token lifecycle event. */
-export const tokenLifecycleEventSchema = z.enum([
-    "issued",
-    "refreshed",
-    "expired",
-    "revoked",
-    "renewed",
-]);
-/** A captured authentication flow event. */
-export const authFlowEventSchema = z.strictObject({
-    /** Monotonic sequence number. */
-    sequence: z.number().int().nonnegative(),
-    /** Timestamp in milliseconds. */
-    at_ms: z.number().int().nonnegative(),
-    /** Authentication stage. */
-    stage: authStageSchema,
-    /** Protocol used. */
-    protocol: z.string().min(1),
-    /** Token type if applicable. */
-    token_type: z.string().nullable(),
-    /** Token lifecycle event. */
-    token_lifecycle: tokenLifecycleEventSchema.nullable(),
-    /** Correlation ID linking challenge-response pairs. */
-    correlation_id: z.string().nullable(),
-    /** Whether the capture producer marked credentials as redacted. */
-    credentials_redacted: z.boolean().default(false),
-    /** Whether the authentication succeeded. */
-    succeeded: z.boolean().default(false),
-    /** Error message if authentication failed. */
-    error: z.string().nullable(),
-});
-/** A captured protocol session. */
-export const customProtocolCaptureSchema = z.strictObject({
-    /** Transport type for this session. */
-    transport: transportTypeSchema,
-    /** Captured frames in order. */
-    frames: z.array(protocolFrameSchema),
-    /** Authentication flow events. */
-    auth_events: z.array(authFlowEventSchema).default([]),
-    /** Whether any frame was truncated. */
-    has_truncated: z.boolean().default(false),
-    /** Whether the capture producer detected credential content. */
-    credentials_detected: z.boolean().default(false),
-});
-/** Correlate a frame with process identity. */
-export function correlateProcessIdentity(frame, pid) {
-    return frame.source_pid === pid || frame.dest_pid === pid;
-}
-/** Check if a frame contains credential-like content. */
-export function looksLikeCredentialFrame(frame) {
-    const patterns = [
-        "password",
-        "token",
-        "secret",
-        "api_key",
-        "apikey",
-        "authorization",
-        "credential",
-    ];
-    const content = JSON.stringify(frame.decoded_content ?? "").toLowerCase();
-    return patterns.some((p) => content.includes(p));
-}
-/** Filter frames by transport type. */
-export function framesByTransport(frames, transport) {
-    return frames.filter((f) => f.transport === transport);
-}
-/** Get all authentication flow events for a specific protocol. */
-export function authEventsByProtocol(events, protocol) {
-    return events.filter((e) => e.protocol === protocol);
-}
-/** Get successful authentication events. */
-export function successfulAuthEvents(events) {
-    return events.filter((e) => e.succeeded);
-}
-/** Get failed authentication events. */
-export function failedAuthEvents(events) {
-    return events.filter((e) => !e.succeeded);
-}
-/** Compute the duration of an authentication flow in milliseconds. */
-export function authFlowDuration(events) {
-    const first = events.at(0);
-    const last = events.at(-1);
-    if (first === undefined || last === undefined)
-        return null;
-    return last.at_ms - first.at_ms;
-}

package/dist/domain/eventProcessTree.js

@@ -1,225 +0,0 @@
-import { z } from "zod";
-/** Event types for event-backed process-tree capture. */
-export const processEventTypeSchema = z.enum([
-    "spawn",
-    "exit",
-    "re_exec",
-    "reparent",
-    "signal",
-    "name_change",
-    "thread_create",
-    "thread_exit",
-]);
-/** A single event-backed process-tree event. */
-export const processTreeEventSchema = z.strictObject({
-    /** Monotonic event sequence number. */
-    sequence: z.number().int().nonnegative(),
-    /** Event timestamp in milliseconds. */
-    at_ms: z.number().int().nonnegative(),
-    /** Event type. */
-    type: processEventTypeSchema,
-    /** Process ID. */
-    pid: z.number().int().positive(),
-    /** Parent process ID. */
-    ppid: z.number().int().nullable(),
-    /** Process name if known. */
-    process_name: z.string().nullable(),
-    /** Executable path if known. */
-    executable: z.string().nullable(),
-    /** Command line arguments. */
-    arguments: z.array(z.string()).default([]),
-    /** Previous PID (for reparent events). */
-    previous_pid: z.number().int().nullable(),
-    /** Previous PPID (for reparent events). */
-    previous_ppid: z.number().int().nullable(),
-    /** Exit code (for exit events). */
-    exit_code: z.number().int().nullable(),
-    /** Signal number (for signal events). */
-    signal: z.number().int().nullable(),
-    /** Thread ID (for thread events). */
-    tid: z.number().int().nullable(),
-});
-/** Process node in a reconstructed tree. */
-export const processNodeSchema = z.strictObject({
-    pid: z.number().int().positive(),
-    ppid: z.number().int().nullable(),
-    process_name: z.string().nullable(),
-    executable: z.string().nullable(),
-    arguments: z.array(z.string()).default([]),
-    children: z.array(z.number().int()).default([]),
-    spawn_time_ms: z.number().int().nullable(),
-    exit_time_ms: z.number().int().nullable(),
-    exit_code: z.number().int().nullable(),
-    is_re_exec: z.boolean().default(false),
-    is_reparented: z.boolean().default(false),
-    previous_ppid: z.number().int().nullable(),
-});
-/** Result of event-backed process-tree reconstruction. */
-export const processTreeReconstructionSchema = z.strictObject({
-    /** Root PID of the process tree. */
-    root_pid: z.number().int().positive(),
-    /** All reconstructed process nodes. */
-    processes: z.array(processNodeSchema).min(0),
-    /** Events that were consumed. */
-    events_consumed: z.number().int().nonnegative(),
-    /** Events that could not be matched. */
-    events_unmatched: z.number().int().nonnegative(),
-    /** Short-lived descendants that were missed by sampling. */
-    short_lived_descendants: z.number().int().nonnegative(),
-    /** Whether any re-exec was detected. */
-    has_re_exec: z.boolean().default(false),
-    /** Whether any reparenting was detected. */
-    has_reparenting: z.boolean().default(false),
-});
-const applyProcessTreeEvent = (event, state) => {
-    let node = state.nodes.get(event.pid);
-    switch (event.type) {
-        case "spawn": {
-            if (!node) {
-                node = {
-                    pid: event.pid,
-                    ppid: event.ppid,
-                    process_name: event.process_name,
-                    executable: event.executable,
-                    arguments: event.arguments,
-                    children: [],
-                    spawn_time_ms: event.at_ms,
-                    exit_time_ms: null,
-                    exit_code: null,
-                    is_re_exec: false,
-                    is_reparented: false,
-                    previous_ppid: null,
-                };
-                state.nodes.set(event.pid, node);
-            }
-            if (event.ppid !== null) {
-                const parentChildren = state.children.get(event.ppid) ?? [];
-                parentChildren.push(event.pid);
-                state.children.set(event.ppid, parentChildren);
-            }
-            break;
-        }
-        case "exit":
-            if (node) {
-                node.exit_time_ms = event.at_ms;
-                node.exit_code = event.exit_code;
-                if (node.spawn_time_ms !== null &&
-                    event.at_ms - node.spawn_time_ms < 100)
-                    state.shortLivedDescendants++;
-            }
-            else
-                state.eventsUnmatched++;
-            break;
-        case "re_exec":
-            if (node) {
-                node.is_re_exec = true;
-                node.executable = event.executable ?? node.executable;
-                node.arguments = event.arguments;
-                state.hasReExec = true;
-            }
-            else
-                state.eventsUnmatched++;
-            break;
-        case "reparent":
-            if (node) {
-                node.previous_ppid = node.ppid;
-                node.ppid = event.ppid;
-                node.is_reparented = true;
-                state.hasReparenting = true;
-            }
-            else
-                state.eventsUnmatched++;
-            break;
-        case "signal":
-        case "name_change":
-        case "thread_create":
-        case "thread_exit":
-            // These events are recorded but don't modify the tree structure.
-            break;
-    }
-};
-/** Reconstruct a process tree from event-backed capture. */
-export function reconstructProcessTree(events, rootPid) {
-    const nodes = new Map();
-    const children = new Map();
-    let eventsConsumed = 0;
-    const state = {
-        nodes,
-        children,
-        eventsUnmatched: 0,
-        hasReExec: false,
-        hasReparenting: false,
-        shortLivedDescendants: 0,
-    };
-    const sorted = [...events].sort((a, b) => a.at_ms - b.at_ms);
-    for (const event of sorted) {
-        eventsConsumed++;
-        applyProcessTreeEvent(event, state);
-    }
-    // Attach children to nodes
-    for (const [pid, childPids] of children) {
-        const node = nodes.get(pid);
-        if (node)
-            node.children = childPids;
-    }
-    return {
-        root_pid: rootPid,
-        processes: [...nodes.values()],
-        events_consumed: eventsConsumed,
-        events_unmatched: state.eventsUnmatched,
-        short_lived_descendants: state.shortLivedDescendants,
-        has_re_exec: state.hasReExec,
-        has_reparenting: state.hasReparenting,
-    };
-}
-/** Get all descendant PIDs of a given root PID. */
-export function getDescendants(processes, rootPid) {
-    const byPid = new Map(processes.map((p) => [p.pid, p]));
-    const visited = new Set();
-    const result = [];
-    const queue = [rootPid];
-    for (let head = 0; head < queue.length; head += 1) {
-        const pid = queue[head];
-        if (pid === undefined)
-            continue;
-        if (visited.has(pid))
-            continue;
-        visited.add(pid);
-        const node = byPid.get(pid);
-        if (node) {
-            for (const child of node.children) {
-                if (!visited.has(child)) {
-                    result.push(child);
-                    queue.push(child);
-                }
-            }
-        }
-    }
-    return result;
-}
-/** Check if a process tree contains a specific PID. */
-export function containsProcess(processes, pid) {
-    return processes.some((p) => p.pid === pid);
-}
-/** Get the maximum tree depth from the root. */
-export function maxTreeDepth(processes, rootPid) {
-    const byPid = new Map(processes.map((p) => [p.pid, p]));
-    const pending = [{ pid: rootPid, depth: 0 }];
-    const visited = new Set();
-    let maximumDepth = 0;
-    while (pending.length > 0) {
-        const current = pending.pop();
-        if (!current || visited.has(current.pid))
-            continue;
-        visited.add(current.pid);
-        const node = byPid.get(current.pid);
-        if (!node || node.children.length === 0)
-            continue;
-        const childDepth = current.depth + 1;
-        maximumDepth = Math.max(maximumDepth, childDepth);
-        for (const childPid of node.children)
-            if (!visited.has(childPid))
-                pending.push({ pid: childPid, depth: childDepth });
-    }
-    return maximumDepth;
-}

package/dist/domain/javascriptAstValues.js

@@ -1,13 +0,0 @@
-import * as t from "@babel/types";
-/** Read an identifier or literal property name without evaluating syntax. */
-export const propertyName = (node) => {
-    if (t.isIdentifier(node))
-        return node.name;
-    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
-        return String(node.value);
-    return "";
-};
-/** Read a property name only when its syntax commits to one exact key. */
-export const semanticStaticPropertyName = (property, computed) => computed && !t.isStringLiteral(property) && !t.isNumericLiteral(property)
-    ? ""
-    : propertyName(property);

package/dist/domain/javascriptSemanticTraversal.js

@@ -1,30 +0,0 @@
-import * as t from "@babel/types";
-/**
- * Visit every Babel AST node in deterministic source-tree order.
- *
- * `ancestors` runs outermost-first and ends with the direct parent. Callers
- * need it whenever meaning depends on where a node sits, not just what its
- * immediate parent is — a binding inside `catch ({message})` or `({a} = o)`
- * has an ObjectProperty parent, so the parent alone cannot say whether the
- * identifier declares a binding or is assigned to.
- */
-export const traverseJavaScriptAst = (root, visitor) => {
-    const visit = (node, parent, ancestors) => {
-        visitor.enter(node, parent, ancestors);
-        for (const child of childNodes(node))
-            visit(child, node, [...ancestors, node]);
-        visitor.exit?.(node, parent);
-    };
-    visit(root, null, []);
-};
-const childNodes = (node) => {
-    const keys = t.VISITOR_KEYS[node.type] ?? [];
-    return keys.flatMap((key) => {
-        const value = Reflect.get(node, key);
-        if (t.isNode(value))
-            return [value];
-        if (!Array.isArray(value))
-            return [];
-        return value.filter((item) => t.isNode(item));
-    });
-};