windows-exe-decompiler-mcp-server 0.1.0

package/dist/tools/system-health.js

@@ -0,0 +1,446 @@
+/**
+ * system.health tool implementation
+ * Aggregated runtime health checks for high-availability operations.
+ */
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { z } from 'zod';
+import { checkGhidraHealth } from '../ghidra-config.js';
+import { resolvePackagePath } from '../runtime-paths.js';
+import { lookupCachedResult } from './cache-observability.js';
+const TOOL_NAME = 'system.health';
+const ComponentSchema = z.object({
+    status: z.enum(['healthy', 'degraded', 'unhealthy', 'skipped']),
+    ok: z.boolean(),
+    error: z.string().nullable().optional(),
+    details: z.record(z.any()).optional(),
+});
+const CacheObservabilitySchema = z.object({
+    key: z.string().nullable(),
+    tier: z.string().nullable(),
+    created_at: z.string().nullable(),
+    expires_at: z.string().nullable(),
+    hit_at: z.string().nullable(),
+    sample_sha256: z.string().nullable(),
+    sample_state_consistent: z.boolean().nullable(),
+});
+export const SystemHealthInputSchema = z.object({
+    sample_id: z
+        .string()
+        .optional()
+        .describe('Optional sample ID used to verify cache metadata consistency'),
+    timeout_ms: z
+        .number()
+        .int()
+        .min(2000)
+        .max(120000)
+        .default(10000)
+        .describe('Timeout for each external probe in milliseconds'),
+    include_ghidra: z
+        .boolean()
+        .default(true)
+        .describe('Include ghidra.health probe'),
+    include_static_worker: z
+        .boolean()
+        .default(true)
+        .describe('Include Python static-worker dependency probe'),
+    include_cache_probe: z
+        .boolean()
+        .default(true)
+        .describe('Include cache observability probe (key/tier/timestamps/sample consistency)'),
+});
+export const SystemHealthOutputSchema = z.object({
+    ok: z.boolean(),
+    data: z
+        .object({
+        overall_status: z.enum(['healthy', 'degraded', 'unhealthy']),
+        checked_at: z.string(),
+        components: z.object({
+            workspace: ComponentSchema,
+            database: ComponentSchema,
+            ghidra: ComponentSchema,
+            static_worker: ComponentSchema,
+            cache: ComponentSchema,
+        }),
+        cache_observability: CacheObservabilitySchema,
+        recommendations: z.array(z.string()),
+    })
+        .optional(),
+    warnings: z.array(z.string()).optional(),
+    errors: z.array(z.string()).optional(),
+    metrics: z
+        .object({
+        elapsed_ms: z.number(),
+        tool: z.string(),
+    })
+        .optional(),
+});
+export const systemHealthToolDefinition = {
+    name: TOOL_NAME,
+    description: 'Run aggregated environment health checks (workspace, database, Ghidra, Python static worker dependencies).',
+    inputSchema: SystemHealthInputSchema,
+    outputSchema: SystemHealthOutputSchema,
+};
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+async function callStaticWorkerHealth(timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const workerPath = resolvePackagePath('workers', 'static_worker.py');
+        const pythonCommand = process.platform === 'win32' ? 'python' : 'python3';
+        const processTimeoutMs = Math.max(timeoutMs, 2000);
+        const pythonProcess = spawn(pythonCommand, [workerPath], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const onDone = (fn) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            fn();
+        };
+        const timer = setTimeout(() => {
+            onDone(() => {
+                pythonProcess.kill();
+                reject(new Error(`Static worker health probe timed out after ${processTimeoutMs}ms`));
+            });
+        }, processTimeoutMs);
+        pythonProcess.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        pythonProcess.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        pythonProcess.on('error', (error) => {
+            onDone(() => {
+                clearTimeout(timer);
+                reject(new Error(`Failed to spawn Python worker: ${error.message}`));
+            });
+        });
+        pythonProcess.on('close', (code) => {
+            onDone(() => {
+                clearTimeout(timer);
+                if (code !== 0) {
+                    reject(new Error(`Python worker exited with code ${code}. stderr: ${stderr}`));
+                    return;
+                }
+                try {
+                    const lines = stdout
+                        .trim()
+                        .split('\n')
+                        .map((line) => line.trim())
+                        .filter((line) => line.length > 0);
+                    const lastLine = lines[lines.length - 1];
+                    const response = JSON.parse(lastLine);
+                    if (!response.ok) {
+                        reject(new Error((response.errors || []).join('; ') || 'Static worker probe failed'));
+                        return;
+                    }
+                    resolve((response.data || {}));
+                }
+                catch (error) {
+                    reject(new Error(`Failed to parse static worker health response: ${normalizeError(error)}. stdout: ${stdout}`));
+                }
+            });
+        });
+        try {
+            const request = {
+                job_id: randomUUID(),
+                tool: 'system.health',
+                sample: {
+                    sample_id: 'health-check',
+                    path: '',
+                },
+                args: {},
+                context: {
+                    request_time_utc: new Date().toISOString(),
+                    policy: {
+                        allow_dynamic: false,
+                        allow_network: false,
+                    },
+                    versions: {
+                        tool_version: '1.0.0',
+                    },
+                },
+            };
+            pythonProcess.stdin.write(JSON.stringify(request) + '\n');
+            pythonProcess.stdin.end();
+        }
+        catch (error) {
+            onDone(() => {
+                clearTimeout(timer);
+                reject(new Error(`Failed to write health request: ${normalizeError(error)}`));
+            });
+        }
+    });
+}
+async function checkWorkspaceWritable(root) {
+    const probeFile = path.join(root, `.health-probe-${process.pid}-${Date.now()}.tmp`);
+    await fs.mkdir(root, { recursive: true });
+    await fs.writeFile(probeFile, `probe:${Date.now()}:${os.hostname()}`, 'utf-8');
+    await fs.unlink(probeFile);
+}
+export function createSystemHealthHandler(workspaceManager, database, dependencies) {
+    const runGhidraCheck = dependencies?.checkGhidra || checkGhidraHealth;
+    const runStaticWorkerProbe = dependencies?.probeStaticWorker || callStaticWorkerHealth;
+    const cacheManager = dependencies?.cacheManager;
+    return async (args) => {
+        const input = SystemHealthInputSchema.parse(args);
+        const startTime = Date.now();
+        try {
+            const recommendations = [];
+            const warnings = [];
+            const workspaceRoot = workspaceManager.getWorkspaceRoot();
+            let workspaceComponent;
+            try {
+                await checkWorkspaceWritable(workspaceRoot);
+                workspaceComponent = {
+                    status: 'healthy',
+                    ok: true,
+                    details: { root: workspaceRoot, writable: true },
+                };
+            }
+            catch (error) {
+                workspaceComponent = {
+                    status: 'unhealthy',
+                    ok: false,
+                    error: normalizeError(error),
+                    details: { root: workspaceRoot, writable: false },
+                };
+                recommendations.push('Fix workspace permissions/path to restore write access.');
+            }
+            let databaseComponent;
+            try {
+                const row = database.getDatabase().prepare('SELECT 1 as ok').get();
+                databaseComponent = {
+                    status: row?.ok === 1 ? 'healthy' : 'degraded',
+                    ok: row?.ok === 1,
+                    details: { query_ok: row?.ok === 1 },
+                };
+                if (row?.ok !== 1) {
+                    recommendations.push('Check database integrity and connectivity.');
+                }
+            }
+            catch (error) {
+                databaseComponent = {
+                    status: 'unhealthy',
+                    ok: false,
+                    error: normalizeError(error),
+                };
+                recommendations.push('Repair SQLite database access before production use.');
+            }
+            let ghidraComponent = {
+                status: 'skipped',
+                ok: true,
+            };
+            if (input.include_ghidra) {
+                try {
+                    const ghidraStatus = runGhidraCheck(input.timeout_ms);
+                    ghidraComponent = {
+                        status: ghidraStatus.ok ? 'healthy' : 'degraded',
+                        ok: ghidraStatus.ok,
+                        error: ghidraStatus.ok ? null : (ghidraStatus.errors || []).join('; '),
+                        details: ghidraStatus,
+                    };
+                    if (ghidraStatus.checks?.pyghidra_available === false) {
+                        warnings.push('PyGhidra is unavailable; Python post-scripts may fail and Java fallback will be used.');
+                        recommendations.push('Install pyghidra in the active Python environment to improve script compatibility.');
+                    }
+                    if (!ghidraStatus.ok) {
+                        recommendations.push('Fix Ghidra install path or launch check before decompiler workloads.');
+                    }
+                }
+                catch (error) {
+                    ghidraComponent = {
+                        status: 'degraded',
+                        ok: false,
+                        error: normalizeError(error),
+                    };
+                    recommendations.push('Investigate ghidra.health probe failure.');
+                }
+            }
+            let staticWorkerComponent = {
+                status: 'skipped',
+                ok: true,
+            };
+            if (input.include_static_worker) {
+                try {
+                    const workerHealth = await runStaticWorkerProbe(input.timeout_ms);
+                    const statusRaw = String(workerHealth.status || 'degraded').toLowerCase();
+                    const status = statusRaw === 'healthy'
+                        ? 'healthy'
+                        : statusRaw === 'unhealthy'
+                            ? 'unhealthy'
+                            : 'degraded';
+                    staticWorkerComponent = {
+                        status,
+                        ok: status === 'healthy',
+                        error: status === 'healthy' ? null : `Static worker status=${statusRaw}`,
+                        details: workerHealth,
+                    };
+                    if (status !== 'healthy') {
+                        recommendations.push('Install/repair Python dependencies (yara-python, flare-floss, yara rules) for static analysis stability.');
+                    }
+                }
+                catch (error) {
+                    staticWorkerComponent = {
+                        status: 'degraded',
+                        ok: false,
+                        error: normalizeError(error),
+                    };
+                    recommendations.push('Fix Python runtime or static worker startup to avoid analysis outages.');
+                }
+            }
+            let cacheComponent = {
+                status: 'skipped',
+                ok: true,
+                details: { reason: 'cache probe disabled' },
+            };
+            let cacheObservability = {
+                key: null,
+                tier: null,
+                created_at: null,
+                expires_at: null,
+                hit_at: null,
+                sample_sha256: null,
+                sample_state_consistent: null,
+            };
+            if (input.include_cache_probe) {
+                if (!cacheManager) {
+                    cacheComponent = {
+                        status: 'skipped',
+                        ok: true,
+                        details: { reason: 'cache manager not configured' },
+                    };
+                }
+                else {
+                    try {
+                        let expectedSampleSha;
+                        if (input.sample_id) {
+                            const sample = database.findSample(input.sample_id);
+                            if (sample) {
+                                expectedSampleSha = sample.sha256;
+                            }
+                            else {
+                                cacheComponent = {
+                                    status: 'degraded',
+                                    ok: false,
+                                    error: `Sample not found for cache consistency check: ${input.sample_id}`,
+                                };
+                                recommendations.push('Provide a valid sample_id to verify cache metadata consistency against current sample state.');
+                            }
+                        }
+                        if (cacheComponent.status !== 'degraded') {
+                            const probeKey = `health_cache_probe_${Date.now()}_${randomUUID().replace(/-/g, '')}`;
+                            const probePayload = {
+                                tool: TOOL_NAME,
+                                checked_at: new Date().toISOString(),
+                                host: os.hostname(),
+                            };
+                            await cacheManager.setCachedResult(probeKey, probePayload, 60_000, expectedSampleSha);
+                            const cachedLookup = await lookupCachedResult(cacheManager, probeKey);
+                            if (!cachedLookup) {
+                                cacheComponent = {
+                                    status: 'degraded',
+                                    ok: false,
+                                    error: 'cache probe write/read failed',
+                                    details: { probe_key: probeKey },
+                                };
+                                recommendations.push('Investigate cache read/write path; probe key was not retrievable.');
+                            }
+                            else {
+                                const metadata = cachedLookup.metadata;
+                                const sampleStateConsistent = expectedSampleSha !== undefined
+                                    ? metadata.sampleSha256 === expectedSampleSha
+                                    : null;
+                                cacheObservability = {
+                                    key: metadata.key,
+                                    tier: metadata.tier,
+                                    created_at: metadata.createdAt || null,
+                                    expires_at: metadata.expiresAt || null,
+                                    hit_at: metadata.fetchedAt || null,
+                                    sample_sha256: metadata.sampleSha256 || null,
+                                    sample_state_consistent: sampleStateConsistent,
+                                };
+                                const cacheHealthy = sampleStateConsistent !== false && typeof metadata.key === 'string';
+                                cacheComponent = {
+                                    status: cacheHealthy ? 'healthy' : 'degraded',
+                                    ok: cacheHealthy,
+                                    error: cacheHealthy ? null : 'cache metadata sample_sha256 mismatch',
+                                    details: {
+                                        probe_key: metadata.key,
+                                        tier: metadata.tier,
+                                        sample_sha256: metadata.sampleSha256 || null,
+                                        expected_sample_sha256: expectedSampleSha || null,
+                                    },
+                                };
+                                if (!cacheHealthy) {
+                                    recommendations.push('Align cache metadata sample_sha256 with active sample state to reduce stale-cache risk.');
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        cacheComponent = {
+                            status: 'degraded',
+                            ok: false,
+                            error: normalizeError(error),
+                        };
+                        recommendations.push('Fix cache probe failures to improve cache observability.');
+                    }
+                }
+            }
+            const essentialUnhealthy = workspaceComponent.status === 'unhealthy' || databaseComponent.status === 'unhealthy';
+            const optionalIssues = [ghidraComponent, staticWorkerComponent, cacheComponent].some((item) => item.status === 'degraded' || item.status === 'unhealthy');
+            const overallStatus = essentialUnhealthy
+                ? 'unhealthy'
+                : optionalIssues
+                    ? 'degraded'
+                    : 'healthy';
+            if (overallStatus !== 'healthy') {
+                warnings.push(`System health is ${overallStatus}`);
+            }
+            return {
+                ok: overallStatus !== 'unhealthy',
+                data: {
+                    overall_status: overallStatus,
+                    checked_at: new Date().toISOString(),
+                    components: {
+                        workspace: workspaceComponent,
+                        database: databaseComponent,
+                        ghidra: ghidraComponent,
+                        static_worker: staticWorkerComponent,
+                        cache: cacheComponent,
+                    },
+                    cache_observability: cacheObservability,
+                    recommendations,
+                },
+                warnings: warnings.length > 0 ? warnings : undefined,
+                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=system-health.js.map

package/dist/tools/task-cancel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * task.cancel MCP tool
+ * Cancel queued/running analysis tasks.
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolHandler } from '../types.js';
+import type { JobQueue } from '../job-queue.js';
+export declare const taskCancelInputSchema: z.ZodObject<{
+    job_id: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    job_id: string;
+    reason?: string | undefined;
+}, {
+    job_id: string;
+    reason?: string | undefined;
+}>;
+export type TaskCancelInput = z.infer<typeof taskCancelInputSchema>;
+export declare const taskCancelToolDefinition: ToolDefinition;
+export declare function createTaskCancelHandler(jobQueue: JobQueue): ToolHandler;
+//# sourceMappingURL=task-cancel.d.ts.map

package/dist/tools/task-cancel.js

@@ -0,0 +1,70 @@
+/**
+ * task.cancel MCP tool
+ * Cancel queued/running analysis tasks.
+ */
+import { z } from 'zod';
+const TOOL_NAME = 'task.cancel';
+export const taskCancelInputSchema = z.object({
+    job_id: z.string().describe('Job id to cancel'),
+    reason: z.string().optional().describe('Optional cancellation reason'),
+});
+export const taskCancelToolDefinition = {
+    name: TOOL_NAME,
+    description: 'Cancel a queued or running analysis task by job id.',
+    inputSchema: taskCancelInputSchema,
+};
+export function createTaskCancelHandler(jobQueue) {
+    return async (args) => {
+        try {
+            const input = taskCancelInputSchema.parse(args);
+            const cancelled = jobQueue.cancel(input.job_id, input.reason);
+            if (!cancelled) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                ok: false,
+                                errors: [
+                                    `Unable to cancel job ${input.job_id}. It may not exist or is already finished.`,
+                                ],
+                            }, null, 2),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: true,
+                            data: {
+                                job_id: input.job_id,
+                                cancelled: true,
+                                reason: input.reason || null,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: false,
+                            errors: [message],
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    };
+}
+//# sourceMappingURL=task-cancel.js.map

package/dist/tools/task-status.d.ts

@@ -0,0 +1,27 @@
+/**
+ * task.status MCP tool
+ * Query analysis task queue status and optional per-job details.
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolHandler } from '../types.js';
+import type { JobQueue } from '../job-queue.js';
+export declare const taskStatusInputSchema: z.ZodObject<{
+    job_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["queued", "running", "completed", "failed", "cancelled"]>>;
+    include_result: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    include_result: boolean;
+    status?: "failed" | "queued" | "running" | "completed" | "cancelled" | undefined;
+    job_id?: string | undefined;
+}, {
+    status?: "failed" | "queued" | "running" | "completed" | "cancelled" | undefined;
+    limit?: number | undefined;
+    job_id?: string | undefined;
+    include_result?: boolean | undefined;
+}>;
+export type TaskStatusInput = z.infer<typeof taskStatusInputSchema>;
+export declare const taskStatusToolDefinition: ToolDefinition;
+export declare function createTaskStatusHandler(jobQueue: JobQueue): ToolHandler;
+//# sourceMappingURL=task-status.d.ts.map

package/dist/tools/task-status.js

@@ -0,0 +1,106 @@
+/**
+ * task.status MCP tool
+ * Query analysis task queue status and optional per-job details.
+ */
+import { z } from 'zod';
+const TOOL_NAME = 'task.status';
+export const taskStatusInputSchema = z.object({
+    job_id: z.string().optional().describe('Optional job id for single-job lookup'),
+    status: z
+        .enum(['queued', 'running', 'completed', 'failed', 'cancelled'])
+        .optional()
+        .describe('Optional status filter'),
+    include_result: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Include completed/failed job result payload for single-job lookup'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(500)
+        .optional()
+        .default(100)
+        .describe('Maximum number of jobs to return'),
+});
+export const taskStatusToolDefinition = {
+    name: TOOL_NAME,
+    description: 'Get queue/running/completed status for analysis tasks, or inspect a specific job.',
+    inputSchema: taskStatusInputSchema,
+};
+export function createTaskStatusHandler(jobQueue) {
+    return async (args) => {
+        try {
+            const input = taskStatusInputSchema.parse(args);
+            if (input.job_id) {
+                const status = jobQueue.getStatus(input.job_id);
+                if (!status) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    ok: false,
+                                    errors: [`Job not found: ${input.job_id}`],
+                                }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                ok: true,
+                                data: {
+                                    job: status,
+                                    result: input.include_result ? jobQueue.getResult(input.job_id) : undefined,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            const listStatus = jobQueue.listStatuses;
+            const rows = listStatus
+                ? listStatus.call(jobQueue, input.status)
+                : jobQueue.getJobsByStatus(input.status || 'queued');
+            const limitedRows = rows.slice(0, input.limit);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: true,
+                            data: {
+                                queue_length: jobQueue.getQueueLength(),
+                                total_jobs: jobQueue.getTotalJobs(),
+                                count: limitedRows.length,
+                                jobs: limitedRows,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: false,
+                            errors: [message],
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    };
+}
+//# sourceMappingURL=task-status.js.map