Privacy and Security Implications of Using Wigolo: A Local‑First Web Intelligence Tool

Wigolo stores all data locally under ~/.wigolo, encrypts secrets in the OS keychain or AES‑256‑GCM files, and only communicates with external services you explicitly configure, making it private by architecture rather than policy.

Understanding the privacy and security implications of using a local‑first web intelligence tool like Wigolo requires examining its architectural guarantees rather than reading privacy policies. Wigolo, an open‑source project developed by KnockOutEZ/wigolo, ensures that sensitive intelligence data never leaves your machine unless you explicitly configure outbound connections.

Local‑First Data Architecture

All application state lives under ~/.wigolo by default. According to docs/privacy-security.md, this directory contains cache, job history, model files, configuration, and encrypted credential stores.

Deleting this directory (rm -rf ~/.wigolo) removes every trace of the tool’s activity, ensuring complete data sovereignty. No background sync processes upload content to cloud infrastructure unless you deliberately enable network features.

Minimal and Explicit Network Egress

Wigolo establishes outbound connections to only three categories of endpoints:

1. Target websites you explicitly query during crawling or fetching operations.
2. LLM providers you configure for synthesis; setting WIGOLO_LOCAL_LLM=auto keeps all processing on‑device with no external LLM calls.
3. Optional telemetry endpoints you define; the repository ships with no default vendor endpoint.

Components like browser engines and on‑device models download from public distribution sites during initialization, but the code contains no hidden licensing checks or phone‑home behavior.

Opt‑In Telemetry Controls

When you set WIGOLO_TELEMETRY=1, the system writes events to a local NDJSON file under ~/.wigolo/telemetry/. A network POST occurs only if you additionally define WIGOLO_TELEMETRY_ENDPOINT. The default configuration keeps telemetry data local, ensuring no information reaches external servers without explicit configuration.

Secret Management and Encryption

Wigolo implements a tiered secret management strategy in src/security/key-store.ts that prioritizes the OS keychain. LLM API keys are written to the system keyring when available. If the keychain is unavailable, the tool falls back to AES‑256‑GCM‑encrypted files stored in ~/.wigolo/keys/, as implemented in src/security/keychain.ts.

Proxy credentials are split from URLs before storage. The persisted config.json contains only the credential‑free URL, while secrets reside in encrypted storage. When you run wigolo config --export, the output deliberately omits secrets to prevent accidental credential leakage.

Server Mode Security Hardening

When running as an HTTP daemon via wigolo serve, Wigolo implements defense‑in‑depth protections against hostile networks:

• Fail‑closed bind gate: Non‑loopback binds without an authentication token are rejected immediately.
• Bearer token authentication: Protects REST and MCP routes while keeping /health open for monitoring probes.
• DNS‑rebinding guard: Blocks requests with non‑loopback Host headers.
• Browser‑origin guard: Rejects any request carrying an Origin header before token validation occurs.

These protections, implemented in src/server.ts, prevent malicious web pages from exploiting an exposed daemon to access internal services.

SSRF Protection

The src/watch/ssrf.ts module guards against Server‑Side Request Forgery attacks. All URL‑taking endpoints—including fetch, crawl, and webhook destinations—reject targets resolving to private or loopback address spaces unless you explicitly set WIGOLO_FETCH_ALLOW_PRIVATE=true.

Practical Configuration Examples

Run in Local‑Only Mode

Configure Wigolo to use a local LLM provider and avoid external API calls:

export WIGOLO_LLM_PROVIDER=ollama
export WIGOLO_LOCAL_LLM=auto
wigolo research "Analyze competitor pricing"

This keeps all synthesis processing on your machine with no outbound LLM traffic.

Securely Store API Credentials

Store secrets in the OS keychain with automatic fallback to encrypted files:

import { storeKey } from 'wigolo-sdk';

await storeKey('openai', process.env.OPENAI_API_KEY!, { 
  dataDir: '~/.wigolo' 
});

This invokes the tiered storage logic in src/security/key-store.ts, attempting the OS keychain first via the keychainSet function in src/security/keychain.ts.

Configure Telemetry with Self‑Hosted Endpoint

Enable local telemetry collection while controlling the destination:

export WIGOLO_TELEMETRY=1
export WIGOLO_TELEMETRY_ENDPOINT=http://my-collector.local/telemetry
wigolo doctor

Events write to local NDJSON files and POST only to your specified endpoint.

Launch Hardened Server Daemon

Bind strictly to localhost with authentication:

wigolo serve --host 127.0.0.1 --token $(openssl rand -hex 32)

Remote bind attempts without tokens fail due to the fail‑closed gate in src/server.ts.

Summary

• Data Sovereignty: All state resides in ~/.wigolo and deletes completely with rm -rf ~/.wigolo.
• Explicit Network Policy: Only connects to websites you query and LLMs you configure; no default telemetry endpoints.
• Defense in Depth: OS keychain integration with AES‑256‑GCM file encryption fallback for credential storage.
• Network Hardening: Serve mode implements fail‑closed binding, token auth, DNS rebinding protection, and origin validation.
• SSRF Prevention: Blocks private IP ranges unless explicitly allowed via WIGOLO_FETCH_ALLOW_PRIVATE.

Frequently Asked Questions

Does Wigolo send any data to its developers by default?

No. Wigolo ships with no default telemetry endpoint. When you set WIGOLO_TELEMETRY=1, events are written to local NDJSON files under ~/.wigolo/telemetry/. Network transmission occurs only if you additionally configure WIGOLO_TELEMETRY_ENDPOINT to point to your own infrastructure.

How does Wigolo protect my LLM API keys?

Wigolo stores LLM API keys in the OS keychain when available, falling back to AES‑256‑GCM‑encrypted files in ~/.wigolo/keys/ if the keychain is unavailable. The src/security/keychain.ts wrapper handles this tiered storage automatically, and exported configurations intentionally exclude secrets.

Can running Wigolo as a server expose my internal network to attackers?

The server mode includes multiple safeguards: it rejects non‑loopback binds without authentication tokens, validates bearer tokens on sensitive routes, blocks DNS‑rebinding attacks via Host header validation, and rejects cross‑origin requests. These protections prevent malicious websites from exploiting an exposed daemon to access internal services.

What happens to my data if I uninstall Wigolo?

Since all data lives in ~/.wigolo by default, running rm -rf ~/.wigolo removes cache, jobs, models, configuration, and encrypted secrets. No data persists in cloud services or remote infrastructure unless you explicitly configured external telemetry or LLM endpoints.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}