rea-agents 2.4.0 → 3.0.0

package/dist/domain/objcSwiftMetadata.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+/** Objective-C method type. */
+export const objcMethodTypeSchema = z.enum([
+    "instance",
+    "class",
+    "ivar_getter",
+    "ivar_setter",
+]);
+/** Objective-C property attribute. */
+export const objcPropertyAttributeSchema = z.strictObject({
+    name: z.string().min(1),
+    value: z.string(),
+    is_weak: z.boolean().default(false),
+    is_atomic: z.boolean().default(false),
+    is_copy: z.boolean().default(false),
+    is_strong: z.boolean().default(false),
+});
+/** Objective-C method metadata. */
+export const objcMethodSchema = z.strictObject({
+    selector: z.string().min(1),
+    method_type: objcMethodTypeSchema,
+    address: z.number().int().nullable(),
+    is_required: z.boolean().default(false),
+    is_optional: z.boolean().default(false),
+});
+/** Objective-C property metadata. */
+export const objcPropertySchema = z.strictObject({
+    name: z.string().min(1),
+    type_encoding: z.string().nullable(),
+    attributes: z.array(objcPropertyAttributeSchema).default([]),
+    is_readonly: z.boolean().default(false),
+    getter: z.string().nullable(),
+    setter: z.string().nullable(),
+});
+/** Objective-C protocol metadata. */
+export const objcProtocolSchema = z.strictObject({
+    name: z.string().min(1),
+    methods: z.array(objcMethodSchema).default([]),
+    optional_methods: z.array(objcMethodSchema).default([]),
+    properties: z.array(objcPropertySchema).default([]),
+});
+/** Objective-C class metadata. */
+export const objcClassSchema = z.strictObject({
+    name: z.string().min(1),
+    super_class: z.string().nullable(),
+    is_meta_class: z.boolean().default(false),
+    is_root_class: z.boolean().default(false),
+    methods: z.array(objcMethodSchema).default([]),
+    properties: z.array(objcPropertySchema).default([]),
+    protocols: z.array(z.string()).default([]),
+    ivar_count: z.number().int().nonnegative().default(0),
+    instance_size: z.number().int().nonnegative().nullable(),
+});
+/** Swift declaration kind. */
+export const swiftDeclKindSchema = z.enum([
+    "class",
+    "struct",
+    "enum",
+    "protocol",
+    "extension",
+    "actor",
+    "global_var",
+    "global_func",
+]);
+/** Swift access level. */
+export const swiftAccessLevelSchema = z.enum([
+    "private",
+    "fileprivate",
+    "internal",
+    "public",
+    "open",
+]);
+/** Swift declaration metadata. */
+export const swiftDeclSchema = z.strictObject({
+    kind: swiftDeclKindSchema,
+    name: z.string().min(1),
+    module: z.string().nullable(),
+    access_level: swiftAccessLevelSchema.default("internal"),
+    super_class: z.string().nullable(),
+    protocols: z.array(z.string()).default([]),
+    is_final: z.boolean().default(false),
+    is_required: z.boolean().default(false),
+    is_convenience_init: z.boolean().default(false),
+    is_override: z.boolean().default(false),
+});
+/** Database save/read operation type. */
+export const dbOperationSchema = z.enum([
+    "save",
+    "readback",
+    "open_database",
+    "close_database",
+    "export",
+    "import",
+]);
+/** Database save operation result. */
+export const dbSaveResultSchema = z.strictObject({
+    operation: dbOperationSchema,
+    succeeded: z.boolean(),
+    preserved_names: z.number().int().nonnegative().default(0),
+    preserved_comments: z.number().int().nonnegative().default(0),
+    preserved_bookmarks: z.number().int().nonnegative().default(0),
+    database_path: z.string().nullable(),
+    error: z.string().nullable(),
+});
+/** Result of deeper ObjC/Swift metadata extraction. */
+export const objcSwiftMetadataSchema = z.strictObject({
+    objc_classes: z.array(objcClassSchema).default([]),
+    objc_protocols: z.array(objcProtocolSchema).default([]),
+    swift_decls: z.array(swiftDeclSchema).default([]),
+    db_save_result: dbSaveResultSchema.nullable(),
+});
+/** Check if a selector name looks like a getter. */
+export function isGetterSelector(selector) {
+    return /^[a-z][a-zA-Z0-9_]*$/u.test(selector) && !selector.includes(":");
+}
+/** Check if a selector name looks like a setter. */
+export function isSetterSelector(selector) {
+    return selector.startsWith("set") && selector.endsWith(":");
+}
+/** Extract property name from a getter/setter selector. */
+export function propertyNameFromSelector(selector) {
+    if (isSetterSelector(selector)) {
+        const inner = selector.slice(3, -1);
+        return inner.charAt(0).toLowerCase() + inner.slice(1);
+    }
+    if (isGetterSelector(selector)) {
+        return selector;
+    }
+    return null;
+}
+/** Count ObjC methods by type. */
+export function countMethodsByType(methods) {
+    return {
+        instance: methods.filter((m) => m.method_type === "instance").length,
+        class: methods.filter((m) => m.method_type === "class").length,
+        ivar_getter: methods.filter((m) => m.method_type === "ivar_getter").length,
+        ivar_setter: methods.filter((m) => m.method_type === "ivar_setter").length,
+    };
+}
+/** Get all Swift declarations of a specific kind. */
+export function swiftDeclsByKind(decls, kind) {
+    return decls.filter((d) => d.kind === kind);
+}
+/** Check if a database save preserved all expected items. */
+export function isDbSaveComplete(result, expectedNames, expectedComments, expectedBookmarks) {
+    return (result.succeeded &&
+        result.preserved_names >= expectedNames &&
+        result.preserved_comments >= expectedComments &&
+        result.preserved_bookmarks >= expectedBookmarks);
+}

