windows-exe-decompiler-mcp-server 0.1.0

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import type { ToolDefinition, ToolHandler } from '../types.js';
+import type { DatabaseManager } from '../database.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+export declare const codeFunctionsSearchInputSchema: z.ZodEffects<z.ZodObject<{
+    sample_id: z.ZodString;
+    api: z.ZodOptional<z.ZodString>;
+    string: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    sample_id: string;
+    limit: number;
+    string?: string | undefined;
+    api?: string | undefined;
+}, {
+    sample_id: string;
+    string?: string | undefined;
+    timeout?: number | undefined;
+    api?: string | undefined;
+    limit?: number | undefined;
+}>, {
+    timeout: number;
+    sample_id: string;
+    limit: number;
+    string?: string | undefined;
+    api?: string | undefined;
+}, {
+    sample_id: string;
+    string?: string | undefined;
+    timeout?: number | undefined;
+    api?: string | undefined;
+    limit?: number | undefined;
+}>;
+export type CodeFunctionsSearchInput = z.infer<typeof codeFunctionsSearchInputSchema>;
+export declare const codeFunctionsSearchToolDefinition: ToolDefinition;
+export declare function createCodeFunctionsSearchHandler(workspaceManager: WorkspaceManager, database: DatabaseManager): ToolHandler;
+//# sourceMappingURL=code-functions-search.d.ts.map

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

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { DecompilerWorker, getGhidraDiagnostics, normalizeGhidraError } from '../decompiler-worker.js';
+import { logger } from '../logger.js';
+export const codeFunctionsSearchInputSchema = z
+    .object({
+    sample_id: z.string().describe('Sample identifier (sha256:<hex>)'),
+    api: z.string().optional().describe('API name or substring, e.g. WriteProcessMemory'),
+    string: z.string().optional().describe('String literal substring to reverse-map into functions'),
+    limit: z.number().int().min(1).max(200).optional().default(20),
+    timeout: z.number().int().min(5).max(300).optional().default(30).describe('Timeout in seconds for Ghidra-backed searches'),
+})
+    .refine((data) => Boolean(data.api || data.string), {
+    message: 'At least one of api or string must be provided',
+});
+export const codeFunctionsSearchToolDefinition = {
+    name: 'code.functions.search',
+    description: 'Search functions by referenced API names or string literals. Uses Ghidra when available for string-to-function mapping and falls back to function-index API search otherwise.',
+    inputSchema: codeFunctionsSearchInputSchema,
+};
+export function createCodeFunctionsSearchHandler(workspaceManager, database) {
+    return async (args) => {
+        try {
+            const input = codeFunctionsSearchInputSchema.parse(args);
+            logger.info({
+                sample_id: input.sample_id,
+                api: input.api,
+                string: input.string,
+                limit: input.limit,
+            }, 'code.functions.search tool called');
+            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,
+                };
+            }
+            const decompilerWorker = new DecompilerWorker(database, workspaceManager);
+            const result = await decompilerWorker.searchFunctions(input.sample_id, {
+                apiQuery: input.api,
+                stringQuery: input.string,
+                limit: input.limit,
+                timeout: input.timeout * 1000,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: true,
+                            data: result,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const diagnostics = getGhidraDiagnostics(error);
+            const normalizedError = normalizeGhidraError(error, 'code.functions.search');
+            logger.error({
+                error: errorMessage,
+                ghidra_diagnostics: diagnostics,
+                normalized_error: normalizedError,
+            }, 'code.functions.search tool failed');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: false,
+                            errors: [errorMessage],
+                            diagnostics,
+                            normalized_error: normalizedError,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    };
+}
+//# sourceMappingURL=code-functions-search.js.map