Add bidirectional command capture - CLI commands now visible in dashboard

Co-authored-by: mblanke <9078342+mblanke@users.noreply.github.com>

BIDIRECTIONAL_CAPTURE.md

@@ -0,0 +1,405 @@
+# Bidirectional Command Capture
+
+## Overview
+
+StrikePackageGPT now supports **bidirectional command capture**, enabling commands run directly in the Kali container to be automatically captured and displayed in the dashboard alongside commands executed via the UI/API.
+
+This feature is perfect for advanced users who prefer command-line interfaces but still want visual tracking and historical reference.
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Two-Way Flow                              │
+├─────────────────────────────────────────────────────────────┤
+│                                                              │
+│  Dashboard UI → HackGPT API → Kali Executor → Kali Container│
+│       ↓                                           ↑          │
+│  Stored in scan_results  ←────────────────────────          │
+│       ↓                                                      │
+│  Displayed in Dashboard History                             │
+│                                                              │
+│  Direct Shell → Command Logger → JSON Files → API Sync      │
+│                      ↓                           ↑          │
+│              /workspace/.command_history    Auto-Import     │
+│                                                              │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Features
+
+### Automatic Logging
+- All commands run in interactive bash sessions are automatically logged
+- Command metadata captured: timestamp, user, working directory, exit code, duration
+- Full stdout/stderr captured for commands run with `capture` wrapper
+
+### Unified History
+- Commands from both sources (UI and direct shell) appear in the same history
+- Consistent format and parsing across all command sources
+- Network visualization includes manually-run scans
+
+### Real-Time Sync
+- API endpoint to pull latest captured commands
+- Background sync every 30 seconds (configurable)
+- Manual sync available via `/commands/sync` endpoint
+
+## Usage
+
+### Option 1: Automatic Logging (All Commands)
+
+When you connect to the Kali container, command logging is enabled automatically:
+
+```bash
+docker exec -it strikepackage-kali bash
+```
+
+Now run any security tool:
+
+```bash
+nmap -sV 192.168.1.0/24
+sqlmap -u "http://example.com?id=1"
+nikto -h http://example.com
+```
+
+These commands are logged with basic metadata. Full output capture requires Option 2.
+
+### Option 2: Explicit Capture (With Full Output)
+
+Use the `capture` command prefix for full output capture:
+
+```bash
+docker exec -it strikepackage-kali bash
+capture nmap -sV 192.168.1.0/24
+capture gobuster dir -u http://example.com -w /usr/share/wordlists/dirb/common.txt
+```
+
+This captures:
+- Full stdout and stderr
+- Exit codes
+- Execution duration
+- All command metadata
+
+### View Recent Commands
+
+Inside the container:
+
+```bash
+recent  # Shows last 10 captured commands
+```
+
+### Sync to Dashboard
+
+Commands are automatically synced to the dashboard. To manually trigger a sync:
+
+```bash
+curl -X POST http://localhost:8001/commands/sync
+```
+
+## API Endpoints
+
+### Get Captured Commands
+
+```bash
+GET /commands/captured?limit=50&since=2025-12-03T00:00:00Z
+```
+
+Returns commands captured from interactive sessions.
+
+**Response:**
+```json
+{
+  "commands": [
+    {
+      "command_id": "abc-123-def",
+      "command": "nmap -sV 192.168.1.0/24",
+      "timestamp": "2025-12-03T14:30:00Z",
+      "completed_at": "2025-12-03T14:35:00Z",
+      "status": "completed",
+      "exit_code": 0,
+      "duration": 300,
+      "stdout": "... nmap output ...",
+      "stderr": "",
+      "user": "root",
+      "working_dir": "/workspace",
+      "source": "capture_wrapper"
+    }
+  ],
+  "count": 1,
+  "imported_to_history": true
+}
+```
+
+### Sync Commands to History
+
+```bash
+POST /commands/sync
+```
+
+Imports all captured commands into the unified scan history, making them visible in the dashboard.
+
+**Response:**
+```json
+{
+  "status": "synced",
+  "imported_count": 15,
+  "message": "All captured commands are now visible in dashboard history"
+}
+```
+
+### View Unified History
+
+```bash
+GET /scans
+```
+
+Returns all commands from both sources (UI and direct shell).
+
+## Dashboard Integration
+
+### Viewing Captured Commands
+
+1. **Scan History Tab**: Shows all commands (UI + captured)
+2. **Network Map**: Includes hosts discovered via manual scans
+3. **Timeline View**: Shows when commands were executed
+4. **Filter by Source**: Filter to show only manually-run or UI-run commands
+
+### Visual Indicators
+
+- 🔷 **UI Commands**: Blue indicator
+- 🔶 **Manual Commands**: Orange indicator with "Interactive Shell" badge
+- ⚡ **Running**: Animated indicator
+- ✅ **Completed**: Green checkmark
+- ❌ **Failed**: Red X with error details
+
+## Configuration
+
+### Enable/Disable Automatic Logging
+
+To disable automatic logging in new shell sessions:
+
+```bash
+# Inside container
+echo 'DISABLE_AUTO_LOGGING=1' >> ~/.bashrc
+```
+
+### Change Log Directory
+
+Set a custom log directory:
+
+```bash
+# In docker-compose.yml or .env
+COMMAND_LOG_DIR=/custom/path/.command_history
+```
+
+### Sync Interval
+
+Configure auto-sync interval (default: 30 seconds):
+
+```bash
+# In HackGPT API configuration
+COMMAND_SYNC_INTERVAL=60  # seconds
+```
+
+## Technical Details
+
+### Storage Format
+
+Commands are stored as JSON files in `/workspace/.command_history/`:
+
+```json
+{
+  "command_id": "unique-uuid",
+  "command": "nmap -sV 192.168.1.1",
+  "timestamp": "2025-12-03T14:30:00Z",
+  "completed_at": "2025-12-03T14:35:00Z",
+  "user": "root",
+  "working_dir": "/workspace",
+  "source": "capture_wrapper",
+  "status": "completed",
+  "exit_code": 0,
+  "duration": 300,
+  "stdout": "...",
+  "stderr": ""
+}
+```
+
+### Command Logger (`command_logger.sh`)
+
+- Hooks into `PROMPT_COMMAND` for automatic logging
+- Filters out basic commands (cd, ls, etc.)
+- Lightweight metadata-only logging
+- No performance impact on command execution
+
+### Capture Wrapper (`capture`)
+
+- Full command wrapper for complete output capture
+- Uses `eval` with output redirection
+- Measures execution time
+- Captures exit codes
+- Saves results as JSON
+
+### API Integration
+
+1. **Kali Executor** reads JSON files from `/workspace/.command_history/`
+2. **HackGPT API** imports them into `scan_results` dict
+3. **Dashboard** displays them alongside UI-initiated commands
+4. Automatic deduplication prevents duplicates
+
+## Security Considerations
+
+### Command Whitelist
+
+- Command logging respects the existing whitelist
+- Only whitelisted tools are executed
+- Malicious commands are blocked before logging
+
+### Storage Limits
+
+- Log directory is size-limited (default: 10MB)
+- Oldest logs are automatically purged
+- Configurable retention period
+
+### Access Control
+
+- Logs are stored in container-specific workspace
+- Only accessible via API with authentication (when enabled)
+- No cross-container access
+
+## Troubleshooting
+
+### Commands Not Appearing in Dashboard
+
+1. **Check logging is enabled**:
+   ```bash
+   docker exec -it strikepackage-kali bash -c 'echo $PROMPT_COMMAND'
+   ```
+
+2. **Verify log files are created**:
+   ```bash
+   docker exec -it strikepackage-kali ls -la /workspace/.command_history/
+   ```
+
+3. **Manually trigger sync**:
+   ```bash
+   curl -X POST http://localhost:8001/commands/sync
+   ```
+
+### Output Not Captured
+
+- Use `capture` prefix for full output: `capture nmap ...`
+- Check log file exists: `ls /workspace/.command_history/`
+- Verify command completed: `recent`
+
+### Performance Issues
+
+If logging causes slowdowns:
+
+1. **Disable for current session**:
+   ```bash
+   unset PROMPT_COMMAND
+   ```
+
+2. **Increase sync interval**:
+   ```bash
+   # In .env
+   COMMAND_SYNC_INTERVAL=120
+   ```
+
+3. **Clear old logs**:
+   ```bash
+   curl -X DELETE http://localhost:8001/captured_commands/clear
+   ```
+
+## Examples
+
+### Example 1: Network Reconnaissance
+
+```bash
+# In Kali container
+docker exec -it strikepackage-kali bash
+
+# Run discovery scan (automatically logged)
+nmap -sn 192.168.1.0/24
+
+# Run detailed scan with full capture
+capture nmap -sV -sC -p- 192.168.1.100
+
+# View in dashboard
+# → Go to Scan History
+# → See both commands with full results
+# → View in Network Map
+```
+
+### Example 2: Web Application Testing
+
+```bash
+# Directory bruteforce
+capture gobuster dir -u http://target.com -w /usr/share/wordlists/dirb/common.txt
+
+# SQL injection testing
+capture sqlmap -u "http://target.com?id=1" --batch --dbs
+
+# Vulnerability scanning
+capture nikto -h http://target.com
+
+# All results appear in dashboard history
+```
+
+### Example 3: Wireless Auditing
+
+```bash
+# Put adapter in monitor mode
+capture airmon-ng start wlan0
+
+# Scan for networks
+capture airodump-ng wlan0mon
+
+# Results visible in dashboard with timestamps
+```
+
+## Advantages
+
+### For Advanced Users
+- ✅ Use familiar command-line interface
+- ✅ Full control over tool parameters
+- ✅ Faster than clicking through UI
+- ✅ Still get visual tracking and history
+
+### For Teams
+- ✅ All team member activity captured
+- ✅ Unified view of all scan activity
+- ✅ Easy to review what was run
+- ✅ Share results without screenshots
+
+### For Reporting
+- ✅ Complete audit trail
+- ✅ Timestamp all activities
+- ✅ Include in final reports
+- ✅ Demonstrate thoroughness
+
+## Comparison
+
+| Feature | UI-Only | Bidirectional |
+|---------|---------|---------------|
+| Run commands via dashboard | ✅ | ✅ |
+| Run commands via CLI | ❌ | ✅ |
+| Visual history | ✅ | ✅ |
+| Network map integration | ✅ | ✅ |
+| Advanced tool parameters | Limited | Full |
+| Speed for power users | Slow | Fast |
+| Learning curve | Low | Medium |
+
+## Future Enhancements
+
+- **Real-time streaming**: See command output as it runs
+- **Collaborative mode**: Multiple users see each other's commands
+- **Smart suggestions**: AI suggests next commands based on results
+- **Template library**: Save common command sequences
+- **Report integration**: One-click add to PDF report
+
+## Support
+
+For issues or questions:
+- GitHub Issues: https://github.com/mblanke/StrikePackageGPT/issues
+- Documentation: See `FEATURES.md` and `INTEGRATION_EXAMPLE.md`
+- Examples: Check `examples/` directory

README.md

@@ -14,6 +14,7 @@ StrikePackageGPT provides security researchers and penetration testers with an A
 - **Vulnerability Analysis** - CVE research, misconfiguration detection
 - **Exploit Research** - Safe research and documentation of exploits
 - **Report Generation** - Professional security assessment reports
+- **🆕 Bidirectional Command Capture** - Run commands in CLI, see results in dashboard
 
 ## 🚀 Quick Start
 
@@ -84,6 +85,35 @@ Access the Kali container:
 docker exec -it strikepackage-kali bash
 ```
 
+### 🔄 Bidirectional Command Capture
+
+**New Feature!** Commands run directly in the Kali container are now automatically captured and visible in the dashboard:
+
+```bash
+# Connect to container
+docker exec -it strikepackage-kali bash
+
+# Run commands normally - they're automatically logged
+nmap -sV 192.168.1.0/24
+
+# Use 'capture' for full output capture
+capture sqlmap -u "http://example.com?id=1" --batch
+
+# View recent commands
+recent
+
+# All commands appear in dashboard history! 🎉
+```
+
+**Benefits:**
+- ✅ Use CLI for speed, GUI for visualization
+- ✅ Perfect for advanced users who prefer terminal
+- ✅ Unified history across all command sources
+- ✅ Network map includes manually-run scans
+- ✅ Complete audit trail for reporting
+
+See `BIDIRECTIONAL_CAPTURE.md` for full documentation.
+
 ## 🤖 LLM Providers
 
 StrikePackageGPT supports multiple LLM providers:

services/hackgpt-api/app/main.py

@@ -729,6 +729,85 @@ async def clear_scans():
     return {"status": "cleared", "message": "All scan history cleared"}
 
 
+# ============== Interactive Command Capture ==============
+
+@app.get("/commands/captured")
+async def get_captured_commands(limit: int = 50, since: Optional[str] = None):
+    """
+    Get commands that were run directly in the Kali container.
+    These are captured via the command logging system in interactive shells.
+    """
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"{KALI_EXECUTOR_URL}/captured_commands",
+                params={"limit": limit, "since": since} if since else {"limit": limit},
+                timeout=10.0
+            )
+            
+            if response.status_code != 200:
+                return {"commands": [], "error": "Could not retrieve captured commands"}
+            
+            captured = response.json()
+            commands = captured.get("commands", [])
+            
+            # Import captured commands into scan_results for unified history
+            for cmd in commands:
+                cmd_id = cmd.get("command_id")
+                if cmd_id and cmd_id not in scan_results:
+                    scan_results[cmd_id] = {
+                        "scan_id": cmd_id,
+                        "tool": cmd.get("command", "").split()[0] if cmd.get("command") else "unknown",
+                        "target": "interactive",
+                        "scan_type": "manual",
+                        "command": cmd.get("command"),
+                        "status": cmd.get("status", "completed"),
+                        "started_at": cmd.get("timestamp"),
+                        "completed_at": cmd.get("completed_at"),
+                        "result": {
+                            "stdout": cmd.get("stdout", ""),
+                            "stderr": cmd.get("stderr", ""),
+                            "exit_code": cmd.get("exit_code"),
+                            "duration": cmd.get("duration")
+                        },
+                        "source": cmd.get("source", "interactive_shell"),
+                        "user": cmd.get("user"),
+                        "working_dir": cmd.get("working_dir")
+                    }
+                    
+                    # Parse output if available
+                    if cmd.get("stdout"):
+                        tool = cmd.get("command", "").split()[0]
+                        parsed = parse_tool_output(tool, cmd.get("stdout", ""))
+                        scan_results[cmd_id]["parsed"] = parsed
+            
+            return {
+                "commands": commands,
+                "count": len(commands),
+                "imported_to_history": True,
+                "message": "Captured commands are now visible in scan history"
+            }
+            
+    except httpx.ConnectError:
+        return {"commands": [], "error": "Kali executor service not available"}
+    except Exception as e:
+        return {"commands": [], "error": str(e)}
+
+
+@app.post("/commands/sync")
+async def sync_captured_commands():
+    """
+    Sync all captured commands from the Kali container into the unified scan history.
+    This allows commands run directly in the container to appear in the dashboard.
+    """
+    result = await get_captured_commands(limit=1000)
+    return {
+        "status": "synced",
+        "imported_count": result.get("count", 0),
+        "message": "All captured commands are now visible in dashboard history"
+    }
+
+
 # ============== Output Parsing ==============
 
 def parse_tool_output(tool: str, output: str) -> Dict[str, Any]:

services/kali-executor/app/main.py

@@ -498,6 +498,88 @@ async def list_installed_tools():
     return {"installed_tools": installed}
 
 
+@app.get("/captured_commands")
+async def get_captured_commands(limit: int = 50, since: Optional[str] = None):
+    """
+    Get commands that were captured from interactive shell sessions in the Kali container.
+    These are commands run directly by users via docker exec or SSH.
+    """
+    global kali_container
+    
+    if not kali_container:
+        raise HTTPException(status_code=503, detail="Kali container not available")
+    
+    try:
+        kali_container.reload()
+        
+        # Read command history from the shared volume
+        cmd = ["bash", "-c", "cd /workspace/.command_history && ls -t *.json 2>/dev/null | head -n {}".format(limit)]
+        exit_code, output = kali_container.exec_run(cmd=cmd, demux=True)
+        
+        if exit_code != 0 or not output[0]:
+            return {"commands": [], "count": 0}
+        
+        # Get list of log files
+        log_files = output[0].decode('utf-8', errors='replace').strip().split('\n')
+        log_files = [f for f in log_files if f.strip()]
+        
+        commands = []
+        for log_file in log_files:
+            try:
+                # Read each JSON log file
+                read_cmd = ["cat", f"/workspace/.command_history/{log_file}"]
+                exit_code, output = kali_container.exec_run(cmd=read_cmd, demux=True)
+                
+                if exit_code == 0 and output[0]:
+                    cmd_data = json.loads(output[0].decode('utf-8', errors='replace'))
+                    
+                    # Filter by timestamp if requested
+                    if since:
+                        cmd_timestamp = cmd_data.get("timestamp", "")
+                        if cmd_timestamp < since:
+                            continue
+                    
+                    commands.append(cmd_data)
+                    
+            except json.JSONDecodeError:
+                continue
+            except Exception:
+                continue
+        
+        return {
+            "commands": commands,
+            "count": len(commands),
+            "source": "interactive_shell_capture"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading captured commands: {str(e)}")
+
+
+@app.delete("/captured_commands/clear")
+async def clear_captured_commands():
+    """Clear all captured command history."""
+    global kali_container
+    
+    if not kali_container:
+        raise HTTPException(status_code=503, detail="Kali container not available")
+    
+    try:
+        kali_container.reload()
+        
+        # Clear the command history directory
+        cmd = ["bash", "-c", "rm -f /workspace/.command_history/*.json"]
+        exit_code, _ = kali_container.exec_run(cmd=cmd)
+        
+        if exit_code == 0:
+            return {"status": "cleared", "message": "All captured command history cleared"}
+        else:
+            raise HTTPException(status_code=500, detail="Failed to clear history")
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @app.get("/allowed-commands")
 async def get_allowed_commands():
     """Get list of allowed commands for security validation."""

services/kali/Dockerfile

@@ -10,18 +10,30 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
-# Install additional Python tools
+# Install additional Python tools and utilities for command logging
 RUN pip3 install --break-system-packages \
     requests \
     beautifulsoup4 \
     shodan \
     censys
 
+# Install jq and uuid-runtime for command logging
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    jq \
+    uuid-runtime \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
 # Create workspace directory
 WORKDIR /workspace
 
-# Copy entrypoint script
+# Copy scripts
 COPY entrypoint.sh /entrypoint.sh
-RUN chmod +x /entrypoint.sh
+COPY command_logger.sh /usr/local/bin/command_logger.sh
+COPY capture_wrapper.sh /usr/local/bin/capture
+RUN chmod +x /entrypoint.sh /usr/local/bin/command_logger.sh /usr/local/bin/capture
+
+# Create command history directory
+RUN mkdir -p /workspace/.command_history
 
 ENTRYPOINT ["/entrypoint.sh"]

services/kali/capture_wrapper.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+# Output Capture Wrapper for Security Tools
+# Wraps command execution to capture stdout/stderr and save results
+
+COMMAND_LOG_DIR="${COMMAND_LOG_DIR:-/workspace/.command_history}"
+mkdir -p "$COMMAND_LOG_DIR"
+
+# Get command from arguments
+cmd_string="$@"
+[[ -z "$cmd_string" ]] && exit 1
+
+# Generate unique ID
+cmd_id=$(uuidgen 2>/dev/null || echo "$(date +%s)-$$")
+timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+output_file="$COMMAND_LOG_DIR/${cmd_id}.json"
+stdout_file="$COMMAND_LOG_DIR/${cmd_id}.stdout"
+stderr_file="$COMMAND_LOG_DIR/${cmd_id}.stderr"
+
+# Create initial log entry
+cat > "$output_file" << EOF
+{
+  "command_id": "$cmd_id",
+  "command": $(echo "$cmd_string" | jq -Rs .),
+  "timestamp": "$timestamp",
+  "user": "$(whoami)",
+  "working_dir": "$(pwd)",
+  "source": "capture_wrapper",
+  "status": "running"
+}
+EOF
+
+# Execute command and capture output
+start_time=$(date +%s)
+set +e
+eval "$cmd_string" > "$stdout_file" 2> "$stderr_file"
+exit_code=$?
+set -e
+end_time=$(date +%s)
+duration=$((end_time - start_time))
+completed_at=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+# Read captured output
+stdout_content=$(cat "$stdout_file" 2>/dev/null || echo "")
+stderr_content=$(cat "$stderr_file" 2>/dev/null || echo "")
+
+# Update log entry with results
+cat > "$output_file" << EOF
+{
+  "command_id": "$cmd_id",
+  "command": $(echo "$cmd_string" | jq -Rs .),
+  "timestamp": "$timestamp",
+  "completed_at": "$completed_at",
+  "user": "$(whoami)",
+  "working_dir": "$(pwd)",
+  "source": "capture_wrapper",
+  "status": "$([ $exit_code -eq 0 ] && echo 'completed' || echo 'failed')",
+  "exit_code": $exit_code,
+  "duration": $duration,
+  "stdout": $(echo "$stdout_content" | jq -Rs .),
+  "stderr": $(echo "$stderr_content" | jq -Rs .)
+}
+EOF
+
+# Clean up temp files
+rm -f "$stdout_file" "$stderr_file"
+
+# Output results to terminal
+cat "$stdout_file" 2>/dev/null || true
+cat "$stderr_file" >&2 2>/dev/null || true
+
+echo "" >&2
+echo "[StrikePackageGPT] Command captured: $cmd_id" >&2
+echo "[StrikePackageGPT] Exit code: $exit_code | Duration: ${duration}s" >&2
+echo "[StrikePackageGPT] Results available in dashboard" >&2
+
+exit $exit_code

services/kali/command_logger.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# Command Logger for StrikePackageGPT
+# Logs all commands executed in interactive shell sessions
+# Results are captured and made available to the API
+
+COMMAND_LOG_DIR="${COMMAND_LOG_DIR:-/workspace/.command_history}"
+mkdir -p "$COMMAND_LOG_DIR"
+
+# Function to log command execution
+log_command() {
+    local cmd="$1"
+    local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    local cmd_id=$(uuidgen 2>/dev/null || echo "$(date +%s)-$$")
+    local output_file="$COMMAND_LOG_DIR/${cmd_id}.json"
+    
+    # Skip logging for cd, ls, echo, and other basic commands
+    local first_word=$(echo "$cmd" | awk '{print $1}')
+    case "$first_word" in
+        cd|ls|pwd|echo|exit|clear|history|source|alias|\
+        export|unset|env|printenv|which|type|whereis)
+            return 0
+            ;;
+    esac
+    
+    # Skip empty commands
+    [[ -z "$cmd" ]] && return 0
+    
+    # Create log entry with metadata
+    cat > "$output_file" << EOF
+{
+  "command_id": "$cmd_id",
+  "command": $(echo "$cmd" | jq -Rs .),
+  "timestamp": "$timestamp",
+  "user": "$(whoami)",
+  "working_dir": "$(pwd)",
+  "source": "interactive_shell",
+  "status": "pending"
+}
+EOF
+    
+    echo "[StrikePackageGPT] Command logged: $cmd_id" >&2
+    echo "[StrikePackageGPT] Results will be visible in dashboard" >&2
+}
+
+# PROMPT_COMMAND hook to log each command after execution
+export PROMPT_COMMAND='history -a; if [ -n "$LAST_CMD" ]; then log_command "$LAST_CMD"; fi; LAST_CMD=$(history 1 | sed "s/^[ ]*[0-9]*[ ]*//"); '
+
+# Also trap DEBUG for more comprehensive logging
+trap 'LAST_EXEC_CMD="$BASH_COMMAND"' DEBUG
+
+echo "[StrikePackageGPT] Command logging enabled"
+echo "[StrikePackageGPT] All security tool commands will be captured and visible in the dashboard"
+echo ""

services/kali/entrypoint.sh

@@ -1,8 +1,28 @@
 #!/bin/bash
 
+# Enable command logging by default for all bash sessions
+echo 'source /usr/local/bin/command_logger.sh' >> /root/.bashrc
+echo 'export COMMAND_LOG_DIR=/workspace/.command_history' >> /root/.bashrc
+
+# Create convenience aliases for captured execution
+cat >> /root/.bashrc << 'ALIASES'
+# Convenience alias to run commands with automatic capture
+alias run='capture'
+
+# Helper function to show recent commands
+recent_commands() {
+    echo "Recent commands logged:"
+    ls -lt /workspace/.command_history/*.json 2>/dev/null | head -10 | while read line; do
+        file=$(echo "$line" | awk '{print $NF}')
+        [ -f "$file" ] && jq -r '"\(.timestamp) - \(.command) [\(.status)]"' "$file" 2>/dev/null
+    done
+}
+alias recent='recent_commands'
+ALIASES
+
 echo "=================================================="
 echo "  StrikePackageGPT - Kali Container"
-echo "  Security Tools Ready"
+echo "  Security Tools Ready + Command Capture Enabled"
 echo "=================================================="
 echo ""
 echo "Available tools:"
@@ -13,6 +33,21 @@ echo "  - sqlmap (SQL injection)"
 echo "  - hydra (brute force)"
 echo "  - metasploit (exploitation)"
 echo "  - searchsploit (exploit database)"
+echo "  - aircrack-ng, wifite (wireless)"
+echo "  - john, hashcat (password cracking)"
+echo "  - and 600+ more Kali tools"
+echo ""
+echo "🔄 BIDIRECTIONAL CAPTURE ENABLED 🔄"
+echo ""
+echo "Commands you run here will be captured and visible in:"
+echo "  • Dashboard history"
+echo "  • API scan results"
+echo "  • Network visualization"
+echo ""
+echo "Usage:"
+echo "  • Run commands normally: nmap -sV 192.168.1.1"
+echo "  • Use 'capture' prefix for explicit capture: capture nmap -sV 192.168.1.1"
+echo "  • View recent: recent"
 echo ""
 echo "Container is ready for security testing."
 echo ""