@bengabay94/mrzero 0.1.0-alpha.1

package/dist/config/tools.d.ts

@@ -0,0 +1,15 @@
+export interface ToolConfig {
+    name: string;
+    displayName: string;
+    description: string;
+    installMethod: 'docker' | 'uv' | 'gem' | 'apt' | 'manual';
+    checkCommand?: string;
+    installCommand?: string;
+    wrapperName?: string;
+}
+export declare const DOCKER_TOOLS: Record<string, ToolConfig>;
+export declare const PYTHON_TOOLS: Record<string, ToolConfig>;
+export declare const RUBY_TOOLS: Record<string, ToolConfig>;
+export declare const SYSTEM_TOOLS: Record<string, ToolConfig>;
+export declare const DOCKER_IMAGE = "ghcr.io/bengabay1994/mrzero-tools:latest";
+//# sourceMappingURL=tools.d.ts.map

package/dist/config/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/config/tools.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,QAAQ,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,CAAC;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAuEnD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAiBnD,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CASjD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAwBnD,CAAC;AAEF,eAAO,MAAM,YAAY,6CAA6C,CAAC"}

package/dist/config/tools.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCKER_IMAGE = exports.SYSTEM_TOOLS = exports.RUBY_TOOLS = exports.PYTHON_TOOLS = exports.DOCKER_TOOLS = void 0;
+exports.DOCKER_TOOLS = {
+    opengrep: {
+        name: 'opengrep',
+        displayName: 'Opengrep',
+        description: 'Pattern-based code analysis for vulnerability detection',
+        installMethod: 'docker',
+        wrapperName: 'opengrep',
+    },
+    gitleaks: {
+        name: 'gitleaks',
+        displayName: 'Gitleaks',
+        description: 'Scanning for hardcoded secrets and sensitive data',
+        installMethod: 'docker',
+        wrapperName: 'gitleaks',
+    },
+    codeql: {
+        name: 'codeql',
+        displayName: 'CodeQL',
+        description: 'Deep semantic code analysis and taint tracking',
+        installMethod: 'docker',
+        wrapperName: 'codeql',
+    },
+    joern: {
+        name: 'joern',
+        displayName: 'Joern',
+        description: 'Code property graph analysis for security flaws',
+        installMethod: 'docker',
+        wrapperName: 'joern',
+    },
+    infer: {
+        name: 'infer',
+        displayName: 'Infer',
+        description: 'Static analysis for memory safety issues',
+        installMethod: 'docker',
+        wrapperName: 'infer',
+    },
+    bearer: {
+        name: 'bearer',
+        displayName: 'Bearer',
+        description: 'Security and privacy scanning for sensitive data flows',
+        installMethod: 'docker',
+        wrapperName: 'bearer',
+    },
+    slither: {
+        name: 'slither',
+        displayName: 'Slither',
+        description: 'Solidity smart contract analysis',
+        installMethod: 'docker',
+        wrapperName: 'slither',
+    },
+    trivy: {
+        name: 'trivy',
+        displayName: 'Trivy',
+        description: 'Dependency and container vulnerability scanning',
+        installMethod: 'docker',
+        wrapperName: 'trivy',
+    },
+    linguist: {
+        name: 'linguist',
+        displayName: 'Linguist',
+        description: 'Language detection and codebase composition analysis',
+        installMethod: 'docker',
+        wrapperName: 'linguist',
+    },
+    'tree-sitter': {
+        name: 'tree-sitter',
+        displayName: 'Tree-sitter',
+        description: 'Syntax tree parsing for code understanding',
+        installMethod: 'docker',
+        wrapperName: 'tree-sitter',
+    },
+};
+exports.PYTHON_TOOLS = {
+    pwntools: {
+        name: 'pwntools',
+        displayName: 'pwntools',
+        description: 'CTF framework and exploit development library',
+        installMethod: 'uv',
+        checkCommand: 'python3 -c "import pwn"',
+        installCommand: 'uv pip install pwntools',
+    },
+    ropper: {
+        name: 'ropper',
+        displayName: 'Ropper',
+        description: 'ROP gadget finder and binary analysis',
+        installMethod: 'uv',
+        checkCommand: 'ropper --version',
+        installCommand: 'uv pip install ropper',
+    },
+};
+exports.RUBY_TOOLS = {
+    one_gadget: {
+        name: 'one_gadget',
+        displayName: 'one_gadget',
+        description: 'Find one-shot RCE gadgets in libc',
+        installMethod: 'gem',
+        checkCommand: 'one_gadget --version',
+        installCommand: 'gem install one_gadget',
+    },
+};
+exports.SYSTEM_TOOLS = {
+    docker: {
+        name: 'docker',
+        displayName: 'Docker',
+        description: 'Container runtime for isolated tools',
+        installMethod: 'manual',
+        checkCommand: 'docker --version',
+    },
+    gdb: {
+        name: 'gdb',
+        displayName: 'GDB',
+        description: 'GNU Debugger',
+        installMethod: 'apt',
+        checkCommand: 'gdb --version',
+        installCommand: 'sudo apt-get install -y gdb',
+    },
+    checksec: {
+        name: 'checksec',
+        displayName: 'checksec',
+        description: 'Check binary security features',
+        installMethod: 'apt',
+        checkCommand: 'checksec --version',
+        installCommand: 'sudo apt-get install -y checksec',
+    },
+};
+exports.DOCKER_IMAGE = 'ghcr.io/bengabay1994/mrzero-tools:latest';
+//# sourceMappingURL=tools.js.map

