@naraya/cli 0.1.0 → 0.4.0

package/dist/pentest/installer/tool-installer.js

@@ -0,0 +1,90 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+export async function checkToolInstalled(tool) {
+    try {
+        const { stdout } = await execAsync(tool.check_installed.command, { timeout: 10000 });
+        let version;
+        if (tool.check_installed.parse_version) {
+            const match = stdout.match(new RegExp(tool.check_installed.parse_version));
+            version = match?.[1];
+        }
+        return {
+            tools_name: tool.tools_name,
+            installed: true,
+            version
+        };
+    }
+    catch (error) {
+        return {
+            tools_name: tool.tools_name,
+            installed: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+        };
+    }
+}
+export async function checkAllToolsInstalled(tools) {
+    return Promise.all(tools.map(checkToolInstalled));
+}
+export function getInstallCommand(tool, platform = process.platform) {
+    const config = tool.installation[platform];
+    return config?.command ?? null;
+}
+export function getInstallCommands(tool) {
+    const result = {};
+    if (tool.installation.linux)
+        result.linux = tool.installation.linux;
+    if (tool.installation.darwin)
+        result.darwin = tool.installation.darwin;
+    if (tool.installation.win32)
+        result.win32 = tool.installation.win32;
+    return result;
+}
+export async function installTool(tool, platform = process.platform) {
+    const config = tool.installation[platform];
+    if (!config) {
+        return {
+            success: false,
+            message: `No installation command available for platform: ${platform}`
+        };
+    }
+    try {
+        const { stdout, stderr } = await execAsync(config.command, { timeout: 300000 });
+        return {
+            success: true,
+            message: stdout || stderr || "Installation completed"
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : "Installation failed"
+        };
+    }
+}
+export function getMissingTools(availability) {
+    return availability.filter(a => !a.installed);
+}
+export function getInstalledTools(availability) {
+    return availability.filter(a => a.installed);
+}
+export async function ensureToolsInstalled(tools, platform = process.platform) {
+    const availability = await checkAllToolsInstalled(tools);
+    const missing = getMissingTools(availability);
+    const failed = [];
+    for (const tool of missing) {
+        const toolEntry = tools.find(t => t.tools_name === tool.tools_name);
+        if (!toolEntry)
+            continue;
+        const result = await installTool(toolEntry, platform);
+        if (!result.success) {
+            failed.push({ tool: tool.tools_name, error: result.message });
+        }
+    }
+    const recheck = await checkAllToolsInstalled(tools);
+    return {
+        installed: getInstalledTools(recheck),
+        missing: getMissingTools(recheck),
+        failed
+    };
+}

package/dist/pentest/manager.js

