pentesting 0.8.33 → 0.8.35

package/dist/{auto-update-NUVK35LG.js → auto-update-RJK3Y5UW.js}

@@ -8,8 +8,8 @@ import {
   readVersionCache,
   semverTuple,
   writeVersionCache
-} from "./chunk-N27ISRFF.js";
-import "./chunk-IYELGZKK.js";
+} from "./chunk-TTQCHK5V.js";
+import "./chunk-UCB4BWTB.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   checkForUpdate,

package/dist/{chunk-N27ISRFF.js → chunk-TTQCHK5V.js}

@@ -1,7 +1,7 @@
 import {
   APP_NAME,
   APP_VERSION
-} from "./chunk-IYELGZKK.js";
+} from "./chunk-UCB4BWTB.js";
 
 // src/core/update/auto-update.ts
 import { execSync } from "child_process";

package/dist/{chunk-IYELGZKK.js → chunk-UCB4BWTB.js}

@@ -27,14 +27,26 @@ var PHASE_STATUS = {
   SKIPPED: "skipped"
 };
 var THOUGHT_TYPE = {
+  THINKING: "thinking",
+  // LLM text streaming
+  REASONING: "reasoning",
+  // LLM extended thinking
+  PLANNING: "planning",
+  // Strategic planning
   OBSERVATION: "observation",
+  // Observing results
   HYPOTHESIS: "hypothesis",
-  PLAN: "plan",
+  // Forming hypothesis
+  REFLECTION: "reflection",
+  // Self-reflection
   ACTION: "action",
+  // Taking action
   RESULT: "result",
-  REFLECTION: "reflection",
+  // Action result
   STUCK: "stuck",
+  // Detected stuck state
   BREAKTHROUGH: "breakthrough"
+  // Found breakthrough
 };
 var AGENT_EVENT = {
   // Lifecycle

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   PHASE_STATUS,
   THOUGHT_TYPE,
   TOOL_NAME
-} from "./chunk-IYELGZKK.js";
+} from "./chunk-UCB4BWTB.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -4581,7 +4581,7 @@ var AutonomousHackingAgent = class extends EventEmitter4 {
       target: this.state.target.primary
     };
     const result = await executeCommand(cmdName, args, context);
-    this.think(THOUGHT_TYPE.PLAN, `Executed command: /${cmdName}`);
+    this.think(THOUGHT_TYPE.PLANNING, `Executed command: /${cmdName}`);
     this.emit(AGENT_EVENT.COMMAND_EXECUTE, { command: cmdName, args });
     return result.output;
   }
@@ -4592,7 +4592,7 @@ var AutonomousHackingAgent = class extends EventEmitter4 {
     );
     if (agent) {
       this.currentAgent = agent;
-      this.think(THOUGHT_TYPE.PLAN, `Switching to specialized agent: ${agent.name}`);
+      this.think(THOUGHT_TYPE.PLANNING, `Switching to specialized agent: ${agent.name}`);
       this.emit(AGENT_EVENT.AGENT_SWITCH, { name: agent.name, description: agent.description });
       return true;
     }
@@ -4787,7 +4787,7 @@ ${prompt}`
       this.setPhaseStatus(this.state.currentPhase, PHASE_STATUS.COMPLETED);
       this.state.currentPhase = nextPhase.id;
       this.setPhaseStatus(nextPhase.id, PHASE_STATUS.IN_PROGRESS);
-      this.think(THOUGHT_TYPE.PLAN, `Advancing to next phase: ${nextPhase.shortName}`);
+      this.think(THOUGHT_TYPE.PLANNING, `Advancing to next phase: ${nextPhase.shortName}`);
       this.autoSwitchAgentForPhase(nextPhase.id);
       this.resetStuckCounter();
       return true;
@@ -4980,7 +4980,7 @@ What went wrong and what different approach should be tried?
 Target ${this.state.target.primary} - performing full penetration test.
 Goal: Deep penetration to obtain root/system privileges, extract internal data, map entire network.
 `;
