windows-exe-decompiler-mcp-server 0.1.0

package/dist/tools/code-functions-list.d.ts

@@ -0,0 +1,37 @@
+/**
+ * code.functions.list MCP Tool
+ *
+ * Requirements: 9.1
+ *
+ * Lists all functions extracted from a binary sample
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolHandler } from '../types.js';
+import type { DatabaseManager } from '../database.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+/**
+ * Input schema for code.functions.list tool
+ */
+export declare const codeFunctionsListInputSchema: z.ZodObject<{
+    sample_id: z.ZodString;
+    backend: z.ZodOptional<z.ZodEnum<["ghidra", "auto"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sample_id: string;
+    backend?: "ghidra" | "auto" | undefined;
+    limit?: number | undefined;
+}, {
+    sample_id: string;
+    backend?: "ghidra" | "auto" | undefined;
+    limit?: number | undefined;
+}>;
+export type CodeFunctionsListInput = z.infer<typeof codeFunctionsListInputSchema>;
+/**
+ * Tool definition for code.functions.list
+ */
+export declare const codeFunctionsListToolDefinition: ToolDefinition;
+/**
+ * Create handler for code.functions.list tool
+ */
+export declare function createCodeFunctionsListHandler(workspaceManager: WorkspaceManager, database: DatabaseManager): ToolHandler;
+//# sourceMappingURL=code-functions-list.d.ts.map

package/dist/tools/code-functions-list.js

@@ -0,0 +1,91 @@
+/**
+ * code.functions.list MCP Tool
+ *
+ * Requirements: 9.1
+ *
+ * Lists all functions extracted from a binary sample
+ */
+import { z } from 'zod';
+import { DecompilerWorker } from '../decompiler-worker.js';
+import { logger } from '../logger.js';
+/**
+ * Input schema for code.functions.list tool
+ */
+export const codeFunctionsListInputSchema = z.object({
+    sample_id: z.string().describe('Sample identifier (sha256:<hex>)'),
+    backend: z.enum(['ghidra', 'auto']).optional().describe('Decompiler backend (default: auto)'),
+    limit: z.number().optional().describe('Maximum number of functions to return')
+});
+/**
+ * Tool definition for code.functions.list
+ */
+export const codeFunctionsListToolDefinition = {
+    name: 'code.functions.list',
+    description: 'List all functions extracted from a binary sample. Requires prior Ghidra analysis.',
+    inputSchema: codeFunctionsListInputSchema
+};
+/**
+ * Create handler for code.functions.list tool
+ */
+export function createCodeFunctionsListHandler(workspaceManager, database) {
+    return async (args) => {
+        try {
+            const input = codeFunctionsListInputSchema.parse(args);
+            logger.info({
+                sample_id: input.sample_id,
+                limit: input.limit
+            }, 'code.functions.list tool called');
+            // Check if sample exists
+            const sample = database.findSample(input.sample_id);
+            if (!sample) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                ok: false,
+                                errors: [`Sample not found: ${input.sample_id}`]
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+            // Create decompiler worker
+            const decompilerWorker = new DecompilerWorker(database, workspaceManager);
+            // List functions
+            const functions = await decompilerWorker.listFunctions(input.sample_id, input.limit);
+            logger.info({
+                sample_id: input.sample_id,
+                function_count: functions.length
+            }, 'Functions listed successfully');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: true,
+                            data: {
+                                functions,
+                                count: functions.length
+                            }
+                        }, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error({
+                error: errorMessage
+            }, 'code.functions.list tool failed');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: false,
+                            errors: [errorMessage]
+                        }, null, 2)
+                    }],
+                isError: true
+            };
+        }
+    };
+}
+//# sourceMappingURL=code-functions-list.js.map

package/dist/tools/code-functions-rank.d.ts

@@ -0,0 +1,34 @@
+/**
+ * code.functions.rank MCP Tool
+ *
+ * Requirements: 9.2, 9.8
+ *
+ * Ranks functions by interest score
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolHandler } from '../types.js';
+import type { DatabaseManager } from '../database.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+/**
+ * Input schema for code.functions.rank tool
+ */
+export declare const codeFunctionsRankInputSchema: z.ZodObject<{
+    sample_id: z.ZodString;
+    topk: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sample_id: string;
+    topk?: number | undefined;
+}, {
+    sample_id: string;
+    topk?: number | undefined;
+}>;
+export type CodeFunctionsRankInput = z.infer<typeof codeFunctionsRankInputSchema>;
+/**
+ * Tool definition for code.functions.rank
+ */
+export declare const codeFunctionsRankToolDefinition: ToolDefinition;
+/**
+ * Create handler for code.functions.rank tool
+ */
+export declare function createCodeFunctionsRankHandler(workspaceManager: WorkspaceManager, database: DatabaseManager): ToolHandler;
+//# sourceMappingURL=code-functions-rank.d.ts.map

package/dist/tools/code-functions-rank.js

@@ -0,0 +1,90 @@
+/**
+ * code.functions.rank MCP Tool
+ *
+ * Requirements: 9.2, 9.8
+ *
+ * Ranks functions by interest score
+ */
+import { z } from 'zod';
+import { DecompilerWorker } from '../decompiler-worker.js';
+import { logger } from '../logger.js';
+/**
+ * Input schema for code.functions.rank tool
+ */
+export const codeFunctionsRankInputSchema = z.object({
+    sample_id: z.string().describe('Sample identifier (sha256:<hex>)'),
+    topk: z.number().optional().describe('Number of top functions to return (default: 20)')
+});
+/**
+ * Tool definition for code.functions.rank
+ */
+export const codeFunctionsRankToolDefinition = {
+    name: 'code.functions.rank',
+    description: 'Rank functions by interest score based on size, callers, sensitive API calls, and entry points. Returns top K functions.',
+    inputSchema: codeFunctionsRankInputSchema
+};
+/**
+ * Create handler for code.functions.rank tool
+ */
+export function createCodeFunctionsRankHandler(workspaceManager, database) {
+    return async (args) => {
+        try {
+            const input = codeFunctionsRankInputSchema.parse(args);
+            logger.info({
+                sample_id: input.sample_id,
+                topk: input.topk
+            }, 'code.functions.rank tool called');
+            // Check if sample exists
+            const sample = database.findSample(input.sample_id);
+            if (!sample) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                ok: false,
+                                errors: [`Sample not found: ${input.sample_id}`]
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+            // Create decompiler worker
+            const decompilerWorker = new DecompilerWorker(database, workspaceManager);
+            // Rank functions
+            const rankedFunctions = await decompilerWorker.rankFunctions(input.sample_id, input.topk || 20);
+            logger.info({
+                sample_id: input.sample_id,
+                function_count: rankedFunctions.length
+            }, 'Functions ranked successfully');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: true,
+                            data: {
+                                functions: rankedFunctions,
+                                count: rankedFunctions.length
+                            }
+                        }, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error({
+                error: errorMessage
+            }, 'code.functions.rank tool failed');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: false,
+                            errors: [errorMessage]
+                        }, null, 2)
+                    }],
+                isError: true
+            };
+        }
+    };
+}
+//# sourceMappingURL=code-functions-rank.js.map