windows-exe-decompiler-mcp-server 0.1.0

package/dist/ghidra-analysis-status.js

@@ -0,0 +1,178 @@
+/**
+ * Shared helpers for interpreting persisted Ghidra analysis states.
+ */
+export const GHIDRA_READY_STATUSES = new Set(['done', 'partial_success']);
+export const GHIDRA_STRICT_READY_STATUSES = new Set(['done']);
+function normalizeCapabilityStatus(raw, fallback) {
+    if (!raw || typeof raw !== 'object') {
+        return fallback;
+    }
+    const candidate = raw;
+    const statusRaw = String(candidate.status || fallback.status || 'missing').toLowerCase();
+    const status = statusRaw === 'ready'
+        ? 'ready'
+        : statusRaw === 'degraded'
+            ? 'degraded'
+            : 'missing';
+    return {
+        available: typeof candidate.available === 'boolean' ? candidate.available : status === 'ready',
+        status,
+        reason: typeof candidate.reason === 'string'
+            ? candidate.reason
+            : typeof fallback.reason === 'string'
+                ? fallback.reason
+                : undefined,
+        warnings: Array.isArray(candidate.warnings)
+            ? candidate.warnings.filter((item) => typeof item === 'string')
+            : fallback.warnings,
+        checked_at: typeof candidate.checked_at === 'string'
+            ? candidate.checked_at
+            : fallback.checked_at,
+        target: typeof candidate.target === 'string'
+            ? candidate.target
+            : fallback.target,
+        details: candidate.details && typeof candidate.details === 'object'
+            ? candidate.details
+            : fallback.details,
+    };
+}
+function buildLegacyCapabilityFallback(capability, analysis, metadata) {
+    const hasProject = Boolean(metadata.project_path && metadata.project_key);
+    const functionCount = typeof metadata.function_count === 'number'
+        ? metadata.function_count
+        : 0;
+    const extractionStatus = String(metadata.function_extraction?.status || '').toLowerCase();
+    const extractionWarnings = Array.isArray(metadata.function_extraction?.warnings)
+        ? metadata.function_extraction?.warnings
+        : undefined;
+    const strictReady = isStrictGhidraReadyStatus(analysis.status);
+    const looseReady = isGhidraReadyStatus(analysis.status);
+    if (capability === 'function_index') {
+        if (functionCount > 0) {
+            return {
+                available: true,
+                status: 'ready',
+                warnings: extractionWarnings,
+            };
+        }
+        if (looseReady && extractionStatus === 'failed') {
+            return {
+                available: false,
+                status: 'missing',
+                reason: 'Function extraction failed after headless analysis completed.',
+                warnings: extractionWarnings,
+            };
+        }
+        if (looseReady) {
+            return {
+                available: false,
+                status: 'missing',
+                reason: 'Legacy Ghidra record has no extracted function index.',
+                warnings: extractionWarnings,
+            };
+        }
+        return {
+            available: false,
+            status: 'missing',
+            reason: 'No completed function-index extraction recorded.',
+        };
+    }
+    if (hasProject && strictReady) {
+        return {
+            available: true,
+            status: 'ready',
+            warnings: extractionWarnings,
+        };
+    }
+    if (hasProject && looseReady) {
+        return {
+            available: false,
+            status: 'degraded',
+            reason: capability === 'decompile'
+                ? 'Project metadata exists, but decompile readiness was not validated.'
+                : 'Project metadata exists, but CFG readiness was not validated.',
+            warnings: extractionWarnings,
+        };
+    }
+    return {
+        available: false,
+        status: 'missing',
+        reason: capability === 'decompile'
+            ? 'No decompile-capable Ghidra project metadata found.'
+            : 'No CFG-capable Ghidra project metadata found.',
+        warnings: extractionWarnings,
+    };
+}
+export function parseGhidraAnalysisMetadata(outputJson) {
+    if (!outputJson) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(outputJson);
+        if (!parsed || typeof parsed !== 'object') {
+            return {};
+        }
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+export function isGhidraReadyStatus(status) {
+    if (!status) {
+        return false;
+    }
+    return GHIDRA_READY_STATUSES.has(status);
+}
+export function isStrictGhidraReadyStatus(status) {
+    if (!status) {
+        return false;
+    }
+    return GHIDRA_STRICT_READY_STATUSES.has(status);
+}
+export function getGhidraReadiness(analysis) {
+    const metadata = parseGhidraAnalysisMetadata(analysis.output_json);
+    const readiness = metadata.readiness || {};
+    return {
+        function_index: normalizeCapabilityStatus(readiness.function_index, buildLegacyCapabilityFallback('function_index', analysis, metadata)),
+        decompile: normalizeCapabilityStatus(readiness.decompile, buildLegacyCapabilityFallback('decompile', analysis, metadata)),
+        cfg: normalizeCapabilityStatus(readiness.cfg, buildLegacyCapabilityFallback('cfg', analysis, metadata)),
+    };
+}
+export function getGhidraCapabilityStatus(analysis, capability) {
+    return getGhidraReadiness(analysis)[capability];
+}
+export function isGhidraCapabilityReady(analysis, capability) {
+    const state = getGhidraCapabilityStatus(analysis, capability);
+    return state.available === true && state.status === 'ready';
+}
+function analysisSortKey(analysis) {
+    const candidates = [analysis.finished_at, analysis.started_at];
+    for (const candidate of candidates) {
+        if (!candidate) {
+            continue;
+        }
+        const ts = new Date(candidate).getTime();
+        if (Number.isFinite(ts)) {
+            return ts;
+        }
+    }
+    return 0;
+}
+export function findBestGhidraAnalysis(analyses, capability) {
+    const sorted = [...analyses]
+        .filter((analysis) => analysis.backend === 'ghidra')
+        .sort((left, right) => analysisSortKey(right) - analysisSortKey(left));
+    if (!capability) {
+        return sorted[0];
+    }
+    const ready = sorted.find((analysis) => isGhidraCapabilityReady(analysis, capability));
+    if (ready) {
+        return ready;
+    }
+    return sorted.find((analysis) => {
+        const status = getGhidraCapabilityStatus(analysis, capability);
+        return status.status === 'degraded';
+    });
+}
+//# sourceMappingURL=ghidra-analysis-status.js.map

package/dist/ghidra-config.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Ghidra Headless configuration and validation
+ * Handles detection, validation, and configuration of Ghidra installation
+ */
+export interface GhidraConfig {
+    installDir: string;
+    analyzeHeadlessPath: string;
+    scriptsDir: string;
+    version?: string;
+    isValid: boolean;
+}
+export interface GhidraHealthStatus {
+    ok: boolean;
+    checked_at: string;
+    install_dir: string;
+    analyze_headless_path: string;
+    scripts_dir: string;
+    version?: string;
+    checks: {
+        install_dir_exists: boolean;
+        analyze_headless_exists: boolean;
+        scripts_dir_exists: boolean;
+        launch_ok: boolean;
+        pyghidra_available: boolean;
+    };
+    launch_probe?: {
+        raw_cmd: string;
+        exit_code: number | null;
+        timed_out: boolean;
+        stdout: string;
+        stderr: string;
+        stdout_encoding: string;
+        stderr_encoding: string;
+    };
+    pyghidra_probe?: {
+        command: string;
+        available: boolean;
+        version?: string;
+        error?: string;
+    };
+    errors: string[];
+    warnings: string[];
+}
+export interface ProcessInvocation {
+    command: string;
+    args: string[];
+    windowsVerbatimArguments?: boolean;
+}
+export declare function probePyGhidraAvailability(timeoutMs?: number): {
+    command: string;
+    available: boolean;
+    version?: string;
+    error?: string;
+};
+/**
+ * Quote argument for Windows cmd.exe command line.
+ * Keeps special characters literal, including &, (), and spaces.
+ */
+export declare function quoteForWindowsCmd(value: string): string;
+/**
+ * Build explicit cmd.exe invocation for .bat/.cmd entry points on Windows.
+ * Avoids `shell: true` and path-splitting issues on special characters.
+ */
+export declare function buildWindowsBatchInvocation(command: string, args: string[]): ProcessInvocation;
+/**
+ * Build portable process invocation.
+ * On Windows batch scripts we explicitly route through cmd.exe.
+ */
+export declare function buildProcessInvocation(command: string, args: string[], platform?: NodeJS.Platform): ProcessInvocation;
+/**
+ * Detect Ghidra installation from environment variable or common paths
+ */
+export declare function detectGhidraInstallation(): string | null;
+/**
+ * Validate Ghidra installation directory
+ */
+export declare function validateGhidraInstallation(installDir: string): boolean;
+/**
+ * Get path to analyzeHeadless script based on platform
+ */
+export declare function getAnalyzeHeadlessPath(installDir: string): string;
+/**
+ * Get Ghidra version from installation
+ */
+export declare function getGhidraVersion(installDir: string): string | null;
+/**
+ * Ensure Ghidra scripts directory exists
+ */
+export declare function ensureScriptsDirectory(baseDir?: string): string;
+/**
+ * Initialize Ghidra configuration
+ */
+export declare function initializeGhidraConfig(installDir?: string): GhidraConfig;
+/**
+ * Generate unique project key for Ghidra project
+ * Format: <timestamp>_<random>
+ * Ensures uniqueness for concurrent analyses
+ *
+ * Requirements: 8.1, 8.7
+ */
+export declare function generateProjectKey(): string;
+/**
+ * Create Ghidra project directory
+ * Creates isolated project space to avoid concurrent conflicts
+ *
+ * Requirements: 8.1, 8.7
+ *
+ * @param ghidraWorkspaceDir - Base Ghidra workspace directory (from workspace manager)
+ * @param projectKey - Unique project key (optional, will be generated if not provided)
+ * @returns Object with project path and project key
+ */
+export declare function createGhidraProject(ghidraWorkspaceDir: string, projectKey?: string): {
+    projectPath: string;
+    projectKey: string;
+};
+/**
+ * Clean up old Ghidra projects
+ * Removes project directories older than specified age
+ *
+ * @param ghidraWorkspaceDir - Base Ghidra workspace directory
+ * @param maxAgeMs - Maximum age in milliseconds (default: 7 days)
+ * @returns Number of projects cleaned up
+ */
+export declare function cleanupOldGhidraProjects(ghidraWorkspaceDir: string, maxAgeMs?: number): number;
+/**
+ * Perform a lightweight Ghidra environment health check.
+ * This verifies path resolution and attempts a short `analyzeHeadless -help` launch.
+ */
+export declare function checkGhidraHealth(timeoutMs?: number): GhidraHealthStatus;
+/**
+ * Global Ghidra configuration instance
+ */
+export declare const ghidraConfig: GhidraConfig;
+//# sourceMappingURL=ghidra-config.d.ts.map