package/dist/domain/packageAnalysis.js

@@ -0,0 +1,123 @@
+import { z } from "zod";
+/** Supported Windows package formats. */
+export const packageFormatSchema = z.enum(["msix", "msi", "appx"]);
+/** A resource entry within a package. */
+export const packageResourceSchema = z.strictObject({
+    /** Resource path within the package. */
+    path: z.string().min(1),
+    /** Resource type. */
+    type: z.enum([
+        "manifest",
+        "icon",
+        "configuration",
+        "certificate",
+        "executable",
+        "library",
+        "data",
+        "other",
+    ]),
+    /** Size in bytes. */
+    size: z.number().int().nonnegative(),
+    /** SHA-256 digest. */
+    digest: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .nullable(),
+});
+/** Digital signature information. */
+export const digitalSignatureSchema = z.strictObject({
+    /** Whether the package is signed. */
+    is_signed: z.boolean(),
+    /** Signer subject name. */
+    signer_subject: z.string().nullable(),
+    /** Certificate thumbprint. */
+    certificate_thumbprint: z.string().nullable(),
+    /** Whether the signature is valid. */
+    is_valid: z.boolean().default(false),
+    /** Whether the signature is timestamped. */
+    is_timestamped: z.boolean().default(false),
+    /** Timestamp signer if present. */
+    timestamp_signer: z.string().nullable(),
+});
+/** A Windows package manifest for static analysis. */
+export const packageManifestSchema = z.strictObject({
+    /** Package format. */
+    format: packageFormatSchema,
+    /** Package identity name. */
+    name: z.string().min(1),
+    /** Package publisher. */
+    publisher: z.string().nullable(),
+    /** Package version. */
+    version: z.string().nullable(),
+    /** Architecture. */
+    architecture: z.enum(["x86", "x64", "arm", "arm64", "neutral", "unknown"]),
+    /** Package resources. */
+    resources: z.array(packageResourceSchema).default([]),
+    /** Digital signature. */
+    signature: digitalSignatureSchema,
+    /** Whether the package is a framework. */
+    is_framework: z.boolean().default(false),
+    /** Package dependencies. */
+    dependencies: z.array(z.string()).default([]),
+    /** Capabilities declared in the manifest. */
+    capabilities: z.array(z.string()).default([]),
+});
+/** Detect package format from file extension. */
+export function detectPackageFormat(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".msix"))
+        return "msix";
+    if (lower.endsWith(".msi"))
+        return "msi";
+    if (lower.endsWith(".appx"))
+        return "appx";
+    return null;
+}
+/** Check if a resource path looks like a manifest. */
+export function isManifestResource(path) {
+    const lower = path.toLowerCase();
+    return (lower.includes("appxmanifest.xml") ||
+        lower.includes("appxmanifest") ||
+        lower.includes("manifest.xml") ||
+        lower.endsWith("_manifest.xml"));
+}
+/** Check if a resource path looks like a configuration file. */
+export function isConfigurationResource(path) {
+    const lower = path.toLowerCase();
+    return (lower.endsWith(".xml") ||
+        lower.endsWith(".json") ||
+        lower.endsWith(".ini") ||
+        lower.endsWith(".config"));
+}
+/** Classify a resource by its path. */
+export function classifyResource(path) {
+    if (isManifestResource(path))
+        return "manifest";
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".ico") ||
+        lower.endsWith(".png") ||
+        lower.endsWith(".jpg") ||
+        lower.endsWith(".jpeg"))
+        return "icon";
+    if (isConfigurationResource(path))
+        return "configuration";
+    if (lower.endsWith(".cer") ||
+        lower.endsWith(".pfx") ||
+        lower.endsWith(".p12"))
+        return "certificate";
+    if (lower.endsWith(".exe") || lower.endsWith(".dll"))
+        return lower.endsWith(".exe") ? "executable" : "library";
+    return "other";
+}
+/** Get all resources of a specific type. */
+export function resourcesByType(manifest, type) {
+    return manifest.resources.filter((r) => r.type === type);
+}
+/** Get the total size of all resources. */
+export function totalResourceSize(manifest) {
+    return manifest.resources.reduce((sum, r) => sum + r.size, 0);
+}
+/** Check if a package has a valid signature. */
+export function hasValidSignature(manifest) {
+    return manifest.signature.is_signed && manifest.signature.is_valid;
+}

