pentesting 0.1.6 → 0.1.9

package/dist/index.js

@@ -5,7 +5,7 @@ import { render } from "ink";
 import { Command } from "commander";
 
 // src/cli/app.tsx
-import { useState, useEffect, useCallback } from "react";
+import { useState, useEffect, useCallback, useRef } from "react";
 import { Box, Text, useInput, useApp, Static } from "ink";
 import TextInput from "ink-text-input";
 import Spinner from "ink-spinner";
@@ -2610,6 +2610,52 @@ var ASCII_BANNER = `
  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 `;
 
+// src/config/agent-constants.ts
+var AGENT_EVENT = {
+  // Lifecycle
+  PLUGINS_LOADED: "plugins_loaded",
+  HOOKS_LOADED: "hooks_loaded",
+  COMMANDS_LOADED: "commands_loaded",
+  MCP_SERVER_ADDED: "mcp_server_added",
+  // Execution
+  ITERATION: "iteration",
+  THOUGHT: "thought",
+  RESPONSE: "response",
+  TOOL_CALL: "tool_call",
+  TOOL_RESULT: "tool_result",
+  COMMAND_EXECUTE: "command_execute",
+  // State changes
+  TARGET_SET: "target_set",
+  PHASE_CHANGE: "phase_change",
+  AGENT_SWITCH: "agent_switch",
+  // Discoveries
+  FINDING: "finding",
+  CREDENTIAL: "credential",
+  COMPROMISED: "compromised",
+  // Completion
+  COMPLETE: "complete",
+  REPORT: "report",
+  ERROR: "error"
+};
+var CLI_COMMAND = {
+  HELP: "help",
+  TARGET: "target",
+  START: "start",
+  STOP: "stop",
+  FINDINGS: "findings",
+  CLEAR: "clear",
+  EXIT: "exit"
+};
+var MESSAGE_TYPE = {
+  USER: "user",
+  ASSISTANT: "assistant",
+  TOOL: "tool",
+  THINKING: "thinking",
+  ERROR: "error",
+  SYSTEM: "system",
+  RESULT: "result"
+};
+
 // src/cli/app.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var App = ({ autoApprove = false, target }) => {
@@ -2617,164 +2663,213 @@ var App = ({ autoApprove = false, target }) => {
   const [messages, setMessages] = useState([]);
   const [input, setInput] = useState("");
   const [isProcessing, setIsProcessing] = useState(false);
+  const [currentStatus, setCurrentStatus] = useState("");
+  const [elapsedTime, setElapsedTime] = useState(0);
   const [agent] = useState(() => new AutonomousHackingAgent(void 0, { autoApprove }));
-  const addMessage = useCallback((type, content) => {
+  const startTimeRef = useRef(0);
+  const timerRef = useRef(null);
+  const addMessage = useCallback((type, content, duration) => {
     setMessages((prev) => [...prev, {
       id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
       type,
       content,
-      timestamp: /* @__PURE__ */ new Date()
+      timestamp: /* @__PURE__ */ new Date(),
+      duration
     }]);
   }, []);
+  const startTimer = useCallback(() => {
+    startTimeRef.current = Date.now();
+    timerRef.current = setInterval(() => {
+      setElapsedTime(Math.floor((Date.now() - startTimeRef.current) / 100) / 10);
+    }, 100);
+  }, []);
+  const stopTimer = useCallback(() => {
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    const duration = Math.floor((Date.now() - startTimeRef.current) / 100) / 10;
+    setElapsedTime(0);
+    return duration;
+  }, []);
   useEffect(() => {
-    addMessage("system", "Pentesting Agent ready. Type a message or use /help for commands.");
+    addMessage(MESSAGE_TYPE.SYSTEM, "Pentesting Agent initialized. Type /help for commands.");
     if (target) {
       agent.setTarget(target);
-      addMessage("system", `Target set: ${target}`);
+      addMessage(MESSAGE_TYPE.SYSTEM, `Target: ${target}`);
     }
-    agent.on("thought", (type, content) => {
-      addMessage("assistant", `[${type}] ${content}`);
+    agent.on(AGENT_EVENT.THOUGHT, (thought) => {
+      setCurrentStatus(thought.content.slice(0, 60));
+    });
+    agent.on(AGENT_EVENT.TOOL_CALL, (data) => {
+      const args = Object.entries(data.input).slice(0, 2).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 30) : "..."}`).join(" ");
+      setCurrentStatus(`Running ${data.name}...`);
+      addMessage(MESSAGE_TYPE.TOOL, `\u25B6 ${data.name} ${args}`);
+    });
+    agent.on(AGENT_EVENT.TOOL_RESULT, (data) => {
+      const icon = data.result.success ? "\u2713" : "\u2717";
+      const preview = data.result.output?.slice(0, 100).replace(/\n/g, " ") || "";
+      addMessage(MESSAGE_TYPE.RESULT, `${icon} ${preview}`);
     });
-    agent.on("tool_call", (data) => {
-      const inputStr = Object.entries(data.input).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
-      addMessage("tool", `\u25B6 ${data.name} ${inputStr}`);
+    agent.on(AGENT_EVENT.ITERATION, (data) => {
+      setCurrentStatus(`Phase: ${data.phase} (iteration ${data.current})`);
     });
-    agent.on("tool_result", (data) => {
-      const status = data.result.success ? "\u2713" : "\u2717";
-      const output = data.result.output?.slice(0, 200) || "";
-      addMessage("tool", `${status} ${data.name}: ${output}`);
+    agent.on(AGENT_EVENT.FINDING, (finding) => {
+      addMessage(MESSAGE_TYPE.SYSTEM, `\u{1F3AF} [${finding.severity.toUpperCase()}] ${finding.title}`);
     });
-    agent.on("finding", (finding) => {
-      addMessage("system", `\u{1F3AF} Finding: [${finding.severity.toUpperCase()}] ${finding.title}`);
+    agent.on(AGENT_EVENT.COMPLETE, () => {
+      const duration = stopTimer();
+      addMessage(MESSAGE_TYPE.SYSTEM, `\u2713 Complete (${duration}s)`);
+      setIsProcessing(false);
+      setCurrentStatus("");
     });
-    agent.on("error", (error) => {
-      addMessage("error", `Error: ${error.message}`);
+    agent.on(AGENT_EVENT.ERROR, (error) => {
+      stopTimer();
+      addMessage(MESSAGE_TYPE.ERROR, error.message);
+      setIsProcessing(false);
     });
-  }, [agent, target, addMessage]);
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current);
+    };
+  }, [agent, target, addMessage, stopTimer]);
   const handleSubmit = useCallback(async (value) => {
     const trimmed = value.trim();
     if (!trimmed || isProcessing) return;
     setInput("");
-    addMessage("user", trimmed);
+    addMessage(MESSAGE_TYPE.USER, trimmed);
     if (trimmed.startsWith("/")) {
       const [cmd, ...args] = trimmed.slice(1).split(" ");
       switch (cmd) {
-        case "help":
-          addMessage("system", `Commands:
-  /target <ip>    Set target
-  /start          Start autonomous mode
-  /stop           Stop current operation
-  /findings       Show findings
-  /clear          Clear messages
-  /exit           Exit`);
+        case CLI_COMMAND.HELP:
+        case "h":
+          addMessage(
+            MESSAGE_TYPE.SYSTEM,
+            `/target <ip>     Set target
+/start [goal]    Start pentest  
+/stop            Stop operation
+/findings        Show findings
+/clear           Clear screen
+/exit            Exit`
+          );
           return;
-        case "target":
+        case CLI_COMMAND.TARGET:
+        case "t":
           if (args[0]) {
             agent.setTarget(args[0]);
-            addMessage("system", `Target set: ${args[0]}`);
+            addMessage(MESSAGE_TYPE.SYSTEM, `Target \u2192 ${args[0]}`);
           } else {
-            addMessage("error", "Usage: /target <ip or domain>");
+            addMessage(MESSAGE_TYPE.ERROR, "Usage: /target <ip>");
           }
           return;
-        case "start":
-          const objective = args.join(" ") || "Perform comprehensive penetration test";
+        case CLI_COMMAND.START:
+        case "s":
           setIsProcessing(true);
-          addMessage("system", `Starting: ${objective}`);
+          startTimer();
+          const objective = args.join(" ") || "Perform comprehensive penetration testing";
+          setCurrentStatus("Initializing...");
           try {
-            await agent.run(objective);
+            await agent.runAutonomous(objective);
           } catch (e) {
-            addMessage("error", `Failed: ${e instanceof Error ? e.message : String(e)}`);
+            addMessage(MESSAGE_TYPE.ERROR, e instanceof Error ? e.message : String(e));
           }
+          stopTimer();
           setIsProcessing(false);
+          setCurrentStatus("");
           return;
-        case "stop":
-          agent.stop();
-          addMessage("system", "Stopped.");
+        case CLI_COMMAND.STOP:
+          agent.pause();
+          stopTimer();
+          addMessage(MESSAGE_TYPE.SYSTEM, "Stopped.");
           setIsProcessing(false);
+          setCurrentStatus("");
           return;
-        case "findings":
+        case CLI_COMMAND.FINDINGS:
+        case "f":
           const findings = agent.getState().findings;
           if (findings.length === 0) {
-            addMessage("system", "No findings yet.");
+            addMessage(MESSAGE_TYPE.SYSTEM, "No findings.");
           } else {
-            findings.forEach((f) => {
-              addMessage("system", `[${f.severity.toUpperCase()}] ${f.title}`);
-            });
+            findings.forEach((f) => addMessage(MESSAGE_TYPE.SYSTEM, `[${f.severity}] ${f.title}`));
           }
           return;
-        case "clear":
+        case CLI_COMMAND.CLEAR:
+        case "c":
           setMessages([]);
-          addMessage("system", "Cleared.");
           return;
-        case "exit":
+        case CLI_COMMAND.EXIT:
         case "quit":
+        case "q":
           exit();
           return;
         default:
-          addMessage("error", `Unknown command: ${cmd}. Type /help`);
+          addMessage(MESSAGE_TYPE.ERROR, `Unknown: ${cmd}`);
           return;
       }
     }
     setIsProcessing(true);
+    startTimer();
+    setCurrentStatus("Thinking...");
     try {
-      await agent.chat(trimmed);
+      await agent.processUserHint(trimmed);
+      addMessage(MESSAGE_TYPE.SYSTEM, "Hint received.");
     } catch (e) {
-      addMessage("error", `Error: ${e instanceof Error ? e.message : String(e)}`);
+      addMessage(MESSAGE_TYPE.ERROR, e instanceof Error ? e.message : String(e));
     }
+    stopTimer();
     setIsProcessing(false);
-  }, [agent, isProcessing, addMessage, exit]);
+    setCurrentStatus("");
+  }, [agent, isProcessing, addMessage, exit, startTimer, stopTimer]);
   useInput((input2, key) => {
     if (key.ctrl && input2 === "c") {
       if (isProcessing) {
-        agent.stop();
+        agent.pause();
+        stopTimer();
         setIsProcessing(false);
-        addMessage("system", "Interrupted.");
+        setCurrentStatus("");
+        addMessage(MESSAGE_TYPE.SYSTEM, "Interrupted.");
       } else {
         exit();
       }
     }
   });
-  const getColor = (type) => {
-    switch (type) {
-      case "user":
-        return THEME.text.accent;
-      case "assistant":
-        return THEME.text.primary;
-      case "tool":
-        return THEME.status.info;
-      case "error":
-        return THEME.status.error;
-      case "system":
-        return THEME.text.muted;
-      default:
-        return THEME.text.primary;
-    }
-  };
-  const getPrefix = (type) => {
-    switch (type) {
-      case "user":
-        return "\u276F";
-      case "assistant":
-        return "\u25C8";
-      case "tool":
-        return "\u2699";
-      case "error":
-        return "\u2717";
-      case "system":
-        return "\u2022";
-      default:
-        return " ";
-    }
+  const getStyle = (type) => {
+    const styles = {
+      [MESSAGE_TYPE.USER]: { color: THEME.text.accent, prefix: "\u276F" },
+      [MESSAGE_TYPE.ASSISTANT]: { color: THEME.text.primary, prefix: "\u25C8" },
+      [MESSAGE_TYPE.TOOL]: { color: THEME.text.muted, prefix: " ", dim: true },
+      [MESSAGE_TYPE.RESULT]: { color: THEME.text.muted, prefix: " ", dim: true },
+      [MESSAGE_TYPE.THINKING]: { color: THEME.status.running, prefix: "\u25CB" },
+      [MESSAGE_TYPE.ERROR]: { color: THEME.status.error, prefix: "\u2717" },
+      [MESSAGE_TYPE.SYSTEM]: { color: THEME.text.muted, prefix: "\u2022" }
+    };
+    return styles[type] || styles[MESSAGE_TYPE.SYSTEM];
   };
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
-    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx(Static, { items: messages.slice(-30), children: (msg) => /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: getColor(msg.type), children: [
-      getPrefix(msg.type),
-      " ",
-      msg.content
-    ] }) }, msg.id) }) }),
-    /* @__PURE__ */ jsx(Box, { children: isProcessing ? /* @__PURE__ */ jsxs(Text, { color: THEME.status.running, children: [
-      /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
-      " Processing..."
+  const state = agent.getState();
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx(Static, { items: messages.slice(-40), children: (msg) => {
+      const style = getStyle(msg.type);
+      return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: style.color, dimColor: style.dim, children: [
+        style.prefix,
+        " ",
+        msg.content,
+        msg.duration && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          " (",
+          msg.duration,
+          "s)"
+        ] })
+      ] }) }, msg.id);
+    } }) }),
+    isProcessing ? /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: THEME.status.running, children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+      /* @__PURE__ */ jsxs(Text, { color: THEME.text.muted, children: [
+        " ",
+        currentStatus,
+        elapsedTime > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          " (",
+          elapsedTime,
+          "s)"
+        ] })
+      ] })
     ] }) : /* @__PURE__ */ jsxs(Box, { children: [
       /* @__PURE__ */ jsx(Text, { color: THEME.status.success, children: "\u276F " }),
       /* @__PURE__ */ jsx(
@@ -2783,17 +2878,23 @@ var App = ({ autoApprove = false, target }) => {
           value: input,
           onChange: setInput,
           onSubmit: handleSubmit,
-          placeholder: "Type a message or /help..."
+          placeholder: "Message or /help..."
         }
       )
-    ] }) }),
-    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: THEME.text.muted, dimColor: true, children: [
-      agent.getState().target ? `Target: ${agent.getState().target}` : "No target",
-      " | Findings: ",
-      agent.getState().findings.length,
-      " | Ctrl+C to ",
-      isProcessing ? "stop" : "exit"
-    ] }) })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        state.target.primary || "No target",
+        " \u2502",
+        state.findings.length,
+        " findings \u2502",
+        state.currentPhase !== "idle" && ` ${state.currentPhase} \u2502`
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "/help \u2502 Ctrl+C ",
+        isProcessing ? "stop" : "exit"
+      ] })
+    ] })
   ] });
 };
 var app_default = App;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pentesting",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "Autonomous Penetration Testing AI Agent",
   "type": "module",
   "main": "dist/index.js",