Vigolium

# Publishing soon

# Scan a single target (default: balanced strategy)
vigolium scan -t https://example.com

# Scan with a strategy preset
vigolium scan -t https://example.com --strategy deep

# Scan specific modules only
vigolium scan -t https://example.com -m xss-reflected,sqli-error

# Scan from an OpenAPI spec
vigolium scan -T openapi.yaml -I openapi

# Pipe URLs from stdin
cat urls.txt | vigolium scan

# Run a single phase directly
vigolium run discovery -t https://example.com

# Generate an HTML report
vigolium scan -t https://example.com --only discovery --format html -o report.html

# Start API server with authentication
vigolium server -k my-secret-key

# Enable transparent HTTP proxy for traffic recording
vigolium server -k my-key --ingest-proxy-port 9003

# Auto-scan ingested traffic
vigolium server -k my-key --scan-on-receive

# Ingest traffic to a running server
cat urls.txt | vigolium ingest -s http://localhost:9002

# Ingest an OpenAPI spec
vigolium ingest -s http://localhost:9002 -i api.yaml -I openapi

# Inline session via CLI flag (name:Header:value)
vigolium scan -t https://example.com \
  --session "admin:Cookie:session_id=abc123" \
  --session "user:Cookie:session_id=xyz789"

# Load session from YAML/JSON file
vigolium scan -t https://example.com --session-file ./admin-session.yaml

# Full auth configuration with login flows
vigolium scan -t https://example.com --auth-config ./auth-config.yaml

# Add custom headers (works with sessions)
vigolium scan -t https://example.com -H "Authorization: Bearer token123"

# Autopilot: autonomous AI-driven scanning (SDK protocol — full tool access)
vigolium agent autopilot -t https://example.com
vigolium agent autopilot -t https://example.com --source ./src --focus "auth bypass"
vigolium agent autopilot -t https://example.com --specialists injection,xss,auth

# Swarm: AI-guided targeted or full-scope vulnerability scanning
vigolium agent swarm -t https://example.com/api/users --vuln-type sqli
vigolium agent swarm -t https://example.com --discover  # full-scope (replaces pipeline)
vigolium agent swarm -t https://example.com --source ./src --discover  # source-aware full-scope
vigolium agent swarm --input "curl -X POST https://example.com/api/login -d '{\"user\":\"admin\"}'"

# Pipeline: backward-compatible alias for swarm --discover
vigolium agent pipeline -t https://example.com

# Security code review of a repository
vigolium agent query --source ./myapp --prompt-template security-code-review

# Send a freeform prompt
vigolium agent query --prompt "Explain the OWASP Top 10 in one sentence each"

# Dry run — render prompt without executing
vigolium agent query --source ./myapp --prompt-template endpoint-discovery --dry-run

# Browse agent sessions
vigolium agent session list --mode pipeline --limit 20

# List available agents and templates
vigolium agent --list-agents
vigolium agent --list-templates

# Execute inline JavaScript
vigolium js --code 'let r = vigolium.http.get(TARGET); console.log(r.statusCode)' -t https://example.com

# Run a JS file with timeout
vigolium js --code-file ./my-script.js -t https://example.com --timeout 60s

# Manage extensions
vigolium ext ls                # list loaded extensions
vigolium ext docs --example    # browse API with code examples
vigolium ext preset            # install starter scripts

// Create a persistent session with shared cookie jar
let session = vigolium.http.session();
session.post("https://app.example.com/login", { user: "admin", pass: "secret" });
session.get("https://app.example.com/dashboard"); // cookies auto-sent

// Automated login flow with token extraction
let authed = vigolium.http.login({
  url: "https://app.example.com/api/auth",
  method: "POST",
  body: JSON.stringify({ username: "admin", password: "pass" }),
  extract: [{ source: "json", path: "$.token", apply_as: "Authorization: Bearer {value}" }]
});

// IDOR/BOLA testing across multiple sessions
let results = vigolium.http.authTest({
  sessions: { admin: adminSession, user: userSession },
  requests: [{ method: "GET", url: "https://app.example.com/api/users/1" }]
});