package/dist/domain/peInspection.js

@@ -0,0 +1,196 @@
+import { z } from "zod";
+/** PE/COFF section characteristics flags. */
+export const sectionCharacteristicsSchema = z.object({
+    /** Section contains executable code. */
+    has_code: z.boolean().default(false),
+    /** Section contains initialized data. */
+    has_initialized_data: z.boolean().default(false),
+    /** Section contains uninitialized data. */
+    has_uninitialized_data: z.boolean().default(false),
+    /** Section can be read. */
+    readable: z.boolean().default(false),
+    /** Section can be written. */
+    writable: z.boolean().default(false),
+    /** Section can be executed. */
+    executable: z.boolean().default(false),
+});
+/** PE/COFF section header. */
+export const peSectionSchema = z.strictObject({
+    name: z.string().min(1),
+    virtual_size: z.number().int().nonnegative(),
+    virtual_address: z.number().int().nonnegative(),
+    raw_size: z.number().int().nonnegative(),
+    raw_offset: z.number().int().nonnegative(),
+    characteristics: sectionCharacteristicsSchema,
+});
+/** PE import entry. */
+export const peImportSchema = z.strictObject({
+    dll: z.string().min(1),
+    function_name: z.string().min(1),
+    ordinal: z.number().int().nullable(),
+    is_delay_import: z.boolean().default(false),
+});
+/** PE export entry. */
+export const peExportSchema = z.strictObject({
+    name: z.string().min(1),
+    ordinal: z.number().int().nonnegative(),
+    rva: z.number().int().nonnegative(),
+    forwarder: z.string().nullable(),
+});
+/** PE/COFF resource entry. */
+export const peResourceSchema = z.strictObject({
+    type: z.string().min(1),
+    name: z.string().nullable(),
+    language: z.number().int().nullable(),
+    rva: z.number().int().nonnegative(),
+    size: z.number().int().nonnegative(),
+});
+/** PE debug directory entry. */
+export const peDebugEntrySchema = z.strictObject({
+    type: z.string().min(1),
+    rva: z.number().int().nonnegative(),
+    size: z.number().int().nonnegative(),
+    /** PDB GUID if this is a CodeView entry. */
+    pdb_guid: z.string().nullable(),
+    /** PDB age if this is a CodeView entry. */
+    pdb_age: z.number().int().nullable(),
+    /** PDB path if this is a CodeView entry. */
+    pdb_path: z.string().nullable(),
+});
+/** TLS callback entry. */
+export const peTlsCallbackSchema = z.strictObject({
+    callback_rva: z.number().int().nonnegative(),
+    index: z.number().int().nonnegative(),
+});
+/** Architecture/machine type. */
+export const peMachineTypeSchema = z.enum([
+    "x86",
+    "x64",
+    "arm",
+    "arm64",
+    "ia64",
+    "unknown",
+]);
+/** PE/COFF manifest for static inspection. */
+export const peManifestSchema = z.strictObject({
+    /** DOS header magic. */
+    dos_magic: z.literal(0x5a4d),
+    /** PE signature. */
+    pe_signature: z.literal(0x00004550),
+    /** Machine type. */
+    machine: peMachineTypeSchema,
+    /** Number of sections. */
+    number_of_sections: z.number().int().positive(),
+    /** Timestamp from the COFF header. */
+    timestamp: z.number().int().nullable(),
+    /** PE characteristics flags. */
+    is_dll: z.boolean().default(false),
+    is_executable: z.boolean().default(false),
+    is_console: z.boolean().default(true),
+    /** Entry point RVA. */
+    entry_point: z.number().int().nonnegative(),
+    /** Image base. */
+    image_base: z.number().int().nonnegative(),
+    /** Section alignment. */
+    section_alignment: z.number().int().positive(),
+    /** Subsystem version. */
+    subsystem_version: z.string().nullable(),
+    /** Sections. */
+    sections: z.array(peSectionSchema).min(0).max(96),
+    /** Imports. */
+    imports: z.array(peImportSchema).default([]),
+    /** Exports. */
+    exports: z.array(peExportSchema).default([]),
+    /** Resources. */
+    resources: z.array(peResourceSchema).default([]),
+    /** Debug directory entries. */
+    debug_entries: z.array(peDebugEntrySchema).default([]),
+    /** TLS callbacks. */
+    tls_callbacks: z.array(peTlsCallbackSchema).default([]),
+    /** Relocations count (not all entries). */
+    relocations_count: z.number().int().nonnegative().default(0),
+    /** Image file characteristics. */
+    image_characteristics: z.array(z.string()).default([]),
+});
+/** Parse machine type from COFF machine field. */
+export function parseMachineType(machine) {
+    switch (machine) {
+        case 0x014c:
+            return "x86";
+        case 0x8664:
+            return "x64";
+        case 0x01c0:
+        case 0x01c4:
+            return "arm";
+        case 0xaa64:
+            return "arm64";
+        case 0x0200:
+            return "ia64";
+        default:
+            return "unknown";
+    }
+}
+/** Parse section characteristics flags. */
+export function parseSectionCharacteristics(characteristics) {
+    const IMAGE_SCN_CNT_CODE = 0x00000020;
+    const IMAGE_SCN_CNT_INITIALIZED_DATA = 0x00000040;
+    const IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080;
+    const IMAGE_SCN_MEM_READ = 0x40000000;
+    const IMAGE_SCN_MEM_WRITE = 0x80000000;
+    const IMAGE_SCN_MEM_EXECUTE = 0x20000000;
+    return {
+        has_code: (characteristics & IMAGE_SCN_CNT_CODE) !== 0,
+        has_initialized_data: (characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) !== 0,
+        has_uninitialized_data: (characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) !== 0,
+        readable: (characteristics & IMAGE_SCN_MEM_READ) !== 0,
+        writable: (characteristics & IMAGE_SCN_MEM_WRITE) !== 0,
+        executable: (characteristics & IMAGE_SCN_MEM_EXECUTE) !== 0,
+    };
+}
+/** Parse image characteristics flags. */
+export function parseImageCharacteristics(characteristics) {
+    const IMAGE_DLL = 0x2000;
+    const IMAGE_EXECUTABLE = 0x0002;
+    const IMAGE_CONSOLE = 0x0003;
+    const flags = [];
+    if (characteristics & IMAGE_DLL)
+        flags.push("DLL");
+    if (characteristics & IMAGE_EXECUTABLE)
+        flags.push("Executable");
+    if ((characteristics & 0x0000000f) === IMAGE_CONSOLE)
+        flags.push("Console");
+    return flags;
+}
+/** Parse a PE debug directory type. */
+export function parseDebugType(type) {
+    switch (type) {
+        case 0:
+            return "UNKNOWN";
+        case 1:
+            return "COFF";
+        case 2:
+            return "CODEVIEW";
+        case 3:
+            return "POGO";
+        case 4:
+            return "MISC";
+        default:
+            return "UNKNOWN";
+    }
+}
+/** Check if a PE manifest has PDB debug info. */
+export function hasPdbInfo(manifest) {
+    return manifest.debug_entries.some((e) => e.pdb_guid !== null && e.pdb_path !== null);
+}
+/** Get all imported DLLs from a PE manifest. */
+export function getImportedDlls(manifest) {
+    return [...new Set(manifest.imports.map((i) => i.dll))];
+}
+/** Get all exported function names from a PE manifest. */
+export function getExportedFunctions(manifest) {
+    return manifest.exports.map((e) => e.name);
+}
+/** Count executable sections. */
+export function countExecutableSections(manifest) {
+    return manifest.sections.filter((s) => s.characteristics.executable).length;
+}