package/dist/config/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../src/config/tools.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const install_js_1 = require("./commands/install.js");
+const check_js_1 = require("./commands/check.js");
+const uninstall_js_1 = require("./commands/uninstall.js");
+const program = new commander_1.Command();
+program
+    .name('mrzero')
+    .description('AI-powered security research agents for vulnerability hunting and exploit development')
+    .version('1.0.0');
+program
+    .command('install')
+    .description('Install MrZero agents and tools')
+    .option('-a, --agent <agents...>', 'Specific agents to install tools for')
+    .option('-p, --platform <platforms...>', 'Target platforms (claude-code, opencode)')
+    .option('--skip-docker', 'Skip Docker image pull/build')
+    .option('--skip-mcp', 'Skip MCP server installation')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .action(install_js_1.installCommand);
+program
+    .command('check')
+    .description('Check installation status of MrZero tools')
+    .option('-v, --verbose', 'Show detailed information')
+    .action(check_js_1.checkCommand);
+program
+    .command('uninstall')
+    .description('Uninstall MrZero tools and configurations')
+    .option('--keep-agents', 'Keep agent files in platform configs')
+    .option('--keep-docker', 'Keep Docker image')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .action(uninstall_js_1.uninstallCommand);
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAEA,yCAAoC;AACpC,sDAAuD;AACvD,kDAAmD;AACnD,0DAA2D;AAE3D,MAAM,OAAO,GAAG,IAAI,mBAAO,EAAE,CAAC;AAE9B,OAAO;KACJ,IAAI,CAAC,QAAQ,CAAC;KACd,WAAW,CAAC,uFAAuF,CAAC;KACpG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEpB,OAAO;KACJ,OAAO,CAAC,SAAS,CAAC;KAClB,WAAW,CAAC,iCAAiC,CAAC;KAC9C,MAAM,CAAC,yBAAyB,EAAE,sCAAsC,CAAC;KACzE,MAAM,CAAC,+BAA+B,EAAE,0CAA0C,CAAC;KACnF,MAAM,CAAC,eAAe,EAAE,8BAA8B,CAAC;KACvD,MAAM,CAAC,YAAY,EAAE,8BAA8B,CAAC;KACpD,MAAM,CAAC,WAAW,EAAE,2BAA2B,CAAC;KAChD,MAAM,CAAC,2BAAc,CAAC,CAAC;AAE1B,OAAO;KACJ,OAAO,CAAC,OAAO,CAAC;KAChB,WAAW,CAAC,2CAA2C,CAAC;KACxD,MAAM,CAAC,eAAe,EAAE,2BAA2B,CAAC;KACpD,MAAM,CAAC,uBAAY,CAAC,CAAC;AAExB,OAAO;KACJ,OAAO,CAAC,WAAW,CAAC;KACpB,WAAW,CAAC,2CAA2C,CAAC;KACxD,MAAM,CAAC,eAAe,EAAE,sCAAsC,CAAC;KAC/D,MAAM,CAAC,eAAe,EAAE,mBAAmB,CAAC;KAC5C,MAAM,CAAC,WAAW,EAAE,2BAA2B,CAAC;KAChD,MAAM,CAAC,+BAAgB,CAAC,CAAC;AAE5B,OAAO,CAAC,KAAK,EAAE,CAAC"}