// Multi-step authentication sequences
let result = vigolium.http.sequence([
  { url: "/csrf", extract: [{ source: "cookie", name: "csrf_token", as: "token" }] },
  { url: "/login", method: "POST", body: "csrf={token}&user=admin" }
]);

// Parallel request batching (race conditions, IDOR)
let responses = vigolium.http.batch([req1, req2, req3], { concurrency: 10 });

// CSRF token extraction
let csrf = vigolium.http.csrf("https://app.example.com/form");

// HTTP request replay with variations
let varied = vigolium.http.replay(rawRequest, [
  { headers: { "Authorization": "Bearer admin_token" } },
  { headers: { "Authorization": "Bearer user_token" } }
]);

vigolium scan                Run a native scan — deterministic multi-phase vulnerability scanning
vigolium run <phase>         Run a single native scan phase (alias for scan --only <phase>)
vigolium scan-url <url>      Quick native scan of a single URL
vigolium scan-request        Native scan from a raw HTTP request

vigolium agent autopilot     Agentic scan: autonomous AI-driven vulnerability scanning
vigolium agent swarm         Agentic scan: AI-guided targeted or full-scope vulnerability scanning
vigolium agent pipeline      Agentic scan: alias for swarm --discover (backward compat)
vigolium agent query         Send a prompt to an AI agent and get a response

vigolium server              Start the API server with traffic ingestion
vigolium ingest              Ingest traffic to a running server
vigolium js                  Execute JavaScript/TypeScript code

vigolium db                  Database operations (list, stats, export, clean)
vigolium finding             Browse and manage findings
vigolium traffic             Browse and manage HTTP records
vigolium project             Manage projects (create, list, use, config)
vigolium ext                 Manage JavaScript extensions

Native Scan (vigolium scan / run):
  -t, --target           Target URL
  -T, --target-file      File containing target URLs
  -i, --input            Input file path (- for stdin)
  -I, --input-mode       Input format: urls, openapi, nuclei, burpxml, curl, postman
  -m, --modules          Modules to run (comma-separated or 'all')
      --strategy         Strategy preset: lite, balanced, deep, whitebox
      --scanning-profile Scanning profile name or YAML path
      --only             Single phase: ingestion, discover (deparos), spidering (spitolas),
                         external-harvest, spa, sast, audit

Authentication:
      --session           Inline session definition (name:Header:value, repeatable)
      --session-file      Session YAML/JSON file path (repeatable)
      --auth-config       Full auth configuration file path
  -H, --header           Custom HTTP header (repeatable)

Performance:
  -c, --concurrency      Concurrent workers (default: 50)
  -r, --rate-limit       Max requests/sec (default: 0 = unlimited)
      --max-per-host     Per-host concurrency cap (default: 2)
      --proxy            HTTP/SOCKS5 proxy URL
      --timeout          HTTP request timeout (default: 15s)

Agentic Scan (vigolium agent autopilot / pipeline / swarm):
      --source             Path to source code for source-aware scanning
      --source-label       Label for source code ingestion
      --agent              Agent backend name (default: from config)
      --agent-acp-cmd      Custom ACP agent command (overrides --agent)
      --agent-timeout      Max agent execution time (default: 5m, 0 = no limit)
      --vuln-type          Vulnerability type focus (sqli, xss, ssrf, etc.)
      --focus              Focus area for the agentic scan (e.g. 'API injection')
      --max-iterations     Max triage-rescan iterations (default: 3)
      --max-rescan-rounds  Max rescan rounds in pipeline mode (default: 2)
      --source-analysis-only  Run only source analysis phase and exit
      --skip-phase         Skip a pipeline phase (repeatable)
      --start-from         Start pipeline from a specific phase

JavaScript:
      --code             Inline JavaScript to execute
      --code-file        Path to JS/TS file to execute
      --timeout          Execution timeout (default: 30s)

Output:
  -j, --json             JSON output
      --format           Output format: console, jsonl, html
  -o, --output           Output file path
      --silent           Suppress all output except findings
  -v, --verbose          Verbose logging