pentesting 0.1.6 → 0.1.8

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";
@@ -2617,40 +2617,75 @@ 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("system", "Pentesting Agent initialized. Type /help for commands.");
     if (target) {
       agent.setTarget(target);
-      addMessage("system", `Target set: ${target}`);
+      addMessage("system", `Target: ${target}`);
     }
     agent.on("thought", (type, content) => {
-      addMessage("assistant", `[${type}] ${content}`);
+      setCurrentStatus(content.slice(0, 60));
     });
     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}`);
+      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("tool", `\u25B6 ${data.name} ${args}`);
     });
     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}`);
+      const icon = data.result.success ? "\u2713" : "\u2717";
+      const preview = data.result.output?.slice(0, 100).replace(/\n/g, " ") || "";
+      addMessage("result", `${icon} ${preview}`);
+    });
+    agent.on("iteration", (data) => {
+      setCurrentStatus(`Phase: ${data.phase} (iteration ${data.iteration})`);
     });
     agent.on("finding", (finding) => {
-      addMessage("system", `\u{1F3AF} Finding: [${finding.severity.toUpperCase()}] ${finding.title}`);
+      addMessage("system", `\u{1F3AF} [${finding.severity.toUpperCase()}] ${finding.title}`);
+    });
+    agent.on("complete", () => {
+      const duration = stopTimer();
+      addMessage("system", `\u2713 Complete (${duration}s)`);
+      setIsProcessing(false);
+      setCurrentStatus("");
     });
     agent.on("error", (error) => {
-      addMessage("error", `Error: ${error.message}`);
+      stopTimer();
+      addMessage("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;
@@ -2660,121 +2695,135 @@ var App = ({ autoApprove = false, target }) => {
       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 "h":
+          addMessage(
+            "system",
+            `/target <ip>     Set target
+/start [goal]    Start pentest  
+/stop            Stop operation
+/findings        Show findings
+/clear           Clear screen
+/exit            Exit`
+          );
           return;
         case "target":
+        case "t":
           if (args[0]) {
             agent.setTarget(args[0]);
-            addMessage("system", `Target set: ${args[0]}`);
+            addMessage("system", `Target \u2192 ${args[0]}`);
           } else {
-            addMessage("error", "Usage: /target <ip or domain>");
+            addMessage("error", "Usage: /target <ip>");
           }
           return;
         case "start":
-          const objective = args.join(" ") || "Perform comprehensive penetration test";
+        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("error", e instanceof Error ? e.message : String(e));
           }
+          stopTimer();
           setIsProcessing(false);
+          setCurrentStatus("");
           return;
         case "stop":
-          agent.stop();
+          agent.pause();
+          stopTimer();
           addMessage("system", "Stopped.");
           setIsProcessing(false);
+          setCurrentStatus("");
           return;
         case "findings":
+        case "f":
           const findings = agent.getState().findings;
           if (findings.length === 0) {
-            addMessage("system", "No findings yet.");
+            addMessage("system", "No findings.");
           } else {
-            findings.forEach((f) => {
-              addMessage("system", `[${f.severity.toUpperCase()}] ${f.title}`);
-            });
+            findings.forEach((f) => addMessage("system", `[${f.severity}] ${f.title}`));
           }
           return;
         case "clear":
+        case "c":
           setMessages([]);
-          addMessage("system", "Cleared.");
           return;
         case "exit":
         case "quit":
+        case "q":
           exit();
           return;
         default:
-          addMessage("error", `Unknown command: ${cmd}. Type /help`);
+          addMessage("error", `Unknown: ${cmd}`);
           return;
       }
     }
     setIsProcessing(true);
+    startTimer();
+    setCurrentStatus("Thinking...");
     try {
-      await agent.chat(trimmed);
+      await agent.processUserHint(trimmed);
+      addMessage("system", "Hint received.");
     } catch (e) {
-      addMessage("error", `Error: ${e instanceof Error ? e.message : String(e)}`);
+      addMessage("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);
+        setCurrentStatus("");
         addMessage("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 = {
+      user: { color: THEME.text.accent, prefix: "\u276F" },
+      assistant: { color: THEME.text.primary, prefix: "\u25C8" },
+      tool: { color: THEME.text.muted, prefix: " ", dim: true },
+      result: { color: THEME.text.muted, prefix: " ", dim: true },
+      thinking: { color: THEME.status.running, prefix: "\u25CB" },
+      error: { color: THEME.status.error, prefix: "\u2717" },
+      system: { color: THEME.text.muted, prefix: "\u2022" }
+    };
+    return styles[type] || styles.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 +2832,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.8",
   "description": "Autonomous Penetration Testing AI Agent",
   "type": "module",
   "main": "dist/index.js",