package/dist/installer/detector.d.ts

@@ -0,0 +1,52 @@
+export interface SystemInfo {
+    os: string;
+    osVersion: string;
+    arch: string;
+    docker: {
+        installed: boolean;
+        version?: string;
+    };
+    python: {
+        installed: boolean;
+        version?: string;
+    };
+    uv: {
+        installed: boolean;
+        version?: string;
+    };
+    ruby: {
+        installed: boolean;
+        version?: string;
+    };
+    git: {
+        installed: boolean;
+        version?: string;
+    };
+}
+export interface ToolStatus {
+    name: string;
+    installed: boolean;
+    version?: string;
+    path?: string;
+    method?: string;
+}
+export declare function detectSystemInfo(): Promise<SystemInfo>;
+export declare function detectGdb(): Promise<ToolStatus>;
+export declare function detectPwndbg(): Promise<ToolStatus>;
+export declare function detectGhidra(): Promise<ToolStatus>;
+export declare function detectMetasploit(): Promise<ToolStatus>;
+export declare function detectIdaPro(): Promise<ToolStatus>;
+export declare function detectIdaFree(): Promise<ToolStatus>;
+export declare function detectPythonPackage(packageName: string): Promise<ToolStatus>;
+export declare function detectRubyGem(gemName: string): Promise<ToolStatus>;
+export declare function detectDockerImage(imageName: string): Promise<boolean>;
+export declare function detectWrapper(wrapperName: string): Promise<boolean>;
+export declare function detectNativeTool(toolName: string): Promise<ToolStatus>;
+export interface DockerToolStatus {
+    name: string;
+    wrapperInstalled: boolean;
+    nativeInstalled: boolean;
+    nativePath?: string;
+}
+export declare function detectDockerTool(toolName: string): Promise<DockerToolStatus>;
+//# sourceMappingURL=detector.d.ts.map

package/dist/installer/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../src/installer/detector.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD,MAAM,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD,EAAE,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,IAAI,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,GAAG,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/C;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,UAAU,CAAC,CAqB5D;AA4DD,wBAAsB,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC,CAOrD;AAGD,wBAAsB,YAAY,IAAI,OAAO,CAAC,UAAU,CAAC,CA6CxD;AAGD,wBAAsB,YAAY,IAAI,OAAO,CAAC,UAAU,CAAC,CAmCxD;AAGD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,UAAU,CAAC,CAqB5D;AAGD,wBAAsB,YAAY,IAAI,OAAO,CAAC,UAAU,CAAC,CAsDxD;AAGD,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,CA8BzD;AAGD,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAMlF;AAGD,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAMxE;AAGD,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG3E;AAGD,wBAAsB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAqBzE;AAGD,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAY5E;AAGD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,OAAO,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAUlF"}

package/dist/installer/detector.js

