pentesting 0.1.5 → 0.1.8

package/dist/index.js

@@ -5,8 +5,9 @@ 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 { 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";
 
 // src/core/agent/autonomous-agent.ts
@@ -2608,397 +2609,246 @@ var ASCII_BANNER = `
  \u2551  \u25C8 PENTESTING - Autonomous Penetration Testing Agent      \u2551
  \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
 `;
-var ICONS = {
-  // Status
-  success: "\u2713",
-  error: "\u2717",
-  warning: "\u26A0",
-  info: "\u2139",
-  running: "\u25C9",
-  thinking: "\u25D0",
-  // Actions (pentesting-specific)
-  target: "\u25C8",
-  // Diamond for target
-  scan: "\u25CE",
-  exploit: "\u26A1",
-  shell: "\u276F",
-  // Progress
-  pending: "\u25CB",
-  completed: "\u25CF",
-  skipped: "\u25CC",
-  // Findings (severity)
-  critical: "\u25BC",
-  high: "\u25BD",
-  medium: "\u25C7",
-  low: "\u25E6",
-  // Security
-  lock: "\u{1F512}",
-  unlock: "\u{1F513}",
-  key: "\u{1F511}",
-  flag: "\u2691",
-  // Simple flag
-  pwned: "\u25C8"
-  // Compromised
-};
 
 // src/cli/app.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
-var App = ({
-  apiKey,
-  target: initialTarget,
-  autoStart = false,
-  autoApprove = false,
-  objective: initialObjective,
-  maxIterations = 200
-}) => {
+var App = ({ autoApprove = false, target }) => {
   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 [messages, setMessages] = 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)}`,
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [currentStatus, setCurrentStatus] = useState("");
+  const [elapsedTime, setElapsedTime] = useState(0);
+  const [agent] = useState(() => new AutonomousHackingAgent(void 0, { autoApprove }));
+  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,
-      message,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    setLogs((prev) => [...prev.slice(-50), entry]);
+      content,
+      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(() => {
-    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);
+    addMessage("system", "Pentesting Agent initialized. Type /help for commands.");
+    if (target) {
+      agent.setTarget(target);
+      addMessage("system", `Target: ${target}`);
+    }
+    agent.on("thought", (type, content) => {
+      setCurrentStatus(content.slice(0, 60));
     });
-    agent.on("phase_change", ({ phaseId, newStatus }) => {
-      setAppState((prev) => ({ ...prev, currentPhase: phaseId }));
-      addLog("info", `[phase] ${phaseId} -> ${newStatus}`);
+    agent.on("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("tool", `\u25B6 ${data.name} ${args}`);
     });
-    agent.on("tool_call", ({ name, input: input2 }) => {
-      addLog("tool", `[tool] ${name}: ${JSON.stringify(input2).slice(0, 100)}...`);
+    agent.on("tool_result", (data) => {
+      const icon = data.result.success ? "\u2713" : "\u2717";
+      const preview = data.result.output?.slice(0, 100).replace(/\n/g, " ") || "";
+      addMessage("result", `${icon} ${preview}`);
     });
-    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("iteration", (data) => {
+      setCurrentStatus(`Phase: ${data.phase} (iteration ${data.iteration})`);
     });
     agent.on("finding", (finding) => {
-      addLog("finding", `[!] [${finding.severity.toUpperCase()}] ${finding.title}`);
-      setAppState((prev) => ({ ...prev, findings: prev.findings + 1 }));
+      addMessage("system", `\u{1F3AF} [${finding.severity.toUpperCase()}] ${finding.title}`);
     });
-    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("complete", () => {
+      const duration = stopTimer();
+      addMessage("system", `\u2713 Complete (${duration}s)`);
+      setIsProcessing(false);
+      setCurrentStatus("");
     });
     agent.on("error", (error) => {
-      addLog("error", `[error] ${error.message}`);
-    });
-    agent.on("report", (report) => {
-      addLog("info", `[report] Generated (${report.length} chars)`);
+      stopTimer();
+      addMessage("error", error.message);
+      setIsProcessing(false);
     });
-    const state = agent.getState();
-    setPhases(state.phases);
-    if (autoStart && initialTarget) {
-      agent.setTarget(initialTarget);
-      setAppState((prev) => ({ ...prev, target: initialTarget }));
-      agent.runAutonomous(initialObjective);
-    }
     return () => {
-      agent.removeAllListeners();
+      if (timerRef.current) clearInterval(timerRef.current);
     };
-  }, [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" }));
+  }, [agent, target, addMessage, stopTimer]);
+  const handleSubmit = useCallback(async (value) => {
+    const trimmed = value.trim();
+    if (!trimmed || isProcessing) return;
+    setInput("");
+    addMessage("user", trimmed);
+    if (trimmed.startsWith("/")) {
+      const [cmd, ...args] = trimmed.slice(1).split(" ");
+      switch (cmd) {
+        case "help":
+        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 \u2192 ${args[0]}`);
+          } else {
+            addMessage("error", "Usage: /target <ip>");
+          }
+          return;
+        case "start":
+        case "s":
+          setIsProcessing(true);
+          startTimer();
+          const objective = args.join(" ") || "Perform comprehensive penetration testing";
+          setCurrentStatus("Initializing...");
+          try {
+            await agent.runAutonomous(objective);
+          } catch (e) {
+            addMessage("error", e instanceof Error ? e.message : String(e));
+          }
+          stopTimer();
+          setIsProcessing(false);
+          setCurrentStatus("");
+          return;
+        case "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.");
+          } else {
+            findings.forEach((f) => addMessage("system", `[${f.severity}] ${f.title}`));
+          }
+          return;
+        case "clear":
+        case "c":
+          setMessages([]);
+          return;
+        case "exit":
+        case "quit":
+        case "q":
+          exit();
+          return;
+        default:
+          addMessage("error", `Unknown: ${cmd}`);
+          return;
+      }
     }