package/dist/domain/processCapture.js

@@ -77,7 +77,7 @@ export const processCaptureSchema = z.object({
         sequence: z.number().int().nonnegative(),
         scheduled_at_ms: z.number().int().nonnegative(),
         dispatched_at_ms: z.number().int().nonnegative(),
-        type: z.enum(["input", "resize", "signal"]),
+        type: z.enum(["input", "resize", "stdin_close", "signal"]),
         data: z.string(),
         outcome: z.enum(["dispatched", "target_exited", "failed"]),
     })),
@@ -202,7 +202,13 @@ export const processCaptureSchema = z.object({
                 .array(z.string().min(1))
                 .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),
             action_types: z
-                .array(z.enum(["send_input", "resize", "send_signal", "checkpoint"]))
+                .array(z.enum([
+                "send_input",
+                "resize",
+                "close_stdin",
+                "send_signal",
+                "checkpoint",
+            ]))
                 .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),
         }))
             .max(PROCESS_REACTIVE_LIMITS.transitions),

package/dist/domain/processReactiveScenario.js

@@ -128,6 +128,7 @@ const processReactiveActionSchema = z.discriminatedUnion("type", [
         columns: z.number().int().min(1).max(1_000),
         rows: z.number().int().min(1).max(1_000),
     }),
+    z.strictObject({ type: z.literal("close_stdin") }),
     z.strictObject({
         type: z.literal("send_signal"),
         target: signalTargetSchema,

package/dist/domain/processReactiveTransition.js

@@ -75,6 +75,14 @@ const applyProcessReactiveTransition = (input) => {
             record,
         };
 };
+const terminalControlObservationMatches = (action, payload) => {
+    if (action.type === "resize")
+        return (payload["type"] === "resize" &&
+            payload["data"] === `${String(action.columns)}x${String(action.rows)}`);
+    if (action.type === "close_stdin")
+        return payload["type"] === "stdin_close" && payload["data"] === "";
+    return payload["type"] === "signal" && payload["data"] === action.signal;
+};
 const effectObservationMatchesAction = (action, observation, committedSensitiveInputs) => {
     const payload = typeof observation.payload === "object" &&
         observation.payload !== null &&
@@ -99,10 +107,7 @@ const effectObservationMatchesAction = (action, observation, committedSensitiveI
         return (payload["type"] === "input" &&
             payload["data"] ===
                 expectedInputEvidence(action.data, action.sensitive, committedSensitiveInputs));
-    if (action.type === "resize")
-        return (payload["type"] === "resize" &&
-            payload["data"] === `${String(action.columns)}x${String(action.rows)}`);
-    return payload["type"] === "signal" && payload["data"] === action.signal;
+    return terminalControlObservationMatches(action, payload);
 };
 const expectedInputEvidence = (data, sensitive, committedSensitiveInput) => !sensitive ||
     (committedSensitiveInput && /^<redacted-input:\d+-bytes>$/.test(data))