@@ -0,0 +1,381 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectSystemInfo = detectSystemInfo;
+exports.detectGdb = detectGdb;
+exports.detectPwndbg = detectPwndbg;
+exports.detectGhidra = detectGhidra;
+exports.detectMetasploit = detectMetasploit;
+exports.detectIdaPro = detectIdaPro;
+exports.detectIdaFree = detectIdaFree;
+exports.detectPythonPackage = detectPythonPackage;
+exports.detectRubyGem = detectRubyGem;
+exports.detectDockerImage = detectDockerImage;
+exports.detectWrapper = detectWrapper;
+exports.detectNativeTool = detectNativeTool;
+exports.detectDockerTool = detectDockerTool;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const shell_js_1 = require("../utils/shell.js");
+const platform_js_1 = require("../utils/platform.js");
+async function detectSystemInfo() {
+    const [docker, python, uv, ruby, git] = await Promise.all([
+        detectDocker(),
+        detectPython(),
+        detectUv(),
+        detectRuby(),
+        detectGit(),
+    ]);
+    const distro = await detectLinuxDistro();
+    return {
+        os: os.platform(),
+        osVersion: distro || os.release(),
+        arch: os.arch(),
+        docker,
+        python,
+        uv,
+        ruby,
+        git,
+    };
+}
+async function detectDocker() {
+    const result = await (0, shell_js_1.exec)('docker --version');
+    if (result.code === 0) {
+        const match = result.stdout.match(/Docker version ([\d.]+)/);
+        return { installed: true, version: match?.[1] };
+    }
+    return { installed: false };
+}
+async function detectPython() {
+    const result = await (0, shell_js_1.exec)('python3 --version');
+    if (result.code === 0) {
+        const match = result.stdout.match(/Python ([\d.]+)/);
+        return { installed: true, version: match?.[1] };
+    }
+    return { installed: false };
+}
+async function detectUv() {
+    const result = await (0, shell_js_1.exec)('uv --version');
+    if (result.code === 0) {
+        const match = result.stdout.match(/uv ([\d.]+)/);
+        return { installed: true, version: match?.[1] };
+    }
+    return { installed: false };
+}
+async function detectRuby() {
+    const result = await (0, shell_js_1.exec)('ruby --version');
+    if (result.code === 0) {
+        const match = result.stdout.match(/ruby ([\d.]+)/);
+        return { installed: true, version: match?.[1] };
+    }
+    return { installed: false };
+}
+async function detectGit() {
+    const result = await (0, shell_js_1.exec)('git --version');
+    if (result.code === 0) {
+        const match = result.stdout.match(/git version ([\d.]+)/);
+        return { installed: true, version: match?.[1] };
+    }
+    return { installed: false };
+}
+async function detectLinuxDistro() {
+    try {
+        const releaseFile = '/etc/os-release';
+        if (fs.existsSync(releaseFile)) {
+            const content = fs.readFileSync(releaseFile, 'utf-8');
+            const nameMatch = content.match(/^PRETTY_NAME="?([^"\n]+)"?/m);
+            return nameMatch?.[1] || null;
+        }
+    }
+    catch { }
+    return null;
+}
+// GDB detection
+async function detectGdb() {
+    const result = await (0, shell_js_1.exec)('gdb --version');
+    if (result.code === 0) {
+        const match = result.stdout.match(/GNU gdb[^\d]*([\d.]+)/);
+        return { name: 'gdb', installed: true, version: match?.[1] };
+    }
+    return { name: 'gdb', installed: false };
+}
+// pwndbg detection - multiple methods
+async function detectPwndbg() {
+    // Method 1: Check for standalone pwndbg binary
+    if (await (0, shell_js_1.commandExists)('pwndbg')) {
+        const result = await (0, shell_js_1.exec)('which pwndbg');
+        return { name: 'pwndbg', installed: true, method: 'binary', path: result.stdout.trim() };
+    }
+    // Method 2: Check .gdbinit for pwndbg source line
+    const gdbinit = path.join((0, platform_js_1.getHomeDir)(), '.gdbinit');
+    if (fs.existsSync(gdbinit)) {
+        const content = fs.readFileSync(gdbinit, 'utf-8');
+        const match = content.match(/source\s+(.+pwndbg[^\s]*gdbinit\.py)/i);
+        if (match) {
+            return { name: 'pwndbg', installed: true, method: 'gdbinit-source', path: match[1] };
+        }
+        if (content.toLowerCase().includes('pwndbg')) {
+            return { name: 'pwndbg', installed: true, method: 'gdbinit-reference' };
+        }
+    }
+    // Method 3: Run gdb and check if pwndbg banner appears
+    try {
+        const result = await (0, shell_js_1.exec)('echo "quit" | gdb -q 2>&1', { timeout: 5000 });
+        const output = result.stdout + result.stderr;
+        if (output.toLowerCase().includes('pwndbg')) {
+            return { name: 'pwndbg', installed: true, method: 'gdb-plugin' };
+        }
+    }
+    catch { }
+    // Method 4: Check common installation paths
+    const commonPaths = [
+        path.join((0, platform_js_1.getHomeDir)(), '.pwndbg', 'gdbinit.py'),
+        path.join((0, platform_js_1.getHomeDir)(), 'pwndbg', 'gdbinit.py'),
+        '/opt/pwndbg/gdbinit.py',
+        path.join((0, platform_js_1.getHomeDir)(), 'Desktop', 'repos', 'pwndbg', 'gdbinit.py'),
+        path.join((0, platform_js_1.getHomeDir)(), 'tools', 'pwndbg', 'gdbinit.py'),
+    ];
+    for (const p of commonPaths) {
+        if (fs.existsSync(p)) {
+            return { name: 'pwndbg', installed: true, method: 'common-path', path: p };
+        }
+    }
+    return { name: 'pwndbg', installed: false };
+}
+// Ghidra detection
+async function detectGhidra() {
+    // Check for ghidraRun in PATH
+    if (await (0, shell_js_1.commandExists)('ghidraRun')) {
+        const result = await (0, shell_js_1.exec)('which ghidraRun');
+        return { name: 'ghidra', installed: true, path: result.stdout.trim() };
+    }
+    // Check common installation paths
+    const commonPaths = [
+        '/opt/ghidra',
+        '/opt/ghidra_*',
+        path.join((0, platform_js_1.getHomeDir)(), 'ghidra'),
+        path.join((0, platform_js_1.getHomeDir)(), 'ghidra_*'),
+        '/usr/local/ghidra',
+        '/usr/share/ghidra',
+    ];
+    for (const pattern of commonPaths) {
+        if (pattern.includes('*')) {
+            // Glob pattern
+            const dir = path.dirname(pattern);
+            const base = path.basename(pattern).replace('*', '');
+            if (fs.existsSync(dir)) {
+                const entries = fs.readdirSync(dir);
+                const match = entries.find((e) => e.startsWith(base));
+                if (match) {
+                    return { name: 'ghidra', installed: true, path: path.join(dir, match) };
+                }
+            }
+        }
+        else if (fs.existsSync(pattern)) {
+            return { name: 'ghidra', installed: true, path: pattern };
+        }
+    }
+    return { name: 'ghidra', installed: false };
+}
+// Metasploit detection
+async function detectMetasploit() {
+    if (await (0, shell_js_1.commandExists)('msfconsole')) {
+        const result = await (0, shell_js_1.exec)('msfconsole --version 2>/dev/null || echo ""');
+        const match = result.stdout.match(/Framework Version: ([\d.]+)/);
+        return { name: 'metasploit', installed: true, version: match?.[1] };
+    }
+    // Check common paths
+    const commonPaths = [
+        '/opt/metasploit-framework',
+        '/usr/share/metasploit-framework',
+        path.join((0, platform_js_1.getHomeDir)(), 'metasploit-framework'),
+    ];
+    for (const p of commonPaths) {
+        if (fs.existsSync(p)) {
+            return { name: 'metasploit', installed: true, path: p };
+        }
+    }
+    return { name: 'metasploit', installed: false };
+}
+// IDA Pro detection - distinguishes between Pro and Free versions
+async function detectIdaPro() {
+    // IDA Pro has idat64 (text mode batch processing) which IDA Free does NOT have
+    // This is the key differentiator between Pro and Free
+    if (await (0, shell_js_1.commandExists)('idat64')) {
+        const result = await (0, shell_js_1.exec)('which idat64');
+        return { name: 'ida-pro', installed: true, method: 'pro', path: result.stdout.trim() };
+    }
+    // Check common installation paths for IDA Pro specific indicators
+    const proPaths = [
+        '/opt/idapro',
+        '/opt/ida-pro',
+        path.join((0, platform_js_1.getHomeDir)(), 'idapro'),
+        path.join((0, platform_js_1.getHomeDir)(), 'ida-pro'),
+    ];
+    for (const p of proPaths) {
+        if (fs.existsSync(p)) {
+            // Check if idat64 exists in this directory (Pro indicator)
+            const idat64Path = path.join(p, 'idat64');
+            if (fs.existsSync(idat64Path)) {
+                return { name: 'ida-pro', installed: true, method: 'pro', path: p };
+            }
+        }
+    }
+    // Check for generic IDA paths but verify it's Pro version
+    const genericPaths = [
+        '/opt/ida*',
+        path.join((0, platform_js_1.getHomeDir)(), 'ida*'),
+    ];
+    for (const pattern of genericPaths) {
+        const dir = path.dirname(pattern);
+        const base = path.basename(pattern).replace('*', '');
+        if (fs.existsSync(dir)) {
+            try {
+                const entries = fs.readdirSync(dir);
+                for (const entry of entries) {
+                    if (entry.toLowerCase().startsWith(base.toLowerCase())) {
+                        const fullPath = path.join(dir, entry);
+                        // Check if idat64 exists (Pro indicator)
+                        const idat64Path = path.join(fullPath, 'idat64');
+                        if (fs.existsSync(idat64Path)) {
+                            return { name: 'ida-pro', installed: true, method: 'pro', path: fullPath };
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    // IDA Pro not found (IDA Free may be installed but we don't detect that here)
+    return { name: 'ida-pro', installed: false };
+}
+// IDA Free detection (separate from Pro)
+async function detectIdaFree() {
+    // Check for ida64 binary (present in both Free and Pro, but we check this after Pro detection fails)
+    if (await (0, shell_js_1.commandExists)('ida64')) {
+        const result = await (0, shell_js_1.exec)('which ida64');
+        return { name: 'ida-free', installed: true, path: result.stdout.trim() };
+    }
+    // Check common installation paths for IDA Free
+    const freePaths = [
+        '/opt/idafree*',
+        '/opt/ida-free*',
+        path.join((0, platform_js_1.getHomeDir)(), 'idafree*'),
+        path.join((0, platform_js_1.getHomeDir)(), 'ida-free*'),
+    ];
+    for (const pattern of freePaths) {
+        const dir = path.dirname(pattern);
+        const base = path.basename(pattern).replace('*', '');
+        if (fs.existsSync(dir)) {
+            try {
+                const entries = fs.readdirSync(dir);
+                const match = entries.find((e) => e.toLowerCase().startsWith(base.toLowerCase()));
+                if (match) {
+                    return { name: 'ida-free', installed: true, path: path.join(dir, match) };
+                }
+            }
+            catch { }
+        }
+    }
+    return { name: 'ida-free', installed: false };
+}
+// Check if a Python package is installed
+async function detectPythonPackage(packageName) {
+    const result = await (0, shell_js_1.exec)(`python3 -c "import ${packageName.replace('-', '_')}" 2>&1`);
+    if (result.code === 0) {
+        return { name: packageName, installed: true };
+    }
+    return { name: packageName, installed: false };
+}
+// Check if a Ruby gem is installed
+async function detectRubyGem(gemName) {
+    const result = await (0, shell_js_1.exec)(`gem list -i ${gemName}`);
+    if (result.code === 0 && result.stdout.includes('true')) {
+        return { name: gemName, installed: true };
+    }
+    return { name: gemName, installed: false };
+}
+// Check if Docker image exists
+async function detectDockerImage(imageName) {
+    const result = await (0, shell_js_1.exec)(`docker image inspect ${imageName} 2>/dev/null`);
+    return result.code === 0;
+}
+// Check if CLI wrapper exists in ~/.local/bin
+async function detectWrapper(wrapperName) {
+    const wrapperPath = path.join((0, platform_js_1.getHomeDir)(), '.local', 'bin', wrapperName);
+    if (!fs.existsSync(wrapperPath)) {
+        return false;
+    }
+    // Check if it's actually our MrZero wrapper (contains our Docker image reference)
+    try {
+        const stats = fs.lstatSync(wrapperPath);
+        // If it's a symlink, it's not our wrapper
+        if (stats.isSymbolicLink()) {
+            return false;
+        }
+        // Read the file and check if it contains our Docker image marker
+        const content = fs.readFileSync(wrapperPath, 'utf-8');
+        return content.includes('mrzero') || content.includes('MRZERO');
+    }
+    catch {
+        return false;
+    }
+}
+// Check if a native CLI tool is installed (not wrapper, actual tool in PATH)
+async function detectNativeTool(toolName) {
+    const result = await (0, shell_js_1.exec)(`which ${toolName} 2>/dev/null`);
+    if (result.code === 0) {
+        const toolPath = result.stdout.trim();
+        return {
+            name: toolName,
+            installed: true,
+            path: toolPath,
+            method: 'native'
+        };
+    }
+    return { name: toolName, installed: false };
+}
+async function detectDockerTool(toolName) {
+    const wrapperInstalled = await detectWrapper(toolName);
+    const nativeStatus = await detectNativeTool(toolName);
+    return {
+        name: toolName,
+        wrapperInstalled,
+        nativeInstalled: nativeStatus.installed,
+        nativePath: nativeStatus.installed ? nativeStatus.path : undefined,
+    };
+}
+//# sourceMappingURL=detector.js.map