@naraya/cli 0.1.0 → 0.4.1

package/src/pentest/mode/mode-selector.ts

@@ -0,0 +1,159 @@
+import type {
+  PentestMode,
+  ModeConfig,
+  ModeSelectorOptions,
+  ModeSelectionResult,
+} from "../types.js"
+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: string): { mode: PentestMode; reason: string } {
+  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: ModeSelectorOptions = {}): ModeSelectionResult {
+  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: PentestMode): ModeConfig {
+  return MODE_PRESETS[mode]
+}
+
+export function getToolsForMode(
+  mode: PentestMode,
+  availableTools: readonly string[],
+): string[] {
+  const config = MODE_PRESETS[mode]
+  const priority = config.tool_priority
+
+  const prioritized: string[] = []
+  const remaining: string[] = []
+
+  for (const tool of availableTools) {
+    const toolCategory = getToolCategory(tool)
+    if (toolCategory && (priority as readonly string[]).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 as readonly string[]).indexOf(catA) - (priority as readonly string[]).indexOf(catB)
+  })
+
+  return [...prioritized, ...remaining]
+}
+
+function getToolCategory(toolName: string): string | undefined {
+  const categoryMap: Record<string, string> = {
+    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: PentestMode): string[] {
+  return [...MODE_PRESETS[mode].skill_chain]
+}
+
+export function getLoopConfig(mode: PentestMode) {
+  return MODE_PRESETS[mode].loop_config
+}
+
+export function getSafetyConfig(mode: PentestMode) {
+  return MODE_PRESETS[mode].safety_constraints
+}
+
+export function getReportFormat(mode: PentestMode) {
+  return MODE_PRESETS[mode].report_format
+}
+
+export function isModeStealth(mode: PentestMode): boolean {
+  return MODE_PRESETS[mode].stealth
+}
+
+export function getModeParallelism(mode: PentestMode): number {
+  return MODE_PRESETS[mode].parallelism
+}

package/src/pentest/selector/index.ts

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

package/src/pentest/selector/tool-selector.ts

@@ -0,0 +1,87 @@
+import type { ToolsCatalog, ToolEntry, ToolSelectorOptions, PentestPhase } from "../types.js"
+
+export function selectTools(catalog: ToolsCatalog, options: ToolSelectorOptions): ToolEntry[] {
+  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: ToolsCatalog, phase: "recon" | "enumeration" | "exploitation" | "reporting"): ToolEntry[] {
+  return selectTools(catalog, { phase })
+}
+
+export function selectToolsByCategory(catalog: ToolsCatalog, category: "recon" | "enumeration" | "exploitation" | "reporting" | "utility"): ToolEntry[] {
+  return selectTools(catalog, { category })
+}
+
+export function selectToolsByTags(catalog: ToolsCatalog, tags: readonly string[]): ToolEntry[] {
+  return selectTools(catalog, { tags })
+}
+
+export function groupToolsByPhase(catalog: ToolsCatalog): Record<string, ToolEntry[]> {
+  const groups: Record<string, ToolEntry[]> = {
+    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: ToolsCatalog): Record<string, ToolEntry[]> {
+  const groups: Record<string, ToolEntry[]> = {}
+
+  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: ToolsCatalog, toolName: string): ToolEntry[] {
+  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: ToolsCatalog, toolName: string): ToolEntry[] {
+  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/src/pentest/skill-bridge/index.ts

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

package/src/pentest/skill-bridge/skill-bridge.ts

@@ -0,0 +1,86 @@
+import type { ToolEntry, SkillBridgeResult } from "../types.js"
+import { existsSync } from "fs"
+import { join } from "path"
+
+const SKILL_DIRS = [
+  ".agents/skills",
+  ".opencode/skills", 
+  ".claude/skills"
+]
+
+export function resolveSkillPath(skillName: string, baseDir: string = process.cwd()): string | null {
+  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: ToolEntry, baseDir: string = process.cwd()): SkillBridgeResult {
+  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: readonly ToolEntry[], baseDir: string = process.cwd()): SkillBridgeResult[] {
+  return tools.map(tool => loadToolSkill(tool, baseDir))
+}
+
+export function getSkillForTool(tools: readonly ToolEntry[], toolName: string): SkillBridgeResult | null {
+  const tool = tools.find(t => t.tools_name === toolName)
+  if (!tool) return null
+  return loadToolSkill(tool)
+}
+
+export function groupToolsBySkill(tools: readonly ToolEntry[]): Record<string, ToolEntry[]> {
+  const groups: Record<string, ToolEntry[]> = {}
+
+  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: readonly ToolEntry[], skillName: string): ToolEntry[] {
+  return tools.filter(t => t.skills_loader === skillName)
+}
+
+export interface SkillManifest {
+  readonly skill_name: string
+  readonly skill_path: string | null
+  readonly tools: readonly ToolEntry[]
+  readonly available: boolean
+}
+
+export function buildSkillManifest(tools: readonly ToolEntry[], baseDir: string = process.cwd()): SkillManifest[] {
+  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/src/pentest/skills/generator/index.ts

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

package/src/pentest/skills/generator/skill-generator.ts

@@ -0,0 +1,373 @@
+import type { PentestSkill, GeneratedSkill, SkillGenerationOptions } from "../types.js"
+import type { ToolEntry, ToolsCatalog, PentestPhase, ToolCategory } from "../../types.js"
+import { existsSync, mkdirSync, writeFileSync } from "fs"
+import { join, dirname } from "path"
+
+const DEFAULT_OUTPUT_DIR = ".agents/skills"
+
+const TEMPLATES: Record<string, (opts: SkillGenerationOptions, tools: readonly ToolEntry[]) => string> = {
+  basic: generateBasicTemplate,
+  recon: generateReconTemplate,
+  exploitation: generateExploitationTemplate,
+  reporting: generateReportingTemplate,
+  custom: generateBasicTemplate,
+}
+
+export function generateSkill(
+  options: SkillGenerationOptions,
+  catalog?: ToolsCatalog,
+): GeneratedSkill {
+  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: SkillGenerationOptions,
+  catalog?: ToolsCatalog,
+): string {
+  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: PentestPhase,
+  catalog: ToolsCatalog,
+  outputDir?: string,
+): GeneratedSkill[] {
+  const phaseTools = catalog.tools.filter(t => t.phase.includes(phase))
+  const skills: GeneratedSkill[] = []
+
+  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: string,
+  catalog: ToolsCatalog,
+  outputDir?: string,
+): GeneratedSkill[] {
+  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: ToolsCatalog,
+  outputDir?: string,
+): GeneratedSkill[] {
+  const allSkills: GeneratedSkill[] = []
+
+  for (const category of catalog.categories) {
+    const skills = generateSkillsForPhase(category as PentestPhase, catalog, outputDir)
+    allSkills.push(...skills)
+  }
+
+  return allSkills
+}
+
+export function saveGeneratedSkills(skills: readonly GeneratedSkill[]): string[] {
+  const paths: string[] = []
+  
+  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: PentestPhase): "basic" | "recon" | "exploitation" | "reporting" {
+  switch (phase) {
+    case "recon":
+    case "enumeration":
+      return "recon"
+    case "exploitation":
+      return "exploitation"
+    case "reporting":
+      return "reporting"
+    default:
+      return "basic"
+  }
+}
+
+function buildFrontmatter(options: SkillGenerationOptions): string {
+  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: readonly ToolEntry[]): string {
+  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: SkillGenerationOptions, tools: readonly ToolEntry[]): string {
+  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: SkillGenerationOptions, tools: readonly ToolEntry[]): string {
+  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: SkillGenerationOptions, tools: readonly ToolEntry[]): string {
+  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: SkillGenerationOptions, _tools: readonly ToolEntry[]): string {
+  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
+`
+}