@naraya/cli 0.1.0 → 0.4.0

package/dist/pentest/skills/generator/skill-generator.js

@@ -0,0 +1,310 @@
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+const DEFAULT_OUTPUT_DIR = ".agents/skills";
+const TEMPLATES = {
+    basic: generateBasicTemplate,
+    recon: generateReconTemplate,
+    exploitation: generateExploitationTemplate,
+    reporting: generateReportingTemplate,
+    custom: generateBasicTemplate,
+};
+export function generateSkill(options, catalog) {
+    const templateName = options.template ?? "basic";
+    const templateFn = TEMPLATES[templateName] ?? TEMPLATES.basic;
+    const catalogTools = catalog
+        ? catalog.tools.filter(t => options.tools.includes(t.tools_name))
+        : [];
+    const content = templateFn(options, catalogTools);
+    const outputDir = options.output_dir ?? DEFAULT_OUTPUT_DIR;
+    const skillDir = join(outputDir, options.name);
+    const skillPath = join(skillDir, "SKILL.md");
+    return {
+        name: options.name,
+        content,
+        path: skillPath,
+        tools_referenced: options.tools,
+        phase: options.phase,
+    };
+}
+export function generateAndSaveSkill(options, catalog) {
+    const skill = generateSkill(options, catalog);
+    const dir = dirname(skill.path);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(skill.path, skill.content);
+    return skill.path;
+}
+export function generateSkillsForPhase(phase, catalog, outputDir) {
+    const phaseTools = catalog.tools.filter(t => t.phase.includes(phase));
+    const skills = [];
+    for (const tool of phaseTools) {
+        const template = phaseToTemplate(phase);
+        const skill = generateSkill({
+            name: `${tool.tools_name}-${phase}`,
+            description: `Automated ${phase} skill using ${tool.tools_name}: ${tool.description}`,
+            phase: [phase],
+            category: [tool.category],
+            tools: [tool.tools_name],
+            tags: [...tool.tags],
+            output_dir: outputDir,
+            template,
+        }, catalog);
+        skills.push(skill);
+    }
+    return skills;
+}
+export function generateSkillsForTool(toolName, catalog, outputDir) {
+    const tool = catalog.tools.find(t => t.tools_name === toolName);
+    if (!tool)
+        return [];
+    return tool.phase.map(phase => {
+        return generateSkill({
+            name: `${toolName}-${phase}`,
+            description: `${tool.description} — ${phase} phase skill`,
+            phase: [phase],
+            category: [tool.category],
+            tools: [toolName],
+            tags: [...tool.tags, phase],
+            output_dir: outputDir,
+            template: phaseToTemplate(phase),
+        }, catalog);
+    });
+}
+export function generateFullPentestSuite(catalog, outputDir) {
+    const allSkills = [];
+    for (const category of catalog.categories) {
+        const skills = generateSkillsForPhase(category, catalog, outputDir);
+        allSkills.push(...skills);
+    }
+    return allSkills;
+}
+export function saveGeneratedSkills(skills) {
+    const paths = [];
+    for (const skill of skills) {
+        const dir = dirname(skill.path);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(skill.path, skill.content);
+        paths.push(skill.path);
+    }
+    return paths;
+}
+function phaseToTemplate(phase) {
+    switch (phase) {
+        case "recon":
+        case "enumeration":
+            return "recon";
+        case "exploitation":
+            return "exploitation";
+        case "reporting":
+            return "reporting";
+        default:
+            return "basic";
+    }
+}
+function buildFrontmatter(options) {
+    const lines = [
+        "---",
+        `name: ${options.name}`,
+        `description: "${options.description}"`,
+        `version: 1.0.0`,
+        `phase: [${options.phase.map(p => `"${p}"`).join(", ")}]`,
+        `category: [${options.category.map(c => `"${c}"`).join(", ")}]`,
+        `tools: [${options.tools.map(t => `"${t}"`).join(", ")}]`,
+        `tags: [${(options.tags ?? []).map(t => `"${t}"`).join(", ")}]`,
+    ];
+    if (options.author) {
+        lines.push(`author: "${options.author}"`);
+    }
+    lines.push("---");
+    return lines.join("\n");
+}
+function buildToolReferenceSection(tools) {
+    if (tools.length === 0)
+        return "";
+    const lines = ["\n## Tools Reference\n"];
+    for (const tool of tools) {
+        lines.push(`### ${tool.tools_name}`);
+        lines.push(`${tool.description}\n`);
+        lines.push(`**Command:** \`${tool.command.base}\``);
+        lines.push(`**Category:** ${tool.category}`);
+        lines.push(`**Phase:** ${tool.phase.join(", ")}`);
+        lines.push(`**Requires root:** ${tool.requires_root ? "Yes" : "No"}`);
+        if (tool.command.flags.length > 0) {
+            lines.push("\n**Key flags:**");
+            for (const flag of tool.command.flags.slice(0, 5)) {
+                const req = flag.required ? " (required)" : "";
+                lines.push(`- \`${flag.name}\` — ${flag.description}${req}`);
+            }
+        }
+        if (tool.homepage) {
+            lines.push(`\n**Homepage:** ${tool.homepage}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function generateBasicTemplate(options, tools) {
+    const fm = buildFrontmatter(options);
+    const toolRef = buildToolReferenceSection(tools);
+    return `${fm}
+
+# ${options.name}
+
+${options.description}
+
+## Prerequisites
+
+${tools.map(t => `- ${t.tools_name} must be installed and accessible`).join("\n")}
+
+## Usage
+
+\`\`\`bash
+# Step 1: Run the tool(s)
+${tools.map(t => `${t.command.base} ${t.command.flags.filter(f => f.required).map(f => `${f.name} <value>`).join(" ")}`).join("\n")}
+\`\`\`
+
+## Expected Output
+
+Describe expected output and how to interpret results.
+
+## Next Steps
+
+Describe follow-up actions based on findings.
+${toolRef}`;
+}
+function generateReconTemplate(options, tools) {
+    const fm = buildFrontmatter(options);
+    const toolRef = buildToolReferenceSection(tools);
+    return `${fm}
+
+# ${options.name} — Reconnaissance Skill
+
+${options.description}
+
+## Phase: Reconnaissance
+
+### Objectives
+- Discover target attack surface
+- Enumerate subdomains, ports, and services
+- Identify technologies and potential entry points
+
+### Prerequisites
+${tools.map(t => `- **${t.tools_name}**: ${t.description}`).join("\n")}
+
+### Step 1: Subdomain Discovery
+\`\`\`bash
+${tools.filter(t => t.tags.includes("subdomain")).map(t => `${t.command.base} -d <target-domain> -o subdomains.txt`).join("\n")}
+\`\`\`
+
+### Step 2: Port Scanning
+\`\`\`bash
+${tools.filter(t => t.tags.includes("port-scan") || t.tags.includes("port")).map(t => `${t.command.base} -host <targets> -o ports.json`).join("\n")}
+\`\`\`
+
+### Step 3: Service Detection
+\`\`\`bash
+${tools.filter(t => t.tags.includes("http") || t.tags.includes("service")).map(t => `${t.command.base} -l subdomains.txt -json -o services.json`).join("\n")}
+\`\`\`
+
+### Output Analysis
+- Review discovered subdomains for interesting targets
+- Correlate open ports with identified services
+- Prioritize targets for exploitation phase
+
+### Handoff
+Pass results to exploitation phase with prioritized target list.
+${toolRef}`;
+}
+function generateExploitationTemplate(options, tools) {
+    const fm = buildFrontmatter(options);
+    const toolRef = buildToolReferenceSection(tools);
+    return `${fm}
+
+# ${options.name} — Exploitation Skill
+
+${options.description}
+
+## Phase: Exploitation
+
+### Objectives
+- Validate identified vulnerabilities
+- Develop proof-of-concept exploits
+- Document impact and severity
+
+### Prerequisites
+${tools.map(t => `- **${t.tools_name}**: ${t.description}`).join("\n")}
+
+### Step 1: Vulnerability Validation
+\`\`\`bash
+# Validate each finding from reconnaissance
+${tools.map(t => `${t.command.base} <target> <parameters>`).join("\n")}
+\`\`\`
+
+### Step 2: PoC Development
+For each validated vulnerability:
+1. Document the exact attack vector
+2. Create minimal reproducible PoC
+3. Assess impact (data access, privilege escalation, etc.)
+
+### Step 3: Severity Assessment
+| Finding | CVSS | Impact | Exploitability |
+|---------|------|--------|----------------|
+| _fill_  | _fill_ | _fill_ | _fill_ |
+
+### Safety Rules
+- Only test targets within authorized scope
+- Do not exfiltrate real user data
+- Document all actions for the report
+${toolRef}`;
+}
+function generateReportingTemplate(options, _tools) {
+    const fm = buildFrontmatter(options);
+    return `${fm}
+
+# ${options.name} — Reporting Skill
+
+${options.description}
+
+## Phase: Reporting
+
+### Report Structure
+
+#### Executive Summary
+- Brief overview of engagement scope
+- Key findings summary (critical/high count)
+- Risk assessment
+
+#### Findings Detail
+For each finding:
+
+##### Finding: [Title]
+- **Severity:** Critical / High / Medium / Low / Info
+- **CVSS Score:** X.X (vector string)
+- **Affected Asset:** URL / endpoint / component
+- **Description:** Clear explanation of the vulnerability
+
+**Proof of Concept:**
+\`\`\`
+[Step-by-step reproduction]
+\`\`\`
+
+**Impact:**
+What an attacker could achieve.
+
+**Remediation:**
+Specific fix recommendation.
+
+#### Methodology
+- Tools used: ${options.tools.join(", ")}
+- Phases covered: ${options.phase.join(", ")}
+- Scope tested: [define scope]
+
+#### Appendices
+- Raw scan outputs
+- Screenshots
+- Timeline of testing
+`;
+}

package/dist/pentest/skills/index.js

@@ -0,0 +1,3 @@
+export * from "./loader/index.js";
+export * from "./register/index.js";
+export * from "./generator/index.js";

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

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

package/dist/pentest/skills/loader/skill-loader.js

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+const SKILL_DIRS = [
+    ".agents/skills",
+    ".opencode/skills",
+    ".claude/skills",
+    "packages/pentest-skills/skills",
+];
+const SKILL_FILENAME = "SKILL.md";
+export function resolveSkillPath(skillName, baseDir = process.cwd()) {
+    for (const dir of SKILL_DIRS) {
+        const skillPath = join(baseDir, dir, skillName, SKILL_FILENAME);
+        if (existsSync(skillPath)) {
+            return skillPath;
+        }
+    }
+    return null;
+}
+export function discoverSkills(baseDir = process.cwd()) {
+    const manifests = [];
+    for (const dir of SKILL_DIRS) {
+        const skillsDir = join(baseDir, dir);
+        if (!existsSync(skillsDir))
+            continue;
+        const entries = readdirSync(skillsDir);
+        for (const entry of entries) {
+            const skillDir = join(skillsDir, entry);
+            if (!statSync(skillDir).isDirectory())
+                continue;
+            const skillFile = join(skillDir, SKILL_FILENAME);
+            if (!existsSync(skillFile))
+                continue;
+            const manifest = parseSkillManifest(skillFile, entry, skillDir);
+            if (manifest) {
+                manifests.push(manifest);
+            }
+        }
+    }
+    return manifests;
+}
+export function loadSkill(skillName, baseDir = process.cwd()) {
+    const skillPath = resolveSkillPath(skillName, baseDir);
+    if (!skillPath) {
+        return {
+            name: skillName,
+            loaded: false,
+            error: `Skill not found: ${skillName}`,
+        };
+    }
+    try {
+        const content = readFileSync(skillPath, "utf-8");
+        const skill = parseSkillContent(content, skillName, skillPath);
+        return {
+            name: skillName,
+            loaded: true,
+            skill,
+        };
+    }
+    catch (error) {
+        return {
+            name: skillName,
+            loaded: false,
+            error: error instanceof Error ? error.message : "Failed to load skill",
+        };
+    }
+}
+export function loadAllSkills(baseDir = process.cwd()) {
+    const manifests = discoverSkills(baseDir);
+    return manifests.map(m => loadSkill(m.name, baseDir));
+}
+export function loadSkillsByPhase(phase, baseDir = process.cwd()) {
+    const manifests = discoverSkills(baseDir);
+    const filtered = manifests.filter(m => m.phase.includes(phase));
+    return filtered.map(m => loadSkill(m.name, baseDir));
+}
+export function loadSkillsByTools(toolNames, baseDir = process.cwd()) {
+    const manifests = discoverSkills(baseDir);
+    const toolSet = new Set(toolNames);
+    const filtered = manifests.filter(m => m.tools.some((t) => toolSet.has(t)));
+    return filtered.map(m => loadSkill(m.name, baseDir));
+}
+export function getSkillsForTool(toolName, baseDir = process.cwd()) {
+    return loadSkillsByTools([toolName], baseDir);
+}
+function parseSkillManifest(skillFile, skillName, _skillDir) {
+    try {
+        const content = readFileSync(skillFile, "utf-8");
+        const frontmatter = extractFrontmatter(content);
+        if (!frontmatter) {
+            return {
+                name: skillName,
+                description: "",
+                version: "0.0.0",
+                phase: [],
+                category: [],
+                tools: [],
+                tags: [],
+                skill_path: skillFile,
+                loaded: false,
+            };
+        }
+        return {
+            name: frontmatter.name ?? skillName,
+            description: frontmatter.description ?? "",
+            version: frontmatter.version ?? "0.0.0",
+            phase: parseStringArray(frontmatter.phase),
+            category: parseStringArray(frontmatter.category),
+            tools: parseStringArray(frontmatter.tools),
+            tags: parseStringArray(frontmatter.tags),
+            skill_path: skillFile,
+            loaded: true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseSkillContent(content, skillName, _skillPath) {
+    const frontmatter = extractFrontmatter(content) ?? {};
+    return {
+        name: frontmatter.name ?? skillName,
+        description: frontmatter.description ?? "",
+        version: frontmatter.version ?? "0.0.0",
+        phase: parseStringArray(frontmatter.phase),
+        category: parseStringArray(frontmatter.category),
+        tools: parseStringArray(frontmatter.tools),
+        author: frontmatter.author,
+        homepage: frontmatter.homepage,
+        tags: parseStringArray(frontmatter.tags),
+        template: content,
+    };
+}
+function extractFrontmatter(content) {
+    const match = /^---\s*\n([\s\S]*?)\n---/.exec(content);
+    if (!match)
+        return null;
+    const yaml = match[1];
+    const result = {};
+    for (const line of yaml.split("\n")) {
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1)
+            continue;
+        const key = line.slice(0, colonIndex).trim();
+        const value = line.slice(colonIndex + 1).trim();
+        if (value.startsWith("[") && value.endsWith("]")) {
+            result[key] = value
+                .slice(1, -1)
+                .split(",")
+                .map(s => s.trim().replace(/^["']|["']$/g, ""));
+        }
+        else {
+            result[key] = value.replace(/^["']|["']$/g, "");
+        }
+    }
+    return result;
+}
+function parseStringArray(value) {
+    if (Array.isArray(value))
+        return value.map(String);
+    if (typeof value === "string") {
+        if (value.startsWith("[") && value.endsWith("]")) {
+            return value.slice(1, -1).split(",").map(s => s.trim().replace(/^["']|["']$/g, ""));
+        }
+        return [value];
+    }
+    return [];
+}

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

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

package/dist/pentest/skills/register/skill-register.js

@@ -0,0 +1,162 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { loadSkill } from "../loader/skill-loader.js";
+const DEFAULT_CONFIG = {
+    skills_dir: ".agents/skills",
+    auto_discover: true,
+    search_paths: [".agents/skills", ".opencode/skills", ".claude/skills"],
+};
+export class SkillRegister {
+    entries = new Map();
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        if (this.config.auto_discover) {
+            this.discoverAndRegister();
+        }
+    }
+    register(skill) {
+        const entry = {
+            name: skill.name,
+            skill,
+            registered_at: new Date().toISOString(),
+            enabled: true,
+        };
+        this.entries.set(skill.name, entry);
+        return entry;
+    }
+    registerFromFile(skillName, baseDir) {
+        const result = loadSkill(skillName, baseDir);
+        if (!result.loaded || !result.skill) {
+            return null;
+        }
+        return this.register(result.skill);
+    }
+    registerMany(skills) {
+        return skills.map(skill => this.register(skill));
+    }
+    registerFromFiles(skillNames, baseDir) {
+        const entries = [];
+        for (const name of skillNames) {
+            const entry = this.registerFromFile(name, baseDir);
+            if (entry)
+                entries.push(entry);
+        }
+        return entries;
+    }
+    unregister(skillName) {
+        return this.entries.delete(skillName);
+    }
+    enable(skillName) {
+        const entry = this.entries.get(skillName);
+        if (!entry)
+            return false;
+        entry.enabled = true;
+        return true;
+    }
+    disable(skillName) {
+        const entry = this.entries.get(skillName);
+        if (!entry)
+            return false;
+        entry.enabled = false;
+        return true;
+    }
+    get(skillName) {
+        return this.entries.get(skillName);
+    }
+    getEnabled() {
+        return [...this.entries.values()].filter(e => e.enabled);
+    }
+    getAll() {
+        return [...this.entries.values()];
+    }
+    getByPhase(phase) {
+        return this.getEnabled().filter(e => e.skill.phase.includes(phase));
+    }
+    getByCategory(category) {
+        return this.getEnabled().filter(e => e.skill.category.includes(category));
+    }
+    getByTool(toolName) {
+        return this.getEnabled().filter(e => e.skill.tools.includes(toolName));
+    }
+    getByTag(tag) {
+        return this.getEnabled().filter(e => e.skill.tags.includes(tag));
+    }
+    has(skillName) {
+        return this.entries.has(skillName);
+    }
+    count() {
+        return this.entries.size;
+    }
+    enabledCount() {
+        return this.getEnabled().length;
+    }
+    clear() {
+        this.entries.clear();
+    }
+    saveToFile(outputPath) {
+        const path = outputPath ?? join(this.config.skills_dir, ".skill-register.json");
+        const dir = dirname(path);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const data = {
+            version: "1.0.0",
+            saved_at: new Date().toISOString(),
+            entries: this.getAll().map(e => ({
+                name: e.name,
+                description: e.skill.description,
+                version: e.skill.version,
+                phase: e.skill.phase,
+                category: e.skill.category,
+                tools: e.skill.tools,
+                tags: e.skill.tags,
+                enabled: e.enabled,
+                registered_at: e.registered_at,
+            })),
+        };
+        writeFileSync(path, JSON.stringify(data, null, 2));
+        return path;
+    }
+    loadFromFile(inputPath) {
+        const path = inputPath ?? join(this.config.skills_dir, ".skill-register.json");
+        if (!existsSync(path))
+            return 0;
+        try {
+            const content = readFileSync(path, "utf-8");
+            const data = JSON.parse(content);
+            let loaded = 0;
+            for (const entry of data.entries ?? []) {
+                const result = loadSkill(entry.name);
+                if (result.loaded && result.skill) {
+                    const registered = this.register(result.skill);
+                    registered.enabled = entry.enabled;
+                    loaded++;
+                }
+            }
+            return loaded;
+        }
+        catch {
+            return 0;
+        }
+    }
+    discoverAndRegister() {
+        for (const searchPath of this.config.search_paths) {
+            if (!existsSync(searchPath))
+                continue;
+            const entries = readdirSync(searchPath);
+            for (const entry of entries) {
+                const skillPath = join(searchPath, entry, "SKILL.md");
+                if (existsSync(skillPath)) {
+                    const result = loadSkill(entry, searchPath);
+                    if (result.loaded && result.skill) {
+                        this.register(result.skill);
+                    }
+                }
+            }
+        }
+    }
+}
+export function createSkillRegister(config) {
+    return new SkillRegister(config);
+}

package/dist/pentest/skills/types.js

@@ -0,0 +1 @@
+export {};