windows-exe-decompiler-mcp-server 0.1.0

package/dist/tools/dynamic-trace-import.js

@@ -0,0 +1,235 @@
+/**
+ * dynamic.trace.import tool
+ * Import external runtime API traces or memory-snapshot summaries into the MCP workspace.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { createHash, randomUUID } from 'crypto';
+import { z } from 'zod';
+import { normalizeDynamicTrace, normalizeDynamicTraceArtifactPayload, summarizeDynamicTrace, } from '../dynamic-trace.js';
+const TOOL_NAME = 'dynamic.trace.import';
+const DynamicTraceImportInputSchema = z
+    .object({
+    sample_id: z.string().describe('Sample ID (format: sha256:<hex>)'),
+    format: z
+        .enum(['auto', 'normalized', 'generic_json', 'frida_json', 'speakeasy_json'])
+        .optional()
+        .default('auto')
+        .describe('Format hint for imported trace payload'),
+    evidence_kind: z
+        .enum(['trace', 'memory_snapshot', 'hybrid'])
+        .optional()
+        .default('trace')
+        .describe('Whether the imported evidence reflects executed runtime trace, memory snapshot, or hybrid evidence'),
+    path: z.string().optional().describe('Path to external JSON trace file'),
+    trace_json: z.any().optional().describe('Inline JSON payload to import when path is not used'),
+    trace_name: z.string().optional().describe('Optional source name used in persisted artifact naming'),
+    persist_artifact: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('Persist normalized trace into workspace reports/dynamic'),
+    register_analysis: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('Insert a completed analysis row for imported runtime evidence'),
+})
+    .refine((value) => Boolean(value.path) !== Boolean(value.trace_json), {
+    message: 'Provide exactly one of `path` or `trace_json`.',
+});
+const DynamicTraceImportOutputSchema = z.object({
+    ok: z.boolean(),
+    data: z
+        .object({
+        trace_id: z.string(),
+        format: z.string(),
+        evidence_kind: z.string(),
+        executed: z.boolean(),
+        summary: z.object({
+            artifact_count: z.number(),
+            executed: z.boolean(),
+            api_count: z.number(),
+            memory_region_count: z.number(),
+            stage_count: z.number(),
+            observed_apis: z.array(z.string()),
+            high_signal_apis: z.array(z.string()),
+            memory_regions: z.array(z.string()),
+            stages: z.array(z.string()),
+            risk_hints: z.array(z.string()),
+            evidence: z.array(z.string()),
+            summary: z.string(),
+        }),
+        normalized_trace: z.any(),
+        analysis_id: z.string().optional(),
+        artifact: z
+            .object({
+            id: z.string(),
+            type: z.string(),
+            path: z.string(),
+            sha256: z.string(),
+            mime: z.string().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    warnings: z.array(z.string()).optional(),
+    errors: z.array(z.string()).optional(),
+    artifacts: z.array(z.any()).optional(),
+    metrics: z
+        .object({
+        elapsed_ms: z.number(),
+        tool: z.string(),
+    })
+        .optional(),
+});
+export const dynamicTraceImportToolDefinition = {
+    name: TOOL_NAME,
+    description: 'Import external runtime API traces or memory-snapshot summaries (Frida/Speakeasy/generic JSON) into the workspace and register them as MCP artifacts.',
+    inputSchema: DynamicTraceImportInputSchema,
+    outputSchema: DynamicTraceImportOutputSchema,
+};
+function sanitizeName(value) {
+    const base = (value || 'trace').trim().toLowerCase();
+    const normalized = base.replace(/[^a-z0-9._-]+/g, '_').replace(/^_+|_+$/g, '');
+    return normalized.length > 0 ? normalized.slice(0, 48) : 'trace';
+}
+function resolveSourceFormat(inputFormat, normalizedHint) {
+    if (normalizedHint) {
+        return normalizedHint.source_format;
+    }
+    if (inputFormat === 'auto' || inputFormat === 'normalized') {
+        return 'generic_json';
+    }
+    return inputFormat;
+}
+async function readInputPayload(input) {
+    if (input.path) {
+        const content = await fs.readFile(input.path, 'utf-8');
+        return JSON.parse(content);
+    }
+    if (typeof input.trace_json === 'string') {
+        return JSON.parse(input.trace_json);
+    }
+    return input.trace_json;
+}
+export function createDynamicTraceImportHandler(workspaceManager, database) {
+    return async (args) => {
+        const startTime = Date.now();
+        try {
+            const input = DynamicTraceImportInputSchema.parse(args);
+            const sample = database.findSample(input.sample_id);
+            if (!sample) {
+                return {
+                    ok: false,
+                    errors: [`Sample not found: ${input.sample_id}`],
+                    metrics: {
+                        elapsed_ms: Date.now() - startTime,
+                        tool: TOOL_NAME,
+                    },
+                };
+            }
+            const rawPayload = await readInputPayload(input);
+            const autoNormalized = input.format === 'auto' || input.format === 'normalized'
+                ? normalizeDynamicTraceArtifactPayload(rawPayload)
+                : null;
+            const normalizedTrace = autoNormalized ||
+                normalizeDynamicTrace(rawPayload, {
+                    sourceFormat: resolveSourceFormat(input.format, autoNormalized),
+                    evidenceKind: input.evidence_kind,
+                    sourceName: input.trace_name || (input.path ? path.basename(input.path) : undefined),
+                });
+            const summary = summarizeDynamicTrace(normalizedTrace);
+            const warnings = [];
+            const artifacts = [];
+            let persistedArtifact;
+            let analysisId;
+            if (!normalizedTrace.executed) {
+                warnings.push('Imported evidence does not prove full execution; treat it as memory or hybrid runtime evidence until corroborated.');
+            }
+            if (input.persist_artifact) {
+                const workspace = await workspaceManager.createWorkspace(input.sample_id);
+                const reportDir = path.join(workspace.reports, 'dynamic');
+                await fs.mkdir(reportDir, { recursive: true });
+                const fileName = `imported_${sanitizeName(input.trace_name || path.basename(input.path || 'trace'))}_${Date.now()}.json`;
+                const absPath = path.join(reportDir, fileName);
+                const serialized = JSON.stringify(normalizedTrace, null, 2);
+                await fs.writeFile(absPath, serialized, 'utf-8');
+                const artifactId = randomUUID();
+                const artifactSha256 = createHash('sha256').update(serialized).digest('hex');
+                const relativePath = `reports/dynamic/${fileName}`;
+                database.insertArtifact({
+                    id: artifactId,
+                    sample_id: input.sample_id,
+                    type: 'dynamic_trace_json',
+                    path: relativePath,
+                    sha256: artifactSha256,
+                    mime: 'application/json',
+                    created_at: new Date().toISOString(),
+                });
+                persistedArtifact = {
+                    id: artifactId,
+                    type: 'dynamic_trace_json',
+                    path: relativePath,
+                    sha256: artifactSha256,
+                    mime: 'application/json',
+                };
+                artifacts.push(persistedArtifact);
+            }
+            if (input.register_analysis) {
+                analysisId = randomUUID();
+                database.insertAnalysis({
+                    id: analysisId,
+                    sample_id: input.sample_id,
+                    stage: 'dynamic_trace_import',
+                    backend: 'runtime_import',
+                    status: 'done',
+                    started_at: new Date(startTime).toISOString(),
+                    finished_at: new Date().toISOString(),
+                    output_json: JSON.stringify({
+                        trace_format: normalizedTrace.source_format,
+                        evidence_kind: normalizedTrace.evidence_kind,
+                        executed: normalizedTrace.executed,
+                        summary,
+                        artifact_id: persistedArtifact?.id,
+                    }),
+                    metrics_json: JSON.stringify({
+                        api_count: summary.api_count,
+                        memory_region_count: summary.memory_region_count,
+                        stage_count: summary.stage_count,
+                    }),
+                });
+            }
+            return {
+                ok: true,
+                data: {
+                    trace_id: randomUUID(),
+                    format: normalizedTrace.source_format,
+                    evidence_kind: normalizedTrace.evidence_kind,
+                    executed: normalizedTrace.executed,
+                    summary,
+                    normalized_trace: normalizedTrace,
+                    analysis_id: analysisId,
+                    artifact: persistedArtifact,
+                },
+                warnings: warnings.length > 0 ? warnings : undefined,
+                artifacts: artifacts.length > 0 ? artifacts : undefined,
+                metrics: {
+                    elapsed_ms: Date.now() - startTime,
+                    tool: TOOL_NAME,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                errors: [error.message],
+                metrics: {
+                    elapsed_ms: Date.now() - startTime,
+                    tool: TOOL_NAME,
+                },
+            };
+        }
+    };
+}
+//# sourceMappingURL=dynamic-trace-import.js.map

package/dist/tools/entrypoint-fallback-disasm.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Helpers for fallback disassembly via static_worker entrypoint.disasm.
+ */
+export interface EntrypointFallbackResult {
+    function: string;
+    address: string;
+    entry_point_rva: string;
+    entry_section: string;
+    architecture: string;
+    backend: string;
+    parser: string;
+    instruction_count: number;
+    assembly: string;
+    bytes_window: number;
+    requested_address?: string | null;
+    requested_rva?: string | null;
+    resolved_from?: string;
+}
+export interface EntrypointFallbackPayload {
+    result: EntrypointFallbackResult;
+    warnings?: string[];
+    metrics?: Record<string, unknown>;
+}
+export declare function runEntrypointFallbackDisasm(samplePath: string, options?: {
+    max_instructions?: number;
+    max_bytes?: number;
+    target_address?: string;
+    target_symbol?: string;
+}): Promise<EntrypointFallbackPayload>;
+//# sourceMappingURL=entrypoint-fallback-disasm.d.ts.map

package/dist/tools/entrypoint-fallback-disasm.js

@@ -0,0 +1,89 @@
+/**
+ * Helpers for fallback disassembly via static_worker entrypoint.disasm.
+ */
+import { spawn } from 'child_process';
+import { v4 as uuidv4 } from 'uuid';
+import { resolvePackagePath } from '../runtime-paths.js';
+function getPythonCommand() {
+    return process.platform === 'win32' ? 'python' : 'python3';
+}
+export async function runEntrypointFallbackDisasm(samplePath, options) {
+    const request = {
+        job_id: uuidv4(),
+        tool: 'entrypoint.disasm',
+        sample: {
+            sample_id: 'sha256:fallback',
+            path: samplePath,
+        },
+        args: {
+            max_instructions: options?.max_instructions ?? 120,
+            max_bytes: options?.max_bytes ?? 1024,
+            target_address: options?.target_address,
+            target_symbol: options?.target_symbol,
+        },
+        context: {
+            request_time_utc: new Date().toISOString(),
+            policy: {
+                allow_dynamic: false,
+                allow_network: false,
+            },
+            versions: {
+                tool_version: 'fallback-0.1.0',
+            },
+        },
+    };
+    const response = await callStaticWorker(request);
+    if (!response.ok) {
+        throw new Error(response.errors.join('; ') || 'entrypoint.disasm failed');
+    }
+    const payload = response.data;
+    if (!payload || !payload.result || !payload.result.assembly) {
+        throw new Error('entrypoint.disasm returned invalid payload');
+    }
+    return {
+        result: payload.result,
+        warnings: payload.warnings || response.warnings || [],
+        metrics: payload.metrics || response.metrics,
+    };
+}
+async function callStaticWorker(request) {
+    return new Promise((resolve, reject) => {
+        const workerPath = resolvePackagePath('workers', 'static_worker.py');
+        const child = spawn(getPythonCommand(), [workerPath], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to spawn Python worker: ${error.message}`));
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Python worker exited with code ${code}. stderr: ${stderr}`));
+                return;
+            }
+            try {
+                const lines = stdout.trim().split('\n');
+                const lastLine = lines[lines.length - 1];
+                resolve(JSON.parse(lastLine));
+            }
+            catch (error) {
+                reject(new Error(`Failed to parse worker response: ${error.message}. stdout: ${stdout}`));
+            }
+        });
+        try {
+            child.stdin.write(JSON.stringify(request) + '\n');
+            child.stdin.end();
+        }
+        catch (error) {
+            reject(new Error(`Failed to write to worker stdin: ${error.message}`));
+        }
+    });
+}
+//# sourceMappingURL=entrypoint-fallback-disasm.js.map

package/dist/tools/ghidra-analyze.d.ts

@@ -0,0 +1,88 @@
+/**
+ * ghidra.analyze MCP Tool
+ *
+ * Requirements: 8.1, 8.2, 8.3
+ *
+ * Analyzes a binary sample with Ghidra Headless and extracts function list
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolHandler } from '../types.js';
+import type { DatabaseManager } from '../database.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+import type { JobQueue } from '../job-queue.js';
+/**
+ * Input schema for ghidra.analyze tool
+ * Requirements: 8.1
+ */
+export declare const ghidraAnalyzeInputSchema: z.ZodObject<{
+    sample_id: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        timeout: z.ZodOptional<z.ZodNumber>;
+        max_cpu: z.ZodOptional<z.ZodString>;
+        project_key: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        project_key?: string | undefined;
+        max_cpu?: string | undefined;
+    }, {
+        timeout?: number | undefined;
+        project_key?: string | undefined;
+        max_cpu?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    sample_id: string;
+    options?: {
+        timeout?: number | undefined;
+        project_key?: string | undefined;
+        max_cpu?: string | undefined;
+    } | undefined;
+}, {
+    sample_id: string;
+    options?: {
+        timeout?: number | undefined;
+        project_key?: string | undefined;
+        max_cpu?: string | undefined;
+    } | undefined;
+}>;
+export type GhidraAnalyzeInput = z.infer<typeof ghidraAnalyzeInputSchema>;
+/**
+ * Output schema for ghidra.analyze tool
+ * Requirements: 8.2, 8.3
+ */
+export interface GhidraAnalyzeOutput {
+    ok: boolean;
+    data?: {
+        analysis_id: string;
+        job_id?: string;
+        backend: string;
+        function_count: number;
+        project_path: string;
+        status: string;
+        capabilities?: {
+            function_index: unknown;
+            decompile: unknown;
+            cfg: unknown;
+        };
+    };
+    diagnostics?: unknown;
+    normalized_error?: unknown;
+    errors?: string[];
+    warnings?: string[];
+}
+/**
+ * Tool definition for ghidra.analyze
+ * Requirements: 8.1, 8.2, 8.3
+ */
+export declare const ghidraAnalyzeToolDefinition: ToolDefinition;
+/**
+ * Create handler for ghidra.analyze tool
+ *
+ * Requirements: 8.1, 8.2, 8.3, 8.4, 8.5, 8.6
+ *
+ * @param workspaceManager - Workspace manager instance
+ * @param database - Database manager instance
+ * @param jobQueue - Job queue instance (optional, for async execution)
+ * @returns Tool handler function
+ */
+export declare function createGhidraAnalyzeHandler(workspaceManager: WorkspaceManager, database: DatabaseManager, jobQueue?: JobQueue): ToolHandler;
+//# sourceMappingURL=ghidra-analyze.d.ts.map

package/dist/tools/ghidra-analyze.js

@@ -0,0 +1,208 @@
+/**
+ * ghidra.analyze MCP Tool
+ *
+ * Requirements: 8.1, 8.2, 8.3
+ *
+ * Analyzes a binary sample with Ghidra Headless and extracts function list
+ */
+import { z } from 'zod';
+import { DecompilerWorker, getGhidraDiagnostics, normalizeGhidraError } from '../decompiler-worker.js';
+import { findBestGhidraAnalysis, getGhidraReadiness, parseGhidraAnalysisMetadata, } from '../ghidra-analysis-status.js';
+import { logger } from '../logger.js';
+/**
+ * Input schema for ghidra.analyze tool
+ * Requirements: 8.1
+ */
+export const ghidraAnalyzeInputSchema = z.object({
+    sample_id: z.string().describe('Sample identifier (sha256:<hex>)'),
+    options: z.object({
+        timeout: z.number().optional().describe('Analysis timeout in seconds (default: 300)'),
+        max_cpu: z.string().optional().describe('Maximum CPU cores to use (default: "4")'),
+        project_key: z.string().optional().describe('Optional project key for reusing existing project')
+    }).optional().describe('Ghidra analysis options')
+});
+/**
+ * Tool definition for ghidra.analyze
+ * Requirements: 8.1, 8.2, 8.3
+ */
+export const ghidraAnalyzeToolDefinition = {
+    name: 'ghidra.analyze',
+    description: 'Analyze a binary sample with Ghidra Headless and extract function list. This is a long-running operation that may take several minutes depending on sample size.',
+    inputSchema: ghidraAnalyzeInputSchema
+};
+/**
+ * Create handler for ghidra.analyze tool
+ *
+ * Requirements: 8.1, 8.2, 8.3, 8.4, 8.5, 8.6
+ *
+ * @param workspaceManager - Workspace manager instance
+ * @param database - Database manager instance
+ * @param jobQueue - Job queue instance (optional, for async execution)
+ * @returns Tool handler function
+ */
+export function createGhidraAnalyzeHandler(workspaceManager, database, jobQueue) {
+    return async (args) => {
+        try {
+            // Validate input
+            const input = ghidraAnalyzeInputSchema.parse(args);
+            logger.info({
+                sample_id: input.sample_id,
+                options: input.options
+            }, 'ghidra.analyze 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);
+            const analyses = database.findAnalysesBySample(input.sample_id);
+            const reusableAnalysis = (() => {
+                if (input.options?.project_key) {
+                    return analyses.find((analysis) => {
+                        if (analysis.backend !== 'ghidra') {
+                            return false;
+                        }
+                        const metadata = parseGhidraAnalysisMetadata(analysis.output_json);
+                        return (metadata.project_key === input.options?.project_key &&
+                            getGhidraReadiness(analysis).function_index.status === 'ready');
+                    });
+                }
+                return findBestGhidraAnalysis(analyses, 'function_index');
+            })();
+            if (reusableAnalysis) {
+                const metadata = parseGhidraAnalysisMetadata(reusableAnalysis.output_json);
+                const reusedOutput = {
+                    ok: true,
+                    data: {
+                        analysis_id: reusableAnalysis.id,
+                        backend: reusableAnalysis.backend,
+                        function_count: typeof metadata.function_count === 'number' ? metadata.function_count : 0,
+                        project_path: typeof metadata.project_path === 'string' ? metadata.project_path : '',
+                        status: 'reused',
+                        capabilities: getGhidraReadiness(reusableAnalysis),
+                    },
+                    warnings: [
+                        input.options?.project_key
+                            ? `Reused existing completed Ghidra analysis for project_key=${input.options.project_key}.`
+                            : 'Reused existing completed Ghidra analysis for this sample.',
+                    ],
+                };
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(reusedOutput, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Convert timeout from seconds to milliseconds
+            const timeoutMs = (input.options?.timeout || 300) * 1000;
+            // Prepare Ghidra options
+            const ghidraOptions = {
+                timeout: timeoutMs,
+                maxCpu: input.options?.max_cpu || '4',
+                projectKey: input.options?.project_key
+            };
+            // If job queue is available, enqueue the analysis
+            if (jobQueue) {
+                const jobId = await jobQueue.enqueue({
+                    type: 'decompile',
+                    tool: 'ghidra.analyze',
+                    sampleId: input.sample_id,
+                    args: input,
+                    priority: 5,
+                    timeout: timeoutMs,
+                    retryPolicy: {
+                        maxRetries: 2,
+                        backoffMs: 5000,
+                        retryableErrors: ['E_TIMEOUT', 'E_RESOURCE_EXHAUSTED']
+                    }
+                });
+                logger.info({
+                    job_id: jobId,
+                    sample_id: input.sample_id
+                }, 'Ghidra analysis job enqueued');
+                const output = {
+                    ok: true,
+                    data: {
+                        analysis_id: jobId,
+                        job_id: jobId,
+                        backend: 'ghidra',
+                        function_count: 0,
+                        project_path: '',
+                        status: 'queued'
+                    }
+                };
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(output, null, 2)
+                        }
+                    ]
+                };
+            }
+            // Otherwise, execute synchronously
+            const result = await decompilerWorker.analyze(input.sample_id, ghidraOptions);
+            logger.info({
+                analysis_id: result.analysisId,
+                function_count: result.functionCount
+            }, 'Ghidra analysis completed');
+            const output = {
+                ok: true,
+                data: {
+                    analysis_id: result.analysisId,
+                    backend: result.backend,
+                    function_count: result.functionCount,
+                    project_path: result.projectPath,
+                    status: result.status === 'partial_success' ? 'partial_success' : 'completed',
+                    capabilities: result.readiness,
+                },
+                warnings: result.warnings,
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(output, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const diagnostics = getGhidraDiagnostics(error);
+            const normalizedError = normalizeGhidraError(error, 'ghidra.analyze');
+            logger.error({
+                error: errorMessage,
+                ghidra_diagnostics: diagnostics,
+                normalized_error: normalizedError,
+            }, 'ghidra.analyze tool failed');
+            const output = {
+                ok: false,
+                diagnostics,
+                normalized_error: normalizedError,
+                errors: [errorMessage]
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(output, null, 2)
+                    }],
+                isError: true
+            };
+        }
+    };
+}
+//# sourceMappingURL=ghidra-analyze.js.map

package/dist/tools/ghidra-health.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ghidra.health MCP Tool
+ *
+ * Performs both environment validation and an optional downstream live probe
+ * against a real analyzed sample/project to verify end-to-end usability.
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolHandler } from '../types.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+import type { DatabaseManager } from '../database.js';
+import { type GhidraHealthStatus } from '../ghidra-config.js';
+import { DecompilerWorker } from '../decompiler-worker.js';
+export declare const ghidraHealthInputSchema: z.ZodObject<{
+    timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sample_id: z.ZodOptional<z.ZodString>;
+    include_end_to_end: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    stale_running_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    timeout_ms: number;
+    include_end_to_end: boolean;
+    sample_id?: string | undefined;
+    stale_running_ms?: number | null | undefined;
+}, {
+    sample_id?: string | undefined;
+    timeout_ms?: number | undefined;
+    stale_running_ms?: number | null | undefined;
+    include_end_to_end?: boolean | undefined;
+}>;
+export type GhidraHealthInput = z.infer<typeof ghidraHealthInputSchema>;
+export declare const ghidraHealthToolDefinition: ToolDefinition;
+interface GhidraHealthDependencies {
+    checkGhidra?: (timeoutMs: number) => GhidraHealthStatus;
+    decompilerWorker?: Pick<DecompilerWorker, 'decompileFunction' | 'getFunctionCFG'>;
+}
+export declare function createGhidraHealthHandler(workspaceManager?: WorkspaceManager, database?: DatabaseManager, dependencies?: GhidraHealthDependencies): ToolHandler;
+export {};
+//# sourceMappingURL=ghidra-health.d.ts.map