-    this.think(THOUGHT_TYPE.PLAN, `Autonomous hacking started: ${mainObjective}`);
+    this.think(THOUGHT_TYPE.PLANNING, `Autonomous hacking started: ${mainObjective}`);
     this.state.history.push({
       role: "user",
       content: mainObjective
@@ -5044,13 +5044,13 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
   // ===== Step Execution =====
   async executeStep() {
     const contextPrompt = this.buildContextPrompt();
-    this.think(THOUGHT_TYPE.PLAN, "Deciding next action...");
+    this.think(THOUGHT_TYPE.PLANNING, "Deciding next action...");
     const contextStatus = this.contextManager.checkStatus(this.state.history);
     if (contextStatus.warning) {
       this.think(THOUGHT_TYPE.OBSERVATION, `Context at ${(contextStatus.percentage * 100).toFixed(1)}% capacity`);
     }
     if (contextStatus.needsCompaction) {
-      this.think(THOUGHT_TYPE.PLAN, "Compacting context...");
+      this.think(THOUGHT_TYPE.PLANNING, "Compacting context...");
       const compactResult = await this.contextManager.compactIfNeeded(this.state.history);
       if (compactResult.wasCompacted && compactResult.result) {
         this.state.history = compactResult.messages;
@@ -5096,12 +5096,12 @@ ${this.currentSpec.systemPrompt}`;
         if (block.type === "thinking" && block.thinking) {
           thinkingBuffer += block.thinking;
           this.emit(AGENT_EVENT.THOUGHT, {
-            type: "reasoning",
+            type: THOUGHT_TYPE.REASONING,
             content: block.thinking
           });
         } else if (block.type === "tool_use") {
           this.emit(AGENT_EVENT.THOUGHT, {
-            type: "action",
+            type: THOUGHT_TYPE.ACTION,
             content: `Calling: ${block.name}`
           });
         }
@@ -5376,9 +5376,9 @@ Use report_finding tool for important discoveries.
   async attemptRecovery(error) {
     this.think(THOUGHT_TYPE.REFLECTION, `Attempting recovery: ${error.message}`);
     if (error.message.includes("timeout")) {
-      this.think(THOUGHT_TYPE.PLAN, "Timeout - retrying with shorter command");
+      this.think(THOUGHT_TYPE.PLANNING, "Timeout - retrying with shorter command");
     } else if (error.message.includes("permission")) {
-      this.think(THOUGHT_TYPE.PLAN, "Permission error - trying different approach");
+      this.think(THOUGHT_TYPE.PLANNING, "Permission error - trying different approach");
     }
   }
   // ===== Final Report Generation =====
@@ -5456,7 +5456,7 @@ ${this.state.findings.filter((f) => f.severity !== "info").map((f) => `- Address
    * This is the main method for interactive TUI conversations
    */
   async chat(userMessage) {
-    this.think(THOUGHT_TYPE.PLAN, `Processing: ${userMessage}`);
+    this.think(THOUGHT_TYPE.PLANNING, `Processing: ${userMessage}`);
     this.state.history.push({
       role: "user",
       content: userMessage
@@ -6658,16 +6658,16 @@ var ASCII_BANNER = `
    \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   \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D 
 `;
 var THOUGHT_LABELS = {
-  thinking: "[think]",
-  reasoning: "[reason]",
-  planning: "[plan]",
-  observation: "[observe]",
-  hypothesis: "[hypothesis]",
-  reflection: "[reflect]",
-  action: "[action]",
-  result: "[result]",
-  stuck: "[stuck]",
-  breakthrough: "[!]"
+  [THOUGHT_TYPE.THINKING]: "[think]",
+  [THOUGHT_TYPE.REASONING]: "[reason]",
+  [THOUGHT_TYPE.PLANNING]: "[plan]",
+  [THOUGHT_TYPE.OBSERVATION]: "[observe]",
+  [THOUGHT_TYPE.HYPOTHESIS]: "[hypothesis]",
+  [THOUGHT_TYPE.REFLECTION]: "[reflect]",
+  [THOUGHT_TYPE.ACTION]: "[action]",
+  [THOUGHT_TYPE.RESULT]: "[result]",
+  [THOUGHT_TYPE.STUCK]: "[stuck]",
+  [THOUGHT_TYPE.BREAKTHROUGH]: "[!]"
 };
 
 // src/cli/components/rich-display.tsx
@@ -6959,6 +6959,142 @@ function getKeyboardListener() {
   return keyboardListenerInstance;
 }
 
+// src/utils/input-queue.ts
+import { EventEmitter as EventEmitter8 } from "events";
+var INPUT_QUEUE_EVENT = {
+  QUEUED: "queued",
+  // Message added to queue
+  DEQUEUED: "dequeued",
+  // Message removed from queue
+  PROCESSING: "processing",
+  // Message being processed
+  CLEARED: "cleared",
+  // Queue cleared
+  SHUTDOWN: "shutdown"
+  // Queue shutdown
+};
+var InputQueue = class extends EventEmitter8 {
+  queue = [];
+  isShutdown = false;
+  isPaused = false;
+  nextId = 1;
+  constructor() {
+    super();
+  }
+  /**
+   * Add input to the queue
+   * Returns immediately, input will be processed when agent is ready
+   */
+  enqueue(content, options = {}) {
+    if (this.isShutdown) {
+      throw new Error("Queue is shutdown");
+    }
+    const input = {
+      id: `input_${this.nextId++}`,
+      content,
+      timestamp: /* @__PURE__ */ new Date(),
+      priority: options.priority || "normal",
+      metadata: options.metadata
+    };
+    if (input.priority === "interrupt") {
+      this.queue.unshift(input);
+    } else if (input.priority === "high") {
+      const firstNormal = this.queue.findIndex((q) => q.priority === "normal");
+      if (firstNormal === -1) {
+        this.queue.push(input);
+      } else {
+        this.queue.splice(firstNormal, 0, input);
+      }
+    } else {
+      this.queue.push(input);
+    }
+    this.emit(INPUT_QUEUE_EVENT.QUEUED, input);
+    return input;
+  }
+  /**
+   * Get next input from queue
+   * Returns null if queue is empty or paused
+   */
+  dequeue() {
+    if (this.isShutdown || this.isPaused || this.queue.length === 0) {
+      return null;
+    }
+    const input = this.queue.shift();
+    this.emit(INPUT_QUEUE_EVENT.DEQUEUED, input);
+    return input;
+  }
+  /**
+   * Peek at next input without removing it
+   */
+  peek() {
+    return this.queue[0] || null;
+  }
+  /**
+   * Check if there are pending inputs
+   */
+  hasPending() {
+    return this.queue.length > 0 && !this.isPaused && !this.isShutdown;
+  }
+  /**
+   * Get number of pending inputs
+   */
+  get length() {
+    return this.queue.length;
+  }
+  /**
+   * Get all pending inputs (for display)
+   */
+  getPending() {
+    return [...this.queue];
+  }
+  /**
+   * Pause queue processing (inputs can still be added)
+   */
+  pause() {
+    this.isPaused = true;
+  }
+  /**
+   * Resume queue processing
+   */
+  resume() {
+    this.isPaused = false;
+  }
+  /**
+   * Clear all pending inputs
+   */
+  clear() {
+    this.queue = [];
+    this.emit(INPUT_QUEUE_EVENT.CLEARED);
+  }
+  /**
+   * Shutdown queue (no more inputs accepted)
+   */
+  shutdown() {
+    this.isShutdown = true;
+    this.queue = [];
+    this.emit(INPUT_QUEUE_EVENT.SHUTDOWN);
+  }
+  /**
+   * Check if queue is shutdown
+   */
+  get isTerminated() {
+    return this.isShutdown;
+  }
+  /**
+   * Check if queue is paused
+   */
+  get isHeld() {
+    return this.isPaused;
+  }
+};
+var inputQueueInstance = null;
+function getInputQueue() {
+  if (!inputQueueInstance) {
+    inputQueueInstance = new InputQueue();
+  }
+  return inputQueueInstance;
+}
+
 // src/cli/app.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var App = ({ autoApprove = false, target }) => {
@@ -6977,6 +7113,7 @@ var App = ({ autoApprove = false, target }) => {
   const [preInputBuffer, setPreInputBuffer] = useState("");
   const [wasInterrupted, setWasInterrupted] = useState(false);
   const [spinnerHue, setSpinnerHue] = useState(0);
+  const [queuedCount, setQueuedCount] = useState(0);
   const [, forceUpdate] = useState(0);
   const spinnerColor = THEME.spinner;
   const [agent] = useState(() => new AutonomousHackingAgent(void 0, { autoApprove }));
@@ -6999,7 +7136,7 @@ var App = ({ autoApprove = false, target }) => {
         setCheckpointCount(contextManagerRef.current?.getCheckpoints().length || 0);
       }
     });
-    import("./auto-update-NUVK35LG.js").then(({ checkForUpdateAsync, formatUpdateNotification }) => {
+    import("./auto-update-RJK3Y5UW.js").then(({ checkForUpdateAsync, formatUpdateNotification }) => {
       checkForUpdateAsync().then((result) => {
         if (result.hasUpdate) {
           const notification = formatUpdateNotification(result);
@@ -7126,14 +7263,14 @@ var App = ({ autoApprove = false, target }) => {
     agent.on(AGENT_EVENT.THOUGHT, (thought) => {
       setCurrentStatus(thought.content.slice(0, 60));
       const label = THOUGHT_LABELS[thought.type] || "[?]";
-      if (thought.type === "reasoning") {
+      if (thought.type === THOUGHT_TYPE.REASONING) {
         addMessage(MESSAGE_TYPE.SYSTEM, `  \u2503 \u{1F4AD} ${thought.content.slice(0, 300)}`);
-      } else if (thought.type === "thinking") {
+      } else if (thought.type === THOUGHT_TYPE.THINKING) {
         addMessage(MESSAGE_TYPE.SYSTEM, `  \u2503 ${thought.content.slice(0, 150)}`);
       } else {
         addMessage(MESSAGE_TYPE.SYSTEM, `${label} ${thought.content.slice(0, 200)}`);
       }
-      wireLoggerRef.current?.contentPart(thought.content, thought.type === "thinking" || thought.type === "reasoning");
+      wireLoggerRef.current?.contentPart(thought.content, thought.type === THOUGHT_TYPE.THINKING || thought.type === THOUGHT_TYPE.REASONING);
     });
     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(" ");
@@ -7220,6 +7357,17 @@ var App = ({ autoApprove = false, target }) => {
       addMessage(MESSAGE_TYPE.SYSTEM, `\u2713 Complete (${duration}s)`);
       setIsProcessing(false);
       setCurrentStatus("");
+      const inputQueue = getInputQueue();
+      if (inputQueue.hasPending()) {
+        const next = inputQueue.dequeue();
+        if (next) {
+          setQueuedCount(inputQueue.length);
+          addMessage(MESSAGE_TYPE.SYSTEM, `  \u{1F4E4} Processing queued: ${next.content.slice(0, 50)}...`);
+          setTimeout(() => {
+            handleSubmit(next.content);
+          }, 100);
+        }
+      }
     });
     agent.on(AGENT_EVENT.ERROR, (error) => {
       stopTimer();
@@ -7275,7 +7423,14 @@ var App = ({ autoApprove = false, target }) => {
       exit();
       return;
     }
-    if (isProcessing && !trimmed.startsWith("/")) return;
+    if (isProcessing && !trimmed.startsWith("/")) {
+      const inputQueue = getInputQueue();
+      inputQueue.enqueue(trimmed);
+      setQueuedCount(inputQueue.length);
+      setInput("");
+      addMessage(MESSAGE_TYPE.SYSTEM, `  \u{1F4E5} Queued (${inputQueue.length} pending): ${trimmed.slice(0, 50)}...`);
+      return;
+    }
     setInput("");
     addMessage(MESSAGE_TYPE.USER, trimmed);
     if (trimmed.startsWith("/")) {
@@ -7734,7 +7889,7 @@ ${list}`);
           return;
         case "update":
           try {
-            const { checkForUpdate, formatUpdateNotification, doUpdate } = await import("./update-VGGUNUWQ.js");
+            const { checkForUpdate, formatUpdateNotification, doUpdate } = await import("./update-LQDOCICM.js");
             const result = checkForUpdate(true);
             if (result.hasUpdate) {
               const notification = formatUpdateNotification(result);
@@ -7926,7 +8081,10 @@ ${list}`);
         /* @__PURE__ */ jsx2(Text2, { color: THEME.text.accent, children: preInputBuffer }),
         /* @__PURE__ */ jsx2(Text2, { color: THEME.text.muted, children: "\u258C" })
       ] }),
-      /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "ESC to interrupt \u2502 Type ahead to queue input" }) })
+      /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "ESC to interrupt \u2502 Type ahead to queue input",
+        queuedCount > 0 ? ` \u2502 \u{1F4E5} ${queuedCount} queued` : ""
+      ] }) })
     ] }) : /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
       showCommandHints && input.startsWith("/") && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: [
         "/target <ip>",

package/dist/{update-VGGUNUWQ.js → update-LQDOCICM.js}

@@ -8,8 +8,8 @@ import {
   readVersionCache,
   semverTuple,
   writeVersionCache
-} from "./chunk-N27ISRFF.js";
-import "./chunk-IYELGZKK.js";
+} from "./chunk-TTQCHK5V.js";
+import "./chunk-UCB4BWTB.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   checkForUpdate,

package/package.json

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