@@ -0,0 +1,125 @@
+import { discoverSkills, loadSkill, loadAllSkills, loadSkillsByPhase } from "./skills/loader/skill-loader.js";
+import { SkillRegister } from "./skills/register/skill-register.js";
+import { selectTools, selectToolsByPhase, selectToolsByCategory } from "./selector/tool-selector.js";
+import { buildCommand, buildCommandWithSudo, validateRequiredFlags } from "./command-builder/command-builder.js";
+import { checkToolInstalled, checkAllToolsInstalled, getInstallCommand, installTool } from "./installer/tool-installer.js";
+import { selectMode, detectMode, getModeConfig, getSkillsForMode, getLoopConfig, getSafetyConfig } from "./mode/mode-selector.js";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+const DEFAULT_SKILL_DIRS = [
+    "assets/agents/skills",
+    "skills/",
+    "packages/pentest-skills/skills",
+];
+const DEFAULT_CATALOG_PATH = "tools-catalog.json";
+export class PentestManager {
+    config;
+    cache = {
+        manifests: new Map(),
+        skills: new Map(),
+        catalog: null,
+    };
+    skillRegister = null;
+    constructor(config = {}) {
+        this.config = {
+            baseDir: config.baseDir ?? process.cwd(),
+            skillDirs: config.skillDirs ?? DEFAULT_SKILL_DIRS,
+            configPath: config.configPath ?? join(config.baseDir ?? process.cwd(), ".pentestrc"),
+            catalogPath: config.catalogPath ?? join(config.baseDir ?? process.cwd(), DEFAULT_CATALOG_PATH),
+        };
+    }
+    // ── Mode Operations ──
+    selectMode(options = {}) {
+        return selectMode(options);
+    }
+    detectMode(target) {
+        return detectMode(target);
+    }
+    getModeConfig(mode) {
+        return getModeConfig(mode);
+    }
+    getSkillsForMode(mode) {
+        return getSkillsForMode(mode);
+    }
+    getLoopConfig(mode) {
+        return getLoopConfig(mode);
+    }
+    getSafetyConfig(mode) {
+        return getSafetyConfig(mode);
+    }
+    // ── Skill Operations ──
+    discoverSkills() {
+        return discoverSkills(this.config.baseDir);
+    }
+    loadSkill(skillName) {
+        return loadSkill(skillName, this.config.baseDir);
+    }
+    loadAllSkills() {
+        return loadAllSkills(this.config.baseDir);
+    }
+    loadSkillsByPhase(phase) {
+        return loadSkillsByPhase(phase, this.config.baseDir);
+    }
+    // ── Catalog Operations ──
+    async loadCatalog() {
+        if (this.cache.catalog)
+            return this.cache.catalog;
+        const catalogPath = this.config.catalogPath;
+        if (!existsSync(catalogPath)) {
+            throw new Error(`Tools catalog not found: ${catalogPath}`);
+        }
+        const content = readFileSync(catalogPath, "utf-8");
+        this.cache.catalog = JSON.parse(content);
+        return this.cache.catalog;
+    }
+    async selectTools(options) {
+        const catalog = await this.loadCatalog();
+        return selectTools(catalog, options);
+    }
+    async selectToolsByPhase(phase) {
+        const catalog = await this.loadCatalog();
+        return selectToolsByPhase(catalog, phase);
+    }
+    async selectToolsByCategory(category) {
+        const catalog = await this.loadCatalog();
+        return selectToolsByCategory(catalog, category);
+    }
+    // ── Command Operations ──
+    buildToolCommand(tool, flags = {}, positional = []) {
+        const result = buildCommand(tool, { flags, positional });
+        return result.fullCommand;
+    }
+    buildToolCommandWithSudo(tool, flags = {}, positional = []) {
+        return buildCommandWithSudo(tool, { flags, positional });
+    }
+    validateToolFlags(tool, flags) {
+        return validateRequiredFlags(tool, { flags });
+    }
+    // ── Installation Operations ──
+    async checkToolInstalled(tool) {
+        return checkToolInstalled(tool);
+    }
+    async checkAllToolsInstalled(tools) {
+        return checkAllToolsInstalled(tools);
+    }
+    getInstallCommandForTool(tool) {
+        return getInstallCommand(tool);
+    }
+    async installTool(tool) {
+        return installTool(tool);
+    }
+    // ── Skill Register ──
+    getRegister() {
+        if (!this.skillRegister) {
+            this.skillRegister = new SkillRegister({
+                skills_dir: join(this.config.baseDir, ".agents/skills"),
+                search_paths: [
+                    join(this.config.baseDir, ".agents/skills"),
+                    join(this.config.baseDir, ".opencode/skills"),
+                    join(this.config.baseDir, ".claude/skills"),
+                ],
+            });
+        }
+        return this.skillRegister;
+    }
+}

package/dist/pentest/mode/index.js

@@ -0,0 +1 @@
+export * from "./mode-selector.js";

package/dist/pentest/mode/mode-selector.js

