windows-exe-decompiler-mcp-server 0.1.0

package/dist/tools/dotnet-types-list.d.ts

@@ -0,0 +1,325 @@
+/**
+ * dotnet.types.list tool implementation
+ * Filtered type inventory derived from managed metadata extraction.
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolArgs, WorkerResult } from '../types.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+import type { DatabaseManager } from '../database.js';
+import type { CacheManager } from '../cache-manager.js';
+export declare const DotNetTypesListInputSchema: z.ZodObject<{
+    sample_id: z.ZodString;
+    namespace_prefix: z.ZodOptional<z.ZodString>;
+    include_methods: z.ZodDefault<z.ZodBoolean>;
+    max_types: z.ZodDefault<z.ZodNumber>;
+    max_methods_per_type: z.ZodDefault<z.ZodNumber>;
+    force_refresh: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    sample_id: string;
+    force_refresh: boolean;
+    include_methods: boolean;
+    max_types: number;
+    max_methods_per_type: number;
+    namespace_prefix?: string | undefined;
+}, {
+    sample_id: string;
+    force_refresh?: boolean | undefined;
+    include_methods?: boolean | undefined;
+    max_types?: number | undefined;
+    max_methods_per_type?: number | undefined;
+    namespace_prefix?: string | undefined;
+}>;
+export type DotNetTypesListInput = z.infer<typeof DotNetTypesListInputSchema>;
+export declare const DotNetTypesListOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodObject<{
+        sample_id: z.ZodString;
+        is_dotnet: z.ZodBoolean;
+        assembly_name: z.ZodNullable<z.ZodString>;
+        module_name: z.ZodNullable<z.ZodString>;
+        dotnet_version: z.ZodNullable<z.ZodString>;
+        target_framework: z.ZodNullable<z.ZodString>;
+        namespace_prefix: z.ZodNullable<z.ZodString>;
+        returned_type_count: z.ZodNumber;
+        total_type_count: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        types: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            namespace: z.ZodString;
+            name: z.ZodString;
+            full_name: z.ZodString;
+            kind: z.ZodString;
+            visibility: z.ZodString;
+            is_public: z.ZodBoolean;
+            base_type: z.ZodNullable<z.ZodString>;
+            method_count: z.ZodNumber;
+            field_count: z.ZodNumber;
+            nested_type_count: z.ZodNumber;
+            flags: z.ZodArray<z.ZodString, "many">;
+            methods: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                token: z.ZodString;
+                rva: z.ZodNumber;
+                attributes: z.ZodArray<z.ZodString, "many">;
+                is_constructor: z.ZodBoolean;
+                is_static: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                rva: number;
+                token: string;
+                attributes: string[];
+                is_constructor: boolean;
+                is_static: boolean;
+            }, {
+                name: string;
+                rva: number;
+                token: string;
+                attributes: string[];
+                is_constructor: boolean;
+                is_static: boolean;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            kind: string;
+            token: string;
+            namespace: string;
+            full_name: string;
+            visibility: string;
+            base_type: string | null;
+            method_count: number;
+            field_count: number;
+            nested_type_count: number;
+            flags: string[];
+            methods: {
+                name: string;
+                rva: number;
+                token: string;
+                attributes: string[];
+                is_constructor: boolean;
+                is_static: boolean;
+            }[];
+            is_public: boolean;
+        }, {
+            name: string;
+            kind: string;
+            token: string;
+            namespace: string;
+            full_name: string;
+            visibility: string;
+            base_type: string | null;
+            method_count: number;
+            field_count: number;
+            nested_type_count: number;
+            flags: string[];
+            methods: {
+                name: string;
+                rva: number;
+                token: string;
+                attributes: string[];
+                is_constructor: boolean;
+                is_static: boolean;
+            }[];
+            is_public: boolean;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        sample_id: string;
+        is_dotnet: boolean;
+        dotnet_version: string | null;
+        target_framework: string | null;
+        truncated: boolean;
+        types: {
+            name: string;
+            kind: string;
+            token: string;
+            namespace: string;
+            full_name: string;
+            visibility: string;
+            base_type: string | null;
+            method_count: number;
+            field_count: number;
+            nested_type_count: number;
+            flags: string[];
+            methods: {
+                name: string;
+                rva: number;
+                token: string;
+                attributes: string[];
+                is_constructor: boolean;
+                is_static: boolean;
+            }[];
+            is_public: boolean;
+        }[];
+        assembly_name: string | null;
+        module_name: string | null;
+        namespace_prefix: string | null;
+        returned_type_count: number;
+        total_type_count: number;
+    }, {
+        sample_id: string;
+        is_dotnet: boolean;
+        dotnet_version: string | null;
+        target_framework: string | null;
+        truncated: boolean;
+        types: {
+            name: string;
+            kind: string;
+            token: string;
+            namespace: string;
+            full_name: string;
+            visibility: string;
+            base_type: string | null;
+            method_count: number;
+            field_count: number;
+            nested_type_count: number;
+            flags: string[];
+            methods: {
+                name: string;
+                rva: number;
+                token: string;
+                attributes: string[];
+                is_constructor: boolean;
+                is_static: boolean;
+            }[];
+            is_public: boolean;
+        }[];
+        assembly_name: string | null;
+        module_name: string | null;
+        namespace_prefix: string | null;
+        returned_type_count: number;
+        total_type_count: number;
+    }>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        elapsed_ms: z.ZodNumber;
+        tool: z.ZodString;
+        cached: z.ZodOptional<z.ZodBoolean>;
+        cache_key: z.ZodOptional<z.ZodString>;
+        cache_tier: z.ZodOptional<z.ZodString>;
+        cache_created_at: z.ZodOptional<z.ZodString>;
+        cache_expires_at: z.ZodOptional<z.ZodString>;
+        cache_hit_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        elapsed_ms: number;
+        tool: string;
+        cached?: boolean | undefined;
+        cache_key?: string | undefined;
+        cache_tier?: string | undefined;
+        cache_created_at?: string | undefined;
+        cache_expires_at?: string | undefined;
+        cache_hit_at?: string | undefined;
+    }, {
+        elapsed_ms: number;
+        tool: string;
+        cached?: boolean | undefined;
+        cache_key?: string | undefined;
+        cache_tier?: string | undefined;
+        cache_created_at?: string | undefined;
+        cache_expires_at?: string | undefined;
+        cache_hit_at?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+        cached?: boolean | undefined;
+        cache_key?: string | undefined;
+        cache_tier?: string | undefined;
+        cache_created_at?: string | undefined;
+        cache_expires_at?: string | undefined;
+        cache_hit_at?: string | undefined;
+    } | undefined;
+    data?: {
+        sample_id: string;
+        is_dotnet: boolean;
+        dotnet_version: string | null;
+        target_framework: string | null;
+        truncated: boolean;
+        types: {
+            name: string;
+            kind: string;
+            token: string;
+            namespace: string;
+            full_name: string;
+            visibility: string;
+            base_type: string | null;
+            method_count: number;
+            field_count: number;
+            nested_type_count: number;
+            flags: string[];
+            methods: {
+                name: string;
+                rva: number;
+                token: string;
+                attributes: string[];
+                is_constructor: boolean;
+                is_static: boolean;
+            }[];
+            is_public: boolean;
+        }[];
+        assembly_name: string | null;
+        module_name: string | null;
+        namespace_prefix: string | null;
+        returned_type_count: number;
+        total_type_count: number;
+    } | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+}, {
+    ok: boolean;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+        cached?: boolean | undefined;
+        cache_key?: string | undefined;
+        cache_tier?: string | undefined;
+        cache_created_at?: string | undefined;
+        cache_expires_at?: string | undefined;
+        cache_hit_at?: string | undefined;
+    } | undefined;
+    data?: {
+        sample_id: string;
+        is_dotnet: boolean;
+        dotnet_version: string | null;
+        target_framework: string | null;
+        truncated: boolean;
+        types: {
+            name: string;
+            kind: string;
+            token: string;
+            namespace: string;
+            full_name: string;
+            visibility: string;
+            base_type: string | null;
+            method_count: number;
+            field_count: number;
+            nested_type_count: number;
+            flags: string[];
+            methods: {
+                name: string;
+                rva: number;
+                token: string;
+                attributes: string[];
+                is_constructor: boolean;
+                is_static: boolean;
+            }[];
+            is_public: boolean;
+        }[];
+        assembly_name: string | null;
+        module_name: string | null;
+        namespace_prefix: string | null;
+        returned_type_count: number;
+        total_type_count: number;
+    } | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+}>;
+export type DotNetTypesListOutput = z.infer<typeof DotNetTypesListOutputSchema>;
+export declare const dotNetTypesListToolDefinition: ToolDefinition;
+interface DotNetTypesListDependencies {
+    metadataHandler?: (args: ToolArgs) => Promise<WorkerResult>;
+}
+export declare function createDotNetTypesListHandler(workspaceManager: WorkspaceManager, database: DatabaseManager, cacheManager: CacheManager, dependencies?: DotNetTypesListDependencies): (args: ToolArgs) => Promise<WorkerResult>;
+export {};
+//# sourceMappingURL=dotnet-types-list.d.ts.map

package/dist/tools/dotnet-types-list.js

@@ -0,0 +1,201 @@
+/**
+ * dotnet.types.list tool implementation
+ * Filtered type inventory derived from managed metadata extraction.
+ */
+import { z } from 'zod';
+import { createDotNetMetadataExtractHandler, } from './dotnet-metadata-extract.js';
+const TOOL_NAME = 'dotnet.types.list';
+export const DotNetTypesListInputSchema = z.object({
+    sample_id: z.string().describe('Sample ID (format: sha256:<hex>)'),
+    namespace_prefix: z
+        .string()
+        .min(1)
+        .max(160)
+        .optional()
+        .describe('Only return managed types whose namespace starts with this prefix'),
+    include_methods: z
+        .boolean()
+        .default(false)
+        .describe('Include per-method rows for each returned type'),
+    max_types: z
+        .number()
+        .int()
+        .min(1)
+        .max(400)
+        .default(120)
+        .describe('Maximum number of managed types to return'),
+    max_methods_per_type: z
+        .number()
+        .int()
+        .min(1)
+        .max(128)
+        .default(24)
+        .describe('Maximum number of methods returned per type when include_methods=true'),
+    force_refresh: z
+        .boolean()
+        .default(false)
+        .describe('Bypass cache lookup in the underlying metadata extract step'),
+});
+const DotNetTypesListMethodSchema = z.object({
+    name: z.string(),
+    token: z.string(),
+    rva: z.number().int().nonnegative(),
+    attributes: z.array(z.string()),
+    is_constructor: z.boolean(),
+    is_static: z.boolean(),
+});
+const DotNetTypesListTypeSchema = z.object({
+    token: z.string(),
+    namespace: z.string(),
+    name: z.string(),
+    full_name: z.string(),
+    kind: z.string(),
+    visibility: z.string(),
+    is_public: z.boolean(),
+    base_type: z.string().nullable(),
+    method_count: z.number().int().nonnegative(),
+    field_count: z.number().int().nonnegative(),
+    nested_type_count: z.number().int().nonnegative(),
+    flags: z.array(z.string()),
+    methods: z.array(DotNetTypesListMethodSchema),
+});
+export const DotNetTypesListOutputSchema = z.object({
+    ok: z.boolean(),
+    data: z
+        .object({
+        sample_id: z.string(),
+        is_dotnet: z.boolean(),
+        assembly_name: z.string().nullable(),
+        module_name: z.string().nullable(),
+        dotnet_version: z.string().nullable(),
+        target_framework: z.string().nullable(),
+        namespace_prefix: z.string().nullable(),
+        returned_type_count: z.number().int().nonnegative(),
+        total_type_count: z.number().int().nonnegative(),
+        truncated: z.boolean(),
+        types: z.array(DotNetTypesListTypeSchema),
+    })
+        .optional(),
+    warnings: z.array(z.string()).optional(),
+    errors: z.array(z.string()).optional(),
+    metrics: z
+        .object({
+        elapsed_ms: z.number(),
+        tool: z.string(),
+        cached: z.boolean().optional(),
+        cache_key: z.string().optional(),
+        cache_tier: z.string().optional(),
+        cache_created_at: z.string().optional(),
+        cache_expires_at: z.string().optional(),
+        cache_hit_at: z.string().optional(),
+    })
+        .optional(),
+});
+export const dotNetTypesListToolDefinition = {
+    name: TOOL_NAME,
+    description: 'List managed types from CLR metadata, with optional namespace filtering and per-method rows.',
+    inputSchema: DotNetTypesListInputSchema,
+    outputSchema: DotNetTypesListOutputSchema,
+};
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function isPublicVisibility(value) {
+    return /\bpublic\b/i.test(value);
+}
+export function createDotNetTypesListHandler(workspaceManager, database, cacheManager, dependencies) {
+    const metadataHandler = dependencies?.metadataHandler ||
+        createDotNetMetadataExtractHandler(workspaceManager, database, cacheManager);
+    return async (args) => {
+        const startTime = Date.now();
+        try {
+            const input = DotNetTypesListInputSchema.parse(args);
+            const metadataResult = await metadataHandler({
+                sample_id: input.sample_id,
+                include_types: true,
+                include_methods: input.include_methods,
+                max_types: input.max_types,
+                max_methods_per_type: input.max_methods_per_type,
+                force_refresh: input.force_refresh,
+            });
+            if (!metadataResult.ok || !metadataResult.data) {
+                return {
+                    ok: false,
+                    errors: metadataResult.errors || ['dotnet.metadata.extract failed'],
+                    warnings: metadataResult.warnings,
+                    metrics: {
+                        ...(metadataResult.metrics || {}),
+                        elapsed_ms: Date.now() - startTime,
+                        tool: TOOL_NAME,
+                    },
+                };
+            }
+            const metadata = metadataResult.data;
+            const namespacePrefix = input.namespace_prefix?.trim() || null;
+            const filteredTypes = (metadata.types || []).filter((typeInfo) => {
+                if (!namespacePrefix) {
+                    return true;
+                }
+                return typeInfo.namespace.startsWith(namespacePrefix);
+            });
+            const types = filteredTypes.slice(0, input.max_types).map((typeInfo) => ({
+                token: typeInfo.token,
+                namespace: typeInfo.namespace,
+                name: typeInfo.name,
+                full_name: typeInfo.full_name,
+                kind: typeInfo.kind,
+                visibility: typeInfo.visibility,
+                is_public: isPublicVisibility(typeInfo.visibility),
+                base_type: typeInfo.base_type,
+                method_count: typeInfo.method_count,
+                field_count: typeInfo.field_count,
+                nested_type_count: typeInfo.nested_type_count,
+                flags: typeInfo.flags,
+                methods: input.include_methods ? typeInfo.methods.slice(0, input.max_methods_per_type) : [],
+            }));
+            const warnings = [...(metadataResult.warnings || [])];
+            if (namespacePrefix && filteredTypes.length === 0) {
+                warnings.push(`No managed types matched namespace_prefix=${namespacePrefix}.`);
+            }
+            if (filteredTypes.length > input.max_types) {
+                warnings.push(`Type list truncated from ${filteredTypes.length} to ${input.max_types}.`);
+            }
+            return {
+                ok: true,
+                data: {
+                    sample_id: input.sample_id,
+                    is_dotnet: metadata.is_dotnet,
+                    assembly_name: metadata.assembly_name,
+                    module_name: metadata.module_name,
+                    dotnet_version: metadata.dotnet_version,
+                    target_framework: metadata.target_framework,
+                    namespace_prefix: namespacePrefix,
+                    returned_type_count: types.length,
+                    total_type_count: filteredTypes.length,
+                    truncated: filteredTypes.length > input.max_types,
+                    types,
+                },
+                warnings: warnings.length > 0 ? warnings : undefined,
+                metrics: {
+                    ...(metadataResult.metrics || {}),
+                    elapsed_ms: Date.now() - startTime,
+                    tool: TOOL_NAME,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                errors: [normalizeError(error)],
+                metrics: {
+                    elapsed_ms: Date.now() - startTime,
+                    tool: TOOL_NAME,
+                },
+            };
+        }
+    };
+}
+//# sourceMappingURL=dotnet-types-list.js.map

package/dist/tools/dynamic-dependencies.d.ts

@@ -0,0 +1,115 @@
+/**
+ * dynamic.dependencies tool
+ * Dynamic-analysis capability bootstrap probe (safe: no sample execution).
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolArgs, WorkerResult } from '../types.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+import type { DatabaseManager } from '../database.js';
+export declare const DynamicDependenciesInputSchema: z.ZodObject<{
+    sample_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sample_id?: string | undefined;
+}, {
+    sample_id?: string | undefined;
+}>;
+export declare const DynamicDependenciesOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<["ready", "partial", "bootstrap_required"]>;
+        available_components: z.ZodArray<z.ZodString, "many">;
+        components: z.ZodRecord<z.ZodString, z.ZodAny>;
+        recommendations: z.ZodArray<z.ZodString, "many">;
+        checked_at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status: "partial" | "ready" | "bootstrap_required";
+        checked_at: string;
+        recommendations: string[];
+        components: Record<string, any>;
+        available_components: string[];
+    }, {
+        status: "partial" | "ready" | "bootstrap_required";
+        checked_at: string;
+        recommendations: string[];
+        components: Record<string, any>;
+        available_components: string[];
+    }>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        elapsed_ms: z.ZodNumber;
+        tool: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        elapsed_ms: number;
+        tool: string;
+    }, {
+        elapsed_ms: number;
+        tool: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+    } | undefined;
+    data?: {
+        status: "partial" | "ready" | "bootstrap_required";
+        checked_at: string;
+        recommendations: string[];
+        components: Record<string, any>;
+        available_components: string[];
+    } | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+    artifacts?: any[] | undefined;
+}, {
+    ok: boolean;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+    } | undefined;
+    data?: {
+        status: "partial" | "ready" | "bootstrap_required";
+        checked_at: string;
+        recommendations: string[];
+        components: Record<string, any>;
+        available_components: string[];
+    } | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+    artifacts?: any[] | undefined;
+}>;
+export declare const dynamicDependenciesToolDefinition: ToolDefinition;
+interface WorkerRequest {
+    job_id: string;
+    tool: string;
+    sample: {
+        sample_id: string;
+        path: string;
+    };
+    args: Record<string, unknown>;
+    context: {
+        request_time_utc: string;
+        policy: {
+            allow_dynamic: boolean;
+            allow_network: boolean;
+        };
+        versions: Record<string, string>;
+    };
+}
+interface WorkerResponse {
+    job_id: string;
+    ok: boolean;
+    warnings: string[];
+    errors: string[];
+    data: unknown;
+    artifacts: unknown[];
+    metrics: Record<string, unknown>;
+}
+interface DynamicDependenciesDependencies {
+    callWorker?: (request: WorkerRequest) => Promise<WorkerResponse>;
+}
+export declare function createDynamicDependenciesHandler(workspaceManager: WorkspaceManager, database: DatabaseManager, dependencies?: DynamicDependenciesDependencies): (args: ToolArgs) => Promise<WorkerResult>;
+export {};
+//# sourceMappingURL=dynamic-dependencies.d.ts.map