-  });
-  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":
+    setIsProcessing(true);
+    startTimer();
+    setCurrentStatus("Thinking...");
+    try {
+      await agent.processUserHint(trimmed);
+      addMessage("system", "Hint received.");
+    } catch (e) {
+      addMessage("error", e instanceof Error ? e.message : String(e));
+    }
+    stopTimer();
+    setIsProcessing(false);
+    setCurrentStatus("");
+  }, [agent, isProcessing, addMessage, exit, startTimer, stopTimer]);
+  useInput((input2, key) => {
+    if (key.ctrl && input2 === "c") {
+      if (isProcessing) {
         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}`);
-        }
+        stopTimer();
+        setIsProcessing(false);
+        setCurrentStatus("");
+        addMessage("system", "Interrupted.");
+      } else {
+        exit();
+      }
     }
-    setInput("");
-  }, [agent, appState, addLog, maxIterations]);
-  const getThoughtStyle = (type) => {
+  });
+  const getStyle = (type) => {
     const styles = {
-      observation: { prefix: "[observe]", color: THEME.text.accent },
-      hypothesis: { prefix: "[hypothesis]", color: THEME.status.warning },
-      plan: { prefix: "[plan]", color: THEME.status.running },
-      action: { prefix: "[action]", color: THEME.status.success },
-      result: { prefix: "[result]", color: THEME.text.primary },
-      reflection: { prefix: "[reflect]", color: THEME.semantic.high },
-      stuck: { prefix: "[stuck]", color: THEME.status.error },
-      breakthrough: { prefix: "[breakthrough]", color: "#00ff00" }
+      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] || { 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 styles[type] || styles.system;
   };
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx(Text, { color: THEME.status.success, children: ASCII_BANNER }),
-      /* @__PURE__ */ jsxs(Box, { marginTop: 1, justifyContent: "space-between", children: [
-        /* @__PURE__ */ jsxs(Text, { color: THEME.status.error, children: [
-          ICONS.target,
-          " Target: ",
-          /* @__PURE__ */ jsx(Text, { color: THEME.text.accent, bold: true, children: appState.target || "Not set" })
-        ] }),
-        /* @__PURE__ */ jsxs(Text, { color: THEME.text.muted, children: [
-          "Status: ",
-          /* @__PURE__ */ jsx(Text, { color: appState.status === "running" ? THEME.status.success : THEME.status.warning, children: appState.status.toUpperCase() })
-        ] }),
-        /* @__PURE__ */ jsxs(Text, { color: THEME.text.muted, children: [
-          "Iteration: ",
-          /* @__PURE__ */ jsxs(Text, { color: THEME.text.accent, children: [
-            appState.iteration,
-            "/",
-            appState.maxIterations
-          ] })
+  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, { borderStyle: "single", borderColor: THEME.status.running, paddingX: 1, children: [
-      /* @__PURE__ */ jsx(Text, { color: THEME.text.muted, children: "Services: " }),
-      /* @__PURE__ */ jsx(Text, { color: THEME.status.success, children: appState.services }),
-      /* @__PURE__ */ jsx(Text, { children: " | " }),
-      /* @__PURE__ */ jsx(Text, { color: THEME.text.muted, children: "Creds: " }),
-      /* @__PURE__ */ jsx(Text, { color: THEME.status.warning, 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.semantic.high, children: appState.findings })
-    ] }),
-    /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: THEME.text.accent, paddingX: 1, marginTop: 1, children: [
-      /* @__PURE__ */ jsx(Text, { color: THEME.text.accent, bold: true, children: "[phases] " }),
-      phases.map((phase) => /* @__PURE__ */ jsx(Box, { marginRight: 1, children: /* @__PURE__ */ jsxs(
-        Text,
+    ] }) : /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: THEME.status.success, children: "\u276F " }),
+      /* @__PURE__ */ jsx(
+        TextInput,
         {
-          color: phase.id === appState.currentPhase ? THEME.status.warning : 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,
-              ")"
-            ] })
-          ]
+          value: input,
+          onChange: setInput,
+          onSubmit: handleSubmit,
+          placeholder: "Message or /help..."
         }
-      ) }, phase.id))
+      )
     ] }),
-    showThoughts && /* @__PURE__ */ jsxs(
-      Box,
-      {
-        flexDirection: "column",
-        borderStyle: "single",
-        borderColor: THEME.status.running,
-        paddingX: 1,
-        height: 10,
-        marginTop: 1,
-        children: [
-          /* @__PURE__ */ jsxs(Box, { children: [
-            /* @__PURE__ */ jsx(Text, { color: THEME.status.running, bold: true, children: "[agent thoughts]" }),
-            isThinking && /* @__PURE__ */ jsxs(Box, { marginLeft: 2, children: [
-              /* @__PURE__ */ jsx(Text, { color: THEME.status.warning, children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
-              /* @__PURE__ */ jsx(Text, { color: THEME.status.warning, 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.status.success,
-        paddingX: 1,
-        height: 12,
-        marginTop: 1,
-        children: [
-          /* @__PURE__ */ jsx(Text, { color: THEME.status.success, 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.semantic.high : log.type === "tool" ? THEME.text.accent : THEME.text.primary, children: [
-              " ",
-              log.message
-            ] })
-          ] }, log.id) })
-        ]
-      }
-    ),
-    /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
-      /* @__PURE__ */ jsxs(Text, { color: THEME.status.success, bold: true, children: [
-        "pentesting ",
-        ">",
-        " "
+    /* @__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__ */ jsx(Text, { color: THEME.text.primary, children: input }),
-      /* @__PURE__ */ jsx(Text, { color: THEME.status.success, 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" }) })
+      /* @__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.5",
+  "version": "0.1.8",
   "description": "Autonomous Penetration Testing AI Agent",
   "type": "module",
   "main": "dist/index.js",