@@ -0,0 +1,127 @@
+import { MODE_PRESETS } from "../types.js";
+const WEB_EXTENSIONS = [".php", ".asp", ".aspx", ".jsp", ".cgi", ".pl", ".py", ".rb"];
+const NETWORK_PORTS = [22, 23, 3389, 445, 139, 135, 1433, 3306, 5432, 27017];
+const CTF_INDICATORS = ["ctf", "chall", "pwn", "crypto", "forensics", "rev", "misc", "web"];
+const RED_TEAM_INDICATORS = ["ad", "active-directory", "kerberos", "ldap", "smb", "rdp"];
+export function detectMode(target) {
+    const lower = target.toLowerCase();
+    for (const indicator of CTF_INDICATORS) {
+        if (lower.includes(indicator)) {
+            return { mode: "ctf", reason: `CTF indicator detected: ${indicator}` };
+        }
+    }
+    for (const indicator of RED_TEAM_INDICATORS) {
+        if (lower.includes(indicator)) {
+            return { mode: "red-team", reason: `Red team indicator detected: ${indicator}` };
+        }
+    }
+    for (const ext of WEB_EXTENSIONS) {
+        if (lower.endsWith(ext)) {
+            return { mode: "bug-bounty", reason: `Web extension detected: ${ext}` };
+        }
+    }
+    const portMatch = lower.match(/:(\d+)/);
+    if (portMatch) {
+        const port = parseInt(portMatch[1], 10);
+        if (NETWORK_PORTS.includes(port)) {
+            return { mode: "red-team", reason: `Network service port detected: ${port}` };
+        }
+    }
+    if (lower.includes("http://") || lower.includes("https://")) {
+        return { mode: "bug-bounty", reason: "Web target detected (HTTP/HTTPS)" };
+    }
+    const ipMatch = lower.match(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/);
+    if (ipMatch) {
+        return { mode: "red-team", reason: `IP address target: ${ipMatch[0]}` };
+    }
+    return { mode: "auto", reason: "No specific indicators detected, using adaptive mode" };
+}
+export function selectMode(options = {}) {
+    if (options.preferred_mode && options.preferred_mode !== "auto") {
+        const config = MODE_PRESETS[options.preferred_mode];
+        return {
+            selected_mode: options.preferred_mode,
+            config,
+            auto_detected: false,
+            detection_reason: `User selected mode: ${options.preferred_mode}`,
+        };
+    }
+    if (options.auto_detect !== false && options.target) {
+        const detection = detectMode(options.target);
+        if (detection.mode !== "auto") {
+            const config = MODE_PRESETS[detection.mode];
+            return {
+                selected_mode: detection.mode,
+                config,
+                auto_detected: true,
+                detection_reason: detection.reason,
+            };
+        }
+    }
+    const config = MODE_PRESETS["auto"];
+    return {
+        selected_mode: "auto",
+        config,
+        auto_detected: false,
+        detection_reason: "No specific mode detected, using adaptive auto mode",
+    };
+}
+export function getModeConfig(mode) {
+    return MODE_PRESETS[mode];
+}
+export function getToolsForMode(mode, availableTools) {
+    const config = MODE_PRESETS[mode];
+    const priority = config.tool_priority;
+    const prioritized = [];
+    const remaining = [];
+    for (const tool of availableTools) {
+        const toolCategory = getToolCategory(tool);
+        if (toolCategory && priority.includes(toolCategory)) {
+            prioritized.push(tool);
+        }
+        else {
+            remaining.push(tool);
+        }
+    }
+    prioritized.sort((a, b) => {
+        const catA = getToolCategory(a);
+        const catB = getToolCategory(b);
+        if (!catA || !catB)
+            return 0;
+        return priority.indexOf(catA) - priority.indexOf(catB);
+    });
+    return [...prioritized, ...remaining];
+}
+function getToolCategory(toolName) {
+    const categoryMap = {
+        subfinder: "recon", amass: "recon", assetfinder: "recon", httpx: "recon",
+        naabu: "recon", massdns: "recon", nmap: "enumeration", nuclei: "enumeration",
+        ffuf: "enumeration", dirsearch: "enumeration", gobuster: "enumeration",
+        feroxbuster: "enumeration", whatweb: "enumeration", wafw00f: "enumeration",
+        nikto: "enumeration", burpsuite: "enumeration", owasp_zap: "enumeration",
+        sqlmap: "exploitation", commix: "exploitation", hydra: "exploitation",
+        hashcat: "exploitation", john: "exploitation", metasploit: "exploitation",
+        pwntools: "exploitation",
+        curl: "utility", jq: "utility", anew: "utility", grep: "utility",
+        sort: "utility", uniq: "utility", notify: "reporting",
+    };
+    return categoryMap[toolName];
+}
+export function getSkillsForMode(mode) {
+    return [...MODE_PRESETS[mode].skill_chain];
+}
+export function getLoopConfig(mode) {
+    return MODE_PRESETS[mode].loop_config;
+}
+export function getSafetyConfig(mode) {
+    return MODE_PRESETS[mode].safety_constraints;
+}
+export function getReportFormat(mode) {
+    return MODE_PRESETS[mode].report_format;
+}
+export function isModeStealth(mode) {
+    return MODE_PRESETS[mode].stealth;
+}
+export function getModeParallelism(mode) {
+    return MODE_PRESETS[mode].parallelism;
+}

package/dist/pentest/selector/index.js

@@ -0,0 +1 @@
+export * from "./tool-selector.js";

package/dist/pentest/selector/tool-selector.js

@@ -0,0 +1,66 @@
+export function selectTools(catalog, options) {
+    let results = [...catalog.tools];
+    if (options.category) {
+        results = results.filter(t => t.category === options.category);
+    }
+    if (options.phase) {
+        results = results.filter(t => t.phase.includes(options.phase));
+    }
+    if (options.tags && options.tags.length > 0) {
+        results = results.filter(t => options.tags.some(tag => t.tags.includes(tag)));
+    }
+    if (options.requires_root !== undefined) {
+        results = results.filter(t => t.requires_root === options.requires_root);
+    }
+    return results;
+}
+export function selectToolsByPhase(catalog, phase) {
+    return selectTools(catalog, { phase });
+}
+export function selectToolsByCategory(catalog, category) {
+    return selectTools(catalog, { category });
+}
+export function selectToolsByTags(catalog, tags) {
+    return selectTools(catalog, { tags });
+}
+export function groupToolsByPhase(catalog) {
+    const groups = {
+        recon: [],
+        enumeration: [],
+        exploitation: [],
+        reporting: [],
+        utility: []
+    };
+    for (const tool of catalog.tools) {
+        for (const phase of tool.phase) {
+            if (groups[phase]) {
+                groups[phase].push(tool);
+            }
+        }
+    }
+    return groups;
+}
+export function groupToolsByCategory(catalog) {
+    const groups = {};
+    for (const category of catalog.categories) {
+        groups[category] = [];
+    }
+    for (const tool of catalog.tools) {
+        if (groups[tool.category]) {
+            groups[tool.category].push(tool);
+        }
+    }
+    return groups;
+}
+export function findAlternatives(catalog, toolName) {
+    const tool = catalog.tools.find(t => t.tools_name === toolName);
+    if (!tool?.alternatives?.length)
+        return [];
+    return catalog.tools.filter(t => tool.alternatives.includes(t.tools_name));
+}
+export function getToolPipeline(catalog, toolName) {
+    const tool = catalog.tools.find(t => t.tools_name === toolName);
+    if (!tool?.command.pipes?.length)
+        return [];
+    return catalog.tools.filter(t => tool.command.pipes.includes(t.tools_name));
+}

package/dist/pentest/skill-bridge/index.js

@@ -0,0 +1 @@
+export * from "./skill-bridge.js";

package/dist/pentest/skill-bridge/skill-bridge.js

@@ -0,0 +1,66 @@
+import { existsSync } from "fs";
+import { join } from "path";
+const SKILL_DIRS = [
+    ".agents/skills",
+    ".opencode/skills",
+    ".claude/skills"
+];
+export function resolveSkillPath(skillName, baseDir = process.cwd()) {
+    for (const dir of SKILL_DIRS) {
+        const skillPath = join(baseDir, dir, skillName, "SKILL.md");
+        if (existsSync(skillPath)) {
+            return skillPath;
+        }
+    }
+    return null;
+}
+export function loadToolSkill(tool, baseDir = process.cwd()) {
+    const skillPath = resolveSkillPath(tool.skills_loader, baseDir);
+    if (!skillPath) {
+        return {
+            skill_name: tool.skills_loader,
+            loaded: false,
+            error: `Skill not found: ${tool.skills_loader}`
+        };
+    }
+    return {
+        skill_name: tool.skills_loader,
+        skill_path: skillPath,
+        loaded: true
+    };
+}
+export function loadToolSkills(tools, baseDir = process.cwd()) {
+    return tools.map(tool => loadToolSkill(tool, baseDir));
+}
+export function getSkillForTool(tools, toolName) {
+    const tool = tools.find(t => t.tools_name === toolName);
+    if (!tool)
+        return null;
+    return loadToolSkill(tool);
+}
+export function groupToolsBySkill(tools) {
+    const groups = {};
+    for (const tool of tools) {
+        const skill = tool.skills_loader;
+        if (!groups[skill]) {
+            groups[skill] = [];
+        }
+        groups[skill].push(tool);
+    }
+    return groups;
+}
+export function getToolsForSkill(tools, skillName) {
+    return tools.filter(t => t.skills_loader === skillName);
+}
+export function buildSkillManifest(tools, baseDir = process.cwd()) {
+    const grouped = groupToolsBySkill(tools);
+    return Object.entries(grouped).map(([skillName, skillTools]) => {
+        const skillPath = resolveSkillPath(skillName, baseDir);
+        return {
+            skill_name: skillName,
+            skill_path: skillPath,
+            tools: skillTools,
+            available: skillPath !== null
+        };
+    });
+}

package/dist/pentest/skills/generator/index.js

@@ -0,0 +1 @@
+export * from "./skill-generator.js";