Skip to content
Back to search

wigolo

Monitor a page for changes over time. Create lazy watch jobs on one or many URLs, list them, and check on demand with optional SSRF-guarded webhook delivery.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/KnockOutEZ/wigolo with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/KnockOutEZ/wigolo'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/knockoutez--wigolo/badge.svg)](/listings/knockoutez--wigolo)

HTML

<a href="/listings/knockoutez--wigolo"><img src="/api/listings/knockoutez--wigolo/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx wigolo init                              # set up the local engine — any system
npx wigolo init --agents=claude-code,cursor  # …or set up + wire your day-to-day agents in one command

Requires **Node ≥ 20** and ~1.5 GB of free disk on macOS, Linux, or Windows. Bare `init` sets up the local engine: it downloads the browser engine and on-device models, runs a health check, and reports each component. Adding `--agents` wires the named agents in the same run, so a coding agent you use daily is ready in one command.

- **Supported agents** — `--agents` takes any of `claude-code` · `cursor` · `codex` · `gemini-cli` · `opencode` · `vscode` · `windsurf` · `zed` · `antigravity` (comma-separated); wigolo writes the MCP config and, where supported, instructions for each. - **Any other setup** — any MCP client, agent framework, or self-hosted agent registers `npx -y wigolo` in its own MCP config. The [installation guide](docs/installation.md) has the exact config block for every client, plus Docker, Homebrew, and single-file-binary channels. - **More on the way** — the supported list keeps growing, and a PR to add your agent is welcome; see [CONTRIBUTING.md](CONTRIBUTING.md). - **Interactive setup** — `--interactive` is a plain-text flow; `--wizard` is the full terminal TUI. - **Defer downloads** — `--no-warmup` waits until first use. A failed component download never fails setup; init reports what's not ready with the exact fix and still completes.

`init` is unattended by default, so it's safe in scripts and CI, and any setup problem surfaces right here in the per-component report, before your agent's first call. **Search, fetch, crawl, extract, cache, and find-similar work with no API key.** Check it's healthy anytime:

npx wigolo doctor

To remove everything cleanly, run `npx wigolo config --uninstall --yes`. You can also paste the [installation guide](docs/installation.md) into any AI assistant and let it do the setup; it's written to be self-contained.

Recommended — a free key for `research` & `agent`

Search, fetch, crawl, extract, cache, and find-similar are **fully keyless**. `research`, `agent`, and `search format=answer` use an LLM to write the synthesized, cited answer. Without one they hand back a raw brief and evidence for your agent to assemble. A free Gemini key turns that into a finished answer:

export WIGOLO_LLM_PROVIDER=gemini
export GEMINI_API_KEY=<free-key>      # grab one at aistudio.google.com/apikey — the free tier is plenty

Any provider works (`anthropic` · `openai` · `groq`), or stay fully local and keyless with `WIGOLO_LLM_PROVIDER=ollama` (or any OpenAI-compatible URL). Set it in your shell or your agent's MCP `env` block. Providers, models, and the keyless local-model ladder are in the [configuration guide](docs/configuration.md).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 424 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ---
  2. name: wigolo
  3. description: Local-first web intelligence MCP server for AI coding agents. Ten tools for search, fetch, crawl, cache, extract, find similar, research, agent-driven data gathering, page diffing, and change watching. No API keys. Results cached in a local knowledge store.
  4. author: KnockOutEZ
  5. license: AGPL-3.0-only
  6. repository: https://github.com/KnockOutEZ/wigolo
  7. transport: stdio
  8. install: npx wigolo
  9. runtime: node
  10. min_runtime_version: "20"
  11. tools:
  12. - name: fetch
  13. description: Fetch one URL, return clean markdown. Auto-routes between HTTP and browser engine. Supports sections, auth, screenshots, browser actions.
  14. - name: search
  15. description: Search the web, return extracted markdown per result. Single query or array of query variants. Domain, category, date filters. Formats include ML-scored highlights with citations for host-LLM synthesis.
  16. - name: crawl
  17. description: Crawl a site from a seed URL. BFS, DFS, sitemap, or map (URL-only) strategies with regex include/exclude filters.
  18. - name: cache
  19. description: Full-text search over previously fetched content. URL glob, date filters, stats, clear, and change detection via re-fetch.
  20. - name: extract
  21. description: Structured extraction from URL or raw HTML. Modes: selector (CSS), tables, metadata (meta + JSON-LD), schema (heuristic field matching), structured (tables + dl + JSON-LD + chart hints + key-value pairs in one call).
  22. - name: find_similar
  23. description: Find pages similar to a URL or concept. Hybrid cache (keyword search + embeddings) + optional web supplement.
  24. - name: research
  25. description: Multi-step research pipeline. Question decomposition, parallel sub-search, source synthesis with citations. Quick, standard, or comprehensive depth.
  26. - name: agent
  27. description: Natural-language data gathering. Plans searches/URLs, fetches in parallel within page and time budgets, optionally applies a JSON Schema to each page.
  28. - name: diff
  29. description: Compare two page versions — a live URL vs its cached copy, two URLs, or two markdown blobs. Unified patch, per-section hunks, or a counts summary at line, word, or section granularity.
  30. - name: watch
  31. description: Monitor a page for changes over time. Create lazy watch jobs on one or many URLs, list them, and check on demand with optional SSRF-guarded webhook delivery.
  32. ---
  33. # wigolo
  34. Local-first web intelligence MCP server for AI coding agents. Ships ten tools over stdio. All network results land in a local knowledge cache.
  35. ## Host-LLM synthesis (read me first)
  36. Wigolo has no internal LLM. It returns *structured evidence* so the calling model (you) writes the final answer. Fold structure into your reply rather than collapsing it away:
  37. - `search` with `format: "highlights"` — ML-scored passages + `citations`. Quote and cite [N].
  38. - `research` — when MCP sampling is unavailable (common), the output carries a `brief` with `topics`, `highlights`, `key_findings`. Use it as the scaffold for the report you write.
  39. - `find_similar` — may return a `cold_start` string. Pass it to the user; it explains why results came from the web and how to warm the cache.
  40. - `extract` with `mode: "structured"` — one call for tables + `<dl>` definitions + JSON-LD + chart hints + key-value pairs.
  41. - `fetch` metadata — surfaces `og_type`, `canonical_url`, and `og_image`; use `canonical_url` to dedupe tracked/canonical URLs.
  42. ## Quick Setup
  43. **Claude Code:**
  44. ```bash
  45. claude mcp add wigolo -- npx wigolo
  46. ```
  47. **Cursor / VS Code / any MCP client:**
  48. ```json
  49. {
  50. "mcpServers": {
  51. "wigolo": {
  52. "command": "npx",
  53. "args": ["wigolo"]
  54. }
  55. }
  56. }
  57. ```
  58. **Warmup (recommended, one-time):**
  59. ```bash
  60. npx wigolo warmup # installs browser engine + bootstraps search engine
  61. npx wigolo warmup --all # also installs Firefox, WebKit, ML reranker, and embeddings
  62. npx wigolo warmup --force # wipe search engine state and rebuild
  63. ```
  64. Warmup flags: `--force`, `--all`, `--reranker`, `--firefox`, `--webkit`, `--embeddings`, `--no-searxng`, `--verify`.
  65. ## Tools
  66. ### fetch
  67. Fetch a single URL and return clean markdown. Use when you already have a specific URL.
  68. Parameters:
  69. - `url` (string, required)
  70. - `render_js`: `"auto"` (default) | `"always"` | `"never"`
  71. - `use_auth`: boolean (default `false`) — reuses the user's browser session
  72. - `max_chars`: number
  73. - `section`: string — return only the content under a heading
  74. - `section_index`: number (default `0`) — which heading match when multiple hit
  75. - `screenshot`: boolean (default `false`)
  76. - `headers`: object
  77. - `force_refresh`: boolean — bypass cache
  78. - `actions`: array of `{type, selector, text, ms, timeout, direction, amount}` — `click`, `type`, `wait`, `wait_for`, `scroll`, `screenshot`. Forces browser rendering when present.
  79. Example:
  80. ```json
  81. { "url": "https://react.dev/reference/react/useState", "section": "Parameters" }
  82. ```
  83. Tip: `section` is much cheaper than reading the full page. Repeat fetches of the same URL are free from cache unless `force_refresh: true`.
  84. ### search
  85. Search the web and return extracted markdown per result. Use when you don't have a URL yet.
  86. Parameters:
  87. - `query` (string OR `string[]`, required) — array runs variants in parallel and dedupes
  88. - `max_results`: number (default `5`, cap `20`)
  89. - `include_content`: boolean (default `true`)
  90. - `content_max_chars`: number (default `30000`)
  91. - `max_total_chars`: number (default `50000`)
  92. - `time_range`: `"day"` | `"week"` | `"month"` | `"year"`
  93. - `include_domains` / `exclude_domains`: `string[]`
  94. - `from_date` / `to_date`: ISO `YYYY-MM-DD`
  95. - `category`: `"general"` | `"news"` | `"code"` | `"docs"` | `"papers"` | `"images"`
  96. - `language`: string
  97. - `search_engines`: `string[]` — override engine selection
  98. - `format`: `"full"` (default) | `"context"` (token-budgeted string) | `"highlights"` (ML-scored passages + citations) | `"answer"` (synthesized via MCP sampling; falls back to `highlights` when unsupported) | `"stream_answer"` (answer + phase progress notifications)
  99. - `max_highlights`: number (default `10`) — cap when `format: "highlights"`
  100. - `force_refresh`: boolean
  101. Example:
  102. ```json
  103. { "query": ["react server components patterns", "RSC data fetching", "react server components streaming"], "category": "docs", "include_domains": ["react.dev"], "max_results": 5 }
  104. ```
  105. Tip: keyword queries beat natural-language questions. A 3–5 item `query` array usually finds more unique sources than one longer query.
  106. ### crawl
  107. Crawl a site starting from a seed URL.
  108. Parameters:
  109. - `url` (string, required)
  110. - `strategy`: `"bfs"` (default) | `"dfs"` | `"sitemap"` | `"map"` (URL-only discovery, no content)
  111. - `max_depth`: number (default `2`)
  112. - `max_pages`: number (default `20`)
  113. - `include_patterns` / `exclude_patterns`: regex `string[]`
  114. - `use_auth`: boolean (default `false`)
  115. - `extract_links`: boolean (default `false`) — returns inter-page link graph
  116. - `max_total_chars`: number (default `100000`)
  117. Example:
  118. ```json
  119. { "url": "https://docs.python.org/3/library/", "strategy": "sitemap", "max_pages": 30, "include_patterns": ["^https://docs\\.python\\.org/3/library/asyncio"] }
  120. ```
  121. Tip: `strategy: "sitemap"` is faster and more complete than BFS on doc sites. `strategy: "map"` returns URLs only — cheap way to scope before targeted fetches.
  122. ### cache
  123. Search previously fetched content without hitting the network.
  124. Parameters:
  125. - `query`: full-text search — supports `AND`, `OR`, `NOT`, `"exact phrase"`
  126. - `url_pattern`: glob (e.g. `"*react.dev*"`)
  127. - `since`: ISO date
  128. - `stats`: boolean — returns total URLs, size, date range
  129. - `clear`: boolean — deletes matching entries (requires one of `query`, `url_pattern`, `since`)
  130. - `check_changes`: boolean — re-fetches matching URLs, reports changed/unchanged with diff summaries
  131. Example:
  132. ```json
  133. { "query": "useState OR useReducer", "url_pattern": "*react.dev*" }
  134. ```
  135. Tip: cache hits are instant and cross-session. Run this before `search` or `fetch` when you suspect the content is already on disk.
  136. ### extract
  137. Structured extraction from URL or raw HTML.
  138. Parameters:
  139. - `url` OR `html` (one required; `url` wins if both provided)
  140. - `mode`: `"metadata"` (default) | `"selector"` | `"tables"` | `"schema"` | `"structured"` (tables + `<dl>` definitions + JSON-LD + chart hints + microdata/data-attr/grid key-value pairs in one call)
  141. - `css_selector`: string — required for `mode: "selector"`
  142. - `multiple`: boolean (default `false`) — return all matches, selector mode only
  143. - `schema`: JSON Schema object with `properties` — required for `mode: "schema"`
  144. Example:
  145. ```json
  146. { "url": "https://example.com/product", "mode": "schema", "schema": { "type": "object", "properties": { "price": { "type": "string" }, "name": { "type": "string" }, "sku": { "type": "string" } } } }
  147. ```
  148. Tip: `mode: "schema"` does heuristic matching over CSS classes, ARIA labels, microdata, and JSON-LD — no LLM call required. `mode: "structured"` returns every structured pattern on the page (`tables`, `definitions`, `jsonld`, `chart_hints`, `key_value_pairs`) in one response — prefer it over chaining multiple extract calls.
  149. ### find_similar
  150. Find pages related to a URL or a free-text concept.
  151. Parameters:
  152. - `url` OR `concept` (one required)
  153. - `max_results`: number (default `10`, cap `50`)
  154. - `include_domains` / `exclude_domains`: `string[]`
  155. - `include_cache`: boolean (default `true`)
  156. - `include_web`: boolean (default `true`)
  157. Example:
  158. ```json
  159. { "url": "https://react.dev/reference/react/useState", "max_results": 8, "include_domains": ["react.dev", "developer.mozilla.org"] }
  160. ```
  161. Tip: uses hybrid 3-way RRF fusion — keyword search + semantic embeddings + live web search. Each result carries `match_signals` with `embedding_rank`, `fts5_rank`, and `fused_score`. If the cache is empty or embeddings aren't set up, the response includes a `cold_start` string — pass it to the user to explain why results came from the web.
  162. ### research
  163. Multi-step research pipeline with decomposition, parallel search, and cited synthesis.
  164. Parameters:
  165. - `question` (string, required)
  166. - `depth`: `"quick"` (~15s, 2 sub-queries, 5–8 sources) | `"standard"` (~40s, default) | `"comprehensive"` (~80s, 7 sub-queries, 20–25 sources)
  167. - `max_sources`: number (cap `50`) — overrides depth default
  168. - `include_domains` / `exclude_domains`: `string[]`
  169. - `schema`: JSON Schema — if present, report is structured to fill these fields
  170. - `stream`: boolean — emit progress notifications per phase
  171. Example:
  172. ```json
  173. { "question": "How do modern JS bundlers tree-shake ESM vs CJS?", "depth": "standard", "include_domains": ["webpack.js.org", "rollupjs.org", "esbuild.github.io", "vitejs.dev"] }
  174. ```
  175. Tip: `research` checks cache internally — no need to pre-probe. With MCP sampling, the tool synthesizes the report directly. Without sampling (the common case), the output ships a `brief` with `topics`, `highlights`, and `key_findings`, plus the raw sources — the host LLM writes the final report from the brief.
  176. ### agent
  177. Natural-language data gathering. Plans queries and URLs from a prompt, runs them in parallel within budget, optionally applies a schema.
  178. Parameters:
  179. - `prompt` (string, required)
  180. - `urls`: `string[]` — seed URLs to include
  181. - `schema`: JSON Schema — extract structured fields per page and merge
  182. - `max_pages`: number (default `10`, cap `100`)
  183. - `max_time_ms`: number (default `60000`, cap `600000`)
  184. - `stream`: boolean
  185. Example:
  186. ```json
  187. { "prompt": "Compare pricing tiers for Supabase, Firebase, and Clerk", "schema": { "type": "object", "properties": { "provider": { "type": "string" }, "free_tier": { "type": "string" }, "paid_start": { "type": "string" } } }, "max_pages": 12 }
  188. ```
  189. Tip: output includes a `steps` array showing every action (plan, search, fetch, extract, synthesize) with timings. Use this to debug why an agent run produced a weak result.
  190. ### diff
  191. Compare two versions of a page. Point it at a live URL and its cached copy, two URLs, or two markdown blobs.
  192. Parameters:
  193. - `old` (object, required): one of `{ url, markdown, content_hash }`
  194. - `new` (object, required): one of `{ url, markdown }`
  195. - `output`: `"unified"` (default), `"hunks"`, or `"summary"`
  196. - `granularity`: `"line"` (default), `"word"`, or `"section"`
  197. Example:
  198. ```json
  199. { "old": { "url": "https://docs.example.com/api" }, "new": { "url": "https://docs.example.com/api" }, "output": "hunks", "granularity": "section" }
  200. ```
  201. Tip: same URL on both sides diffs the cached copy against a fresh fetch. Use `output: "summary"` for counts only.
  202. ### watch
  203. Monitor a page for changes over time. Lazy execution — checks run when you call `check` or when an overdue job is picked up during another tool run.
  204. Parameters:
  205. - `action` (string, required): `"create"`, `"list"`, `"check"`, `"pause"`, `"resume"`, `"delete"`
  206. - `url` or `urls`: single-URL or batch create (mutually exclusive)
  207. - `interval_seconds`: required for create (min 60)
  208. - `selector`: create-only CSS selector to scope the diff
  209. - `notification`: `"inline"` (default) or an SSRF-guarded webhook URL
  210. - `job_id`: required for check/pause/resume/delete
  211. Example:
  212. ```json
  213. { "action": "create", "url": "https://nodejs.org/en/blog", "interval_seconds": 21600 }
  214. ```
  215. Tip: webhook destinations are SSRF-guarded — a job cannot be pointed at internal or loopback addresses.
  216. ## Workflow Patterns
  217. Quick routing:
  218. - Use when `search` — you need information but don't have a URL.
  219. - Use when `fetch` — you already have the URL.
  220. - Use when `crawl` — you need multiple pages from one site.
  221. - Use when `cache` — you want to check whether something is already on disk.
  222. - Use when `extract` — you need specific fields, tables, or metadata, not the whole page.
  223. - Use when `find_similar` — you have a good page/concept and want related content.
  224. - Use when `research` — a question needs decomposition and multi-source synthesis.
  225. - Use when `agent` — a natural-language task needs multi-step data gathering.
  226. - Use when `diff` — you need to see what changed between two versions of a page.
  227. - Use when `watch` — you want to monitor a page for changes over time.
  228. **Cache-first lookup.** Before any `fetch` or `search`, probe the cache.
  229. ```json
  230. cache({ "query": "oauth2 pkce", "url_pattern": "*auth0.com*" })
  231. // empty? fall through to search
  232. search({ "query": "oauth2 pkce flow", "include_domains": ["auth0.com"] })
  233. ```
  234. **Fresh content (news, dashboards, changelogs).** Bypass cache explicitly.
  235. ```json
  236. search({ "query": "node.js 22 release notes", "force_refresh": true, "time_range": "week" })
  237. fetch({ "url": "https://nodejs.org/en/blog", "force_refresh": true })
  238. ```
  239. **Scoped documentation research.** Crawl the relevant slice, then query cache.
  240. ```json
  241. crawl({ "url": "https://docs.astro.build", "strategy": "sitemap", "max_pages": 40 })
  242. cache({ "query": "server islands hydration", "url_pattern": "*docs.astro.build*" })
  243. ```
  244. **Broad exploration.** Pass a query array; dedup is automatic.
  245. ```json
  246. search({ "query": ["rust async runtimes comparison", "tokio vs async-std vs smol", "rust executor benchmarks"], "max_results": 8 })
  247. ```
  248. **More like this.** Start with a known-good URL, widen via `find_similar`.
  249. ```json
  250. find_similar({ "url": "https://react.dev/reference/react/useMemo", "max_results": 6, "include_domains": ["react.dev"] })
  251. ```
  252. **Complex synthesis.** One `research` call replaces 5+ manual search/fetch cycles.
  253. ```json
  254. research({ "question": "Tradeoffs of vector DBs for RAG at 100M+ embeddings", "depth": "comprehensive" })
  255. ```
  256. **Structured data from multiple sources.** Use `agent` with a schema.
  257. ```json
  258. agent({ "prompt": "Find latency and pricing for top 5 edge compute providers", "schema": { "type": "object", "properties": { "provider": {"type":"string"}, "cold_start_ms": {"type":"string"}, "price_per_million": {"type":"string"} } } })
  259. ```
  260. **Table extraction.** Skip markdown entirely.
  261. ```json
  262. extract({ "url": "https://en.wikipedia.org/wiki/List_of_programming_languages", "mode": "tables" })
  263. ```
  264. **One-shot structured brief.** Tables + definition lists + JSON-LD + chart hints + key-value pairs in one call.
  265. ```json
  266. extract({ "url": "https://example.com/product-page", "mode": "structured" })
  267. ```
  268. **Direct quotes with citations.** ML-scored passages are ideal for host-LLM synthesis.
  269. ```json
  270. search({ "query": "react server components data fetching", "format": "highlights", "max_highlights": 6, "include_domains": ["react.dev", "nextjs.org"] })
  271. ```
  272. ## Parameter Cheat Sheet
  273. | Situation | Tool + parameters |
  274. |---|---|
  275. | Focused lookup, known site | `search` + `max_results: 3` + `include_domains` |
  276. | Broad topic survey | `search` + `query: [...3-5 variants]` + `max_results: 8` |
  277. | Fresh content required | any tool + `force_refresh: true` |
  278. | Doc site indexing | `crawl` + `strategy: "sitemap"` |
  279. | Site URL inventory only | `crawl` + `strategy: "map"` |
  280. | Single heading from long page | `fetch` + `section: "..."` |
  281. | Behind login | `fetch` / `crawl` + `use_auth: true` |
  282. | Direct answer (sampling client) | `search` + `format: "answer"` |
  283. | ML-scored passages + citations | `search` + `format: "highlights"` |
  284. | LLM-ready context blob | `search` + `format: "context"` |
  285. | Complex question, multi-source | `research` + `depth: "standard"` |
  286. | Structured multi-page extraction | `agent` + `schema` |
  287. | One-page structured data | `extract` + `mode: "structured"` (everything) or `"schema"` / `"tables"` (targeted) |
  288. | Change tracking | `cache` + `check_changes: true` |
  289. ## Anti-Patterns
  290. **Do not skip the cache.** Running `search` or `fetch` without probing `cache` wastes time on content already on disk. `research` and `agent` check cache internally; manual `search`/`fetch` do not.
  291. **Do not send natural-language questions to `search`.** Use keywords. `"how do I debounce in React hooks"` loses to `"react useDebounce hook custom"`.
  292. **Do not retry an identical failing query.** Reformulate keywords, swap `category`, or add `include_domains`. Same query → same empty result.
  293. **Do not use `agent` or `research` for one-URL lookups.** Use `fetch`. `agent` is for multi-source gathering; `research` is for decomposable questions.
  294. **Do not crawl `max_pages: 100` without filters.** Always add `include_patterns` to stay in-scope. Unfiltered crawls fetch nav, footer, and sitemap garbage.
  295. **Do not fetch whole pages when you need one section.** `fetch` + `section` reads under one heading only.
  296. **Do not set `force_refresh: true` by default.** It defeats the cache. Use it for news, status, changelogs — content that actually churns.
  297. **Do not pass a JSON Schema to `extract` without `properties`.** The handler rejects schemas that lack a `properties` key.
  298. ## CLI Commands
  299. ```bash
  300. wigolo # default: start MCP server on stdio
  301. wigolo mcp # explicit: start MCP server
  302. wigolo warmup [flags] # install browser engine, bootstrap search engine, optional extras
  303. wigolo serve # start HTTP daemon on WIGOLO_DAEMON_PORT (default 3333)
  304. wigolo health # health probe, exits 0 if ok
  305. wigolo doctor # environment diagnostics
  306. wigolo auth discover # list CDP sessions (needs WIGOLO_CDP_URL)
  307. wigolo auth status # show configured auth paths
  308. wigolo plugin add <git-url> # clone plugin into ~/.wigolo/plugins/
  309. wigolo plugin list # list installed plugins
  310. wigolo plugin remove <name> # remove a plugin
  311. wigolo shell [--json] # interactive REPL against subsystems
  312. ```
  313. ## Configuration
  314. Top environment variables. All optional — defaults are safe.
  315. | Variable | Default | Purpose |
  316. |---|---|---|
  317. | `WIGOLO_DATA_DIR` | `~/.wigolo` | Cache DB, search engine state, plugins, embeddings |
  318. | `WIGOLO_SEARXNG_URL` | unset | Point at an existing search engine (skips native bootstrap); legacy `SEARXNG_URL` also accepted |
  319. | `SEARXNG_MODE` | `native` | `native` runs local Python search engine; `docker` runs container |
  320. | `WIGOLO_CHROME_PROFILE_PATH` | unset | Chrome profile for `use_auth: true` |
  321. | `WIGOLO_CDP_URL` | unset | Chrome DevTools endpoint (e.g. `http://localhost:9222`) |
  322. | `MAX_BROWSERS` | `3` | Browser pool size |
  323. | `WIGOLO_BROWSER_TYPES` | `chromium` | Comma list: `chromium,firefox,webkit` |
  324. | `WIGOLO_RERANKER` | `none` | `flashrank` for ML reranking |
  325. | `WIGOLO_EMBEDDING_MODEL` | `BAAI/bge-small-en-v1.5` | Used by `find_similar` |
  326. | `CACHE_TTL_CONTENT` | `604800` (7d) | Seconds before cached pages expire |
  327. | `LOG_LEVEL` | `info` | `debug` \| `info` \| `warn` \| `error` |
  328. Full list: see `src/config.ts`.
  329. ## Links
  330. - Repository: https://github.com/KnockOutEZ/wigolo
  331. - npm: https://www.npmjs.com/package/wigolo
  332. - License: GNU AGPL-3.0-only — free to use, modify, and self-host; see the root LICENSE
README.md · README · 445 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. <img alt="wigolo — the go-to web for your agent" src="assets/brand/wigolo-banner.png" width="640">
  3. Local-first web intelligence for AI agents — **no keys, no cloud, no metered bill.**
  4. <sub>works with&nbsp;&nbsp;**Claude Code · Cursor · Codex · Gemini CLI · OpenCode · VS Code · Windsurf · Zed · Antigravity**</sub>
  5. <br>
  6. <sub>and beyond&nbsp;&nbsp;**LangChain · CrewAI · LlamaIndex · Vercel AI SDK · n8n & self-hosted agents · any MCP client · plain REST**</sub>
  7. [![npm](https://img.shields.io/npm/v/wigolo?color=cb3837&logo=npm)](https://www.npmjs.com/package/wigolo)
  8. [![npm downloads](https://img.shields.io/npm/dm/wigolo?color=cb3837&logo=npm&label=downloads)](https://www.npmjs.com/package/wigolo)
  9. [![GitHub stars](https://img.shields.io/github/stars/KnockOutEZ/wigolo?style=flat&logo=github&color=e3b341)](https://github.com/KnockOutEZ/wigolo/stargazers)
  10. [![CI](https://img.shields.io/github/actions/workflow/status/KnockOutEZ/wigolo/ci.yml?branch=main&logo=github&label=CI)](https://github.com/KnockOutEZ/wigolo/actions/workflows/ci.yml)
  11. [![node](https://img.shields.io/badge/node-%E2%89%A520-339933?logo=node.js&logoColor=white)](https://nodejs.org)
  12. [![MCP](https://img.shields.io/badge/MCP-server-7c3aed)](https://modelcontextprotocol.io)
  13. [![license](https://img.shields.io/badge/license-AGPL--3.0-2563eb)](#license)
  14. [![status](https://img.shields.io/badge/status-public%20beta-b7791f)](#beta--feedback)
  15. [![follow on X](https://img.shields.io/badge/follow-%40yourtowhid-000000?logo=x&logoColor=white)](https://x.com/yourtowhid)
  16. [![Discord](https://img.shields.io/badge/Discord-join%20the%20community-5865F2?logo=discord&logoColor=white)](https://discord.gg/BkUUgz2bNF)
  17. <a href="https://trendshift.io/repositories/79424?utm_source=repository-badge&utm_medium=badge&utm_campaign=badge-repository-79424" target="_blank"><img src="https://trendshift.io/api/badge/repositories/79424" alt="wigolo on Trendshift" width="250" height="55"/></a>
  18. <a href="https://trendshift.io/repositories/79424?utm_source=trendshift-badge&utm_medium=badge&utm_campaign=badge-trendshift-79424" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/79424/daily?language=TypeScript" alt="KnockOutEZ%2Fwigolo | Trendshift" width="250" height="55"/></a>
  19. <sub>sponsored by</sub><br>
  20. <a href="https://wigolo.app/go/testmu/?ref=readme-top"><picture><source media="(prefers-color-scheme: dark)" srcset="assets/sponsors/testmu-ai-dark.svg"><img alt="TestMu AI" src="assets/sponsors/testmu-ai.svg" height="20"></picture></a>
  21. [Quickstart](#quickstart) · [Tools](#tools) · [Why wigolo](#why-its-different) · [Discord](https://discord.gg/BkUUgz2bNF) · [Sponsors](#sponsors) · [Benchmark](#benchmark) · [Docs](docs/README.md) · [Examples](examples/README.md) · [Licensing](LICENSING.md) · [Feedback](#beta--feedback) · [FAQ](#faq)
  22. **Join the community on [Discord](https://discord.gg/BkUUgz2bNF)** — questions, help, and what's being built next.
  23. New features and updates ship steadily. Follow <a href="https://x.com/yourtowhid"><b>@yourtowhid on X</b></a> for all of it and new ways to use wigolo, and reach out there for collaborations or feedback · also on <a href="https://www.linkedin.com/in/yourtowhid/">LinkedIn</a>
  24. </div>
  25. ---
  26. wigolo gives an AI agent one surface for everything web-related: **search, fetch, crawl, extract, cache, find-similar, research,** and autonomous gather loops. It runs wherever your agent runs — as an MCP server next to your coding agent, as a REST/MCP endpoint on the box where your self-hosted agents live, or embedded through an SDK inside your own app. The core tools need no API keys, nothing it touches leaves `~/.wigolo/`, and no bill grows with how much your agent thinks.
  27. <div align="center">
  28. <img alt="wigolo demo — Claude Code answering a live web question through wigolo, no API keys" src="assets/wigolo-demo.gif" width="800">
  29. </div>
  30. ## Quickstart
  31. ```bash
  32. npx wigolo init # set up the local engine — any system
  33. npx wigolo init --agents=claude-code,cursor # …or set up + wire your day-to-day agents in one command
  34. ```
  35. Requires **Node ≥ 20** and ~1.5 GB of free disk on macOS, Linux, or Windows. Bare `init` sets up the local engine: it downloads the browser engine and on-device models, runs a health check, and reports each component. Adding `--agents` wires the named agents in the same run, so a coding agent you use daily is ready in one command.
  36. - **Supported agents** — `--agents` takes any of `claude-code` · `cursor` · `codex` · `gemini-cli` · `opencode` · `vscode` · `windsurf` · `zed` · `antigravity` (comma-separated); wigolo writes the MCP config and, where supported, instructions for each.
  37. - **Any other setup** — any MCP client, agent framework, or self-hosted agent registers `npx -y wigolo` in its own MCP config. The [installation guide](docs/installation.md) has the exact config block for every client, plus Docker, Homebrew, and single-file-binary channels.
  38. - **More on the way** — the supported list keeps growing, and a PR to add your agent is welcome; see [CONTRIBUTING.md](CONTRIBUTING.md).
  39. - **Interactive setup** — `--interactive` is a plain-text flow; `--wizard` is the full terminal TUI.
  40. - **Defer downloads** — `--no-warmup` waits until first use. A failed component download never fails setup; init reports what's not ready with the exact fix and still completes.
  41. `init` is unattended by default, so it's safe in scripts and CI, and any setup problem surfaces right here in the per-component report, before your agent's first call. **Search, fetch, crawl, extract, cache, and find-similar work with no API key.** Check it's healthy anytime:
  42. ```bash
  43. npx wigolo doctor
  44. ```
  45. To remove everything cleanly, run `npx wigolo config --uninstall --yes`. You can also paste the [installation guide](docs/installation.md) into any AI assistant and let it do the setup; it's written to be self-contained.
  46. ### Recommended — a free key for `research` & `agent`
  47. Search, fetch, crawl, extract, cache, and find-similar are **fully keyless**. `research`, `agent`, and `search format=answer` use an LLM to write the synthesized, cited answer. Without one they hand back a raw brief and evidence for your agent to assemble. A free Gemini key turns that into a finished answer:
  48. ```bash
  49. export WIGOLO_LLM_PROVIDER=gemini
  50. export GEMINI_API_KEY=<free-key> # grab one at aistudio.google.com/apikey — the free tier is plenty
  51. ```
  52. Any provider works (`anthropic` · `openai` · `groq`), or stay fully local and keyless with `WIGOLO_LLM_PROVIDER=ollama` (or any OpenAI-compatible URL). Set it in your shell or your agent's MCP `env` block. Providers, models, and the keyless local-model ladder are in the [configuration guide](docs/configuration.md).
  53. ## What your agent gets back
  54. Every search result is evidence the agent can act on. It carries a verbatim excerpt pinned to its exact position in the source, a citation ID the agent can quote, and a score it can inspect (abridged real shape):
  55. ```jsonc
  56. {
  57. "results": [{
  58. "title": "Logical replication - PostgreSQL docs",
  59. "url": "https://www.postgresql.org/docs/current/logical-replication.html",
  60. "excerpt": "Logical replication is a method of replicating data objects…",
  61. "citation_id": "src-1",
  62. "source_span": { "start": 1042, "end": 1305 }, // byte-exact provenance
  63. "evidence_score": { "final": 0.86, "semantic": 0.91, "lexical": 0.78, "engine_consensus": 3 }
  64. }],
  65. "citations": [{ "id": "src-1", "url": "…" }],
  66. "freshness_signal": { "published": "2026-05-12", "confidence": "high" }
  67. }
  68. ```
  69. Weak results get flagged as junk by wigolo's own scorer. Failed engines are reported and stale cache is labeled, so the agent always knows what it's standing on. Full response contracts per tool are in the [tools reference](docs/tools.md).
  70. ## Tools
  71. | Tool | What it does |
  72. |------|--------------|
  73. | 🔎 `search` | Multi-engine web search (18 direct adapters) with rank fusion, ML reranking, and an explainable per-result score. Pass a query **array** for parallel breadth. Scope by domain and time range, match an exact phrase, or return image results. |
  74. | 📄 `fetch` | Load one URL through a tiered router that auto-escalates from plain HTTP to a headless browser engine on anti-bot challenges or SPA shells. Clean markdown + metadata + links. Handles PDFs, a single-heading `section`, authenticated sessions, and page actions (click / type / scroll / screenshot). |
  75. | 🕸️ `crawl` | Multi-page crawl — BFS, DFS, sitemap, or map-only. Per-domain rate limits, robots.txt respect, boilerplate dedup. |
  76. | 🧩 `extract` | Structured data from a page: tables, metadata, JSON-LD, brand identity, named schemas (Article / Recipe / Product / …), or any custom JSON Schema. |
  77. | 💾 `cache` | Query everything already seen — keyword or hybrid semantic. Plus stats, clear, and change detection. |
  78. | 🧲 `find_similar` | Pages similar to a URL or a concept, via 3-way fusion of keyword + semantic + live web. |
  79. | 🧠 `research` | Decompose a question → fan out sub-queries → fetch sources → synthesize a cited report (or a structured brief the host LLM writes from). |
  80. | 🤖 `agent` | Autonomous gather loop: plan → search → fetch → extract → synthesize, with a step log, time budget, and optional output schema. |
  81. | 🔁 `diff` + ⏱️ `watch` | See exactly what changed on a page since last visit; re-check on demand and deliver changes to a webhook. |
  82. Every tool also runs from the terminal (`wigolo search "…" --json`), from an interactive shell with NDJSON piping (`wigolo shell`), over REST, and through the SDKs — [CLI reference](docs/cli.md). Per-tool guides with the full parameter set are in [docs/tools.md](docs/tools.md); runnable examples are in [examples/](examples/README.md).
  83. ## Why it's different
  84. wigolo isn't a free stand-in for the paid tools — it's built to match them. It's a focused web layer for your agents: an MCP and REST surface they call directly, with the search and extraction quality the paid services charge for. What separates it:
  85. - **Built for agents.** One MCP call fans out many queries across many engines in parallel, which a serial host tool-loop can't replicate. Every result carries transparent per-result scoring, and output is budget-aware.
  86. - **Honest output.** Stale cache, failed fetches, degraded backends, and truncation are surfaced in the result. When a bot-protected page can't be read, you get a labeled `blocked_by_challenge` failure, not a challenge shell returned as content.
  87. - **$0 per query, free to re-query.** Default search talks to public engines through direct adapters; the reranker and embeddings run on-device. Every response is cached, so asking again is instant and costs nothing.
  88. - **Private by default.** Cache, embeddings, models, and config live under `~/.wigolo/`. Nothing reaches a third party unless you explicitly opt into an LLM for synthesis.
  89. Here's what one real result looks like, dissected. It includes the failed engine and the weak result, because those are part of the answer too:
  90. <div align="center">
  91. <picture>
  92. <source media="(prefers-color-scheme: dark)" srcset="assets/promo/anatomy-dark.svg">
  93. <img alt="Anatomy of a wigolo result: explainable score decomposition, live engine telemetry, surfaced degradation, self-flagged junk — one real query, captured live" src="assets/promo/anatomy.svg" width="880">
  94. </picture>
  95. </div>
  96. ## Benchmark
  97. > **All four tools converged on the same core answer, and only one of them handed back verbatim, byte-pinned evidence while doing it.**
  98. One cold query ran live inside a single **Claude Fable 5** session, fanned out to four web tools on equal footing (built-in **WebSearch**, **wigolo**, **Tavily**, **Exa**), and was judged by the agent on the evidence alone. All four converged on the same answer and the same top source, so the parity is demonstrated on-screen. wigolo alone returned verbatim excerpts pinned to byte-offset source spans, an explainable score decomposition, and live per-engine telemetry, and its own scorer flagged two weak results as junk. The cloud tools earn their place too: Exa rendered the official docs' comparison matrix in full. Run your own query and you'll see the same shape.
  99. <div align="center">
  100. <img alt="wigolo vs built-in WebSearch, Tavily, and Exa on one real query, driven by Claude Fable 5" src="assets/wigolo-vs.gif" width="900">
  101. </div>
  102. ### How it compares
  103. | | wigolo | Firecrawl | Exa | Tavily |
  104. |---|:---:|:---:|:---:|:---:|
  105. | Multi-engine web search | ✅ | ✅ | ✅ | ✅ |
  106. | Fetch & structured extraction | ✅ | ✅ | ✅ | ✅ |
  107. | Whole-site crawl & map | ✅ | ✅ | — | ✅ |
  108. | Verbatim excerpts pinned to byte-offset source spans | ✅ | — | — | — |
  109. | Explainable per-result score decomposition | ✅ | — | — | — |
  110. | Persistent local memory — re-query instantly, offline | ✅ | — | — | — |
  111. | Query data stays on your machine | ✅ | — | — | — |
  112. | API key / account | none | required | required | required |
  113. | Cost per query | $0 | metered | metered | metered |
  114. <sub>Feature standing as of July 2026 — check each vendor's docs for current state.</sub>
  115. That last row compounds, because agents ask in bursts:
  116. <div align="center">
  117. <picture>
  118. <source media="(prefers-color-scheme: dark)" srcset="assets/promo/meter-dark.svg">
  119. <img alt="The meter: a metered cloud API's cost climbs with every query while wigolo stays flat at zero dollars — illustrative pricing" src="assets/promo/meter.svg" width="880">
  120. </picture>
  121. </div>
  122. ## Beyond your editor
  123. The same ten tools serve every kind of agent, over whichever surface fits: MCP for coding agents, REST for everything else, SDKs to embed, and framework wrappers to drop in.
  124. ### REST API — `wigolo serve`
  125. One process exposes a plain-JSON REST API next to the MCP transport. No MCP client needed, just curl:
  126. ```bash
  127. wigolo serve # 127.0.0.1:3333 — loopback is open; off-loopback requires a token
  128. curl -sX POST http://127.0.0.1:3333/v1/search \
  129. -H 'Content-Type: application/json' \
  130. -d '{"query":"local-first software","max_results":5}'
  131. ```
  132. `POST /v1/{tool}` covers all ten tools, `GET /openapi.json` is the OpenAPI 3.1 contract, and `/mcp` + `/sse` serve remote MCP clients from the same port. Bind past loopback and a bearer token is required, so the server fails closed by default. Point n8n, a Hermes-style assistant, or any self-hosted agent at it. → [REST API](docs/rest-api.md)
  133. ### SDKs — TypeScript & Python
  134. Thin, typed clients with an embedded local mode that finds or starts the daemon for you. No separate `serve` step.
  135. **TypeScript** — `npm install wigolo-sdk` (zero-dep; Node / Bun / Deno / edge):
  136. ```ts
  137. import { createLocalClient } from 'wigolo-sdk/local';
  138. const { client, close } = await createLocalClient(); // reuse a running daemon, or spawn one
  139. const res = await client.search({ query: 'local-first web search', max_results: 5 });
  140. console.log(res.results.map((r) => r.title));
  141. await close(); // stops the daemon only if this call spawned it
  142. ```
  143. **Python** — `pip install wigolo` (standard library only; sync + async):
  144. ```python
  145. from wigolo import local_client
  146. with local_client() as client: # reuse a healthy daemon, or spawn one
  147. res = client.search(query="local-first web search", max_results=5)
  148. for r in res["results"]:
  149. print(r["title"], r["url"])
  150. ```
  151. → [SDKs & embedded mode](docs/sdks.md)
  152. ### Framework integrations
  153. Drop wigolo's tools into the framework you already use. You get the full ten-tool surface, including the cache / find_similar / research / agent that most framework web-tools don't ship:
  154. | Framework | Package | What you get |
  155. |-----------|---------|--------------|
  156. | **LangChain** | `wigolo-langchain` | each tool as a `BaseTool`, plus a `BaseRetriever` over search / find_similar for RAG |
  157. | **CrewAI** | `wigolo-crewai` | `wigolo_tools()` → hand the set to any crew |
  158. | **LlamaIndex** | `wigolo-llamaindex` | a `BaseReader` that loads fetched / crawled / searched pages as documents |
  159. | **Vercel AI SDK** | `wigolo-vercel-ai-sdk` | tool factories for `generateText` / `streamText`, edge-friendly |
  160. → [Framework integrations](docs/sdks.md)
  161. ### Docker
  162. ```bash
  163. # stdio MCP — wire it into any MCP client as command: docker
  164. docker run -i --rm -v wigolo-data:/data ghcr.io/knockoutez/wigolo
  165. # HTTP server for remote / multi-client use
  166. docker run -p 3333:3333 -v wigolo-data:/data \
  167. -e WIGOLO_API_TOKEN=a-long-random-secret \
  168. ghcr.io/knockoutez/wigolo serve --host 0.0.0.0
  169. ```
  170. The slim image lazy-loads models into the volume; `ghcr.io/knockoutez/wigolo:latest-full` preinstalls the browser engine. Versioned releases use the same `-full` suffix (for example, `0.3.1-full`). Also on Docker Hub as `towhid69420/wigolo`. → [installation & all channels](docs/installation.md)
  171. ### Agent skills
  172. An 11-pack skill catalog teaches your coding agent to drive each tool well. It's installed by `init` and managed with `wigolo skills add|list|remove`. → [skills](docs/skills.md)
  173. One note for self-hosters: some challenge-protected sites score IP reputation, so a datacenter IP won't clear walls a home connection would. wigolo labels those failures, and the [self-hosting guide](docs/self-hosting.md) covers the opt-in proxy answer.
  174. ## Star history
  175. <div align="center">
  176. <a href="https://www.star-history.com/#KnockOutEZ/wigolo&Date">
  177. <picture>
  178. <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/KnockOutEZ/wigolo/star-chart/star-history-dark.svg">
  179. <img alt="wigolo GitHub stars over time" src="https://raw.githubusercontent.com/KnockOutEZ/wigolo/star-chart/star-history.svg" width="880">
  180. </picture>
  181. </a>
  182. <sub>Refreshed daily from the GitHub API. <a href="https://github.com/KnockOutEZ/wigolo">Add a ⭐</a> if wigolo is useful to you.</sub>
  183. </div>
  184. ## Architecture
  185. A single Node process speaks MCP (JSON-RPC over stdio). Everything heavy is local and lazy-loaded, so a zero-key install pays nothing for the parts it isn't using.
  186. ```mermaid
  187. flowchart TD
  188. A["🤖 AI agent<br/>any MCP client · REST · SDK"]
  189. A -->|MCP over stdio| B["<b>wigolo</b><br/>10 tools · dynamic instructions<br/>in-process browser pool + cache + models"]
  190. B --> C{"Tool layer"}
  191. C --> T1["search · fetch · crawl · extract"]
  192. C --> T2["cache · find_similar · research · agent"]
  193. T1 --> F["⚙️ Fetch router<br/>tiered escalation, learned per domain"]
  194. T1 --> S["⚙️ Search<br/>18 engines → rank fusion → ML rerank<br/><i>explainable evidence score</i>"]
  195. T2 --> DB[("🗄️ Local cache<br/>keyword + vector index")]
  196. T2 --> ML["🧠 On-device ML<br/>embeddings + reranker"]
  197. F -.->|optional| LLM["☁️ LLM<br/>synthesis only · opt-in"]
  198. S -.->|optional| SX["🔀 Aggregator backend<br/>opt-in legacy / hybrid"]
  199. F --> WEB["🌍 Public web"]
  200. S --> WEB
  201. style B fill:#7c3aed,stroke:#5b21b6,color:#fff
  202. style WEB fill:#0ea5e9,stroke:#0369a1,color:#fff
  203. style DB fill:#1e293b,stroke:#334155,color:#fff
  204. style LLM stroke-dasharray: 5 5
  205. style SX stroke-dasharray: 5 5
  206. ```
  207. - **Code beats model.** Deterministic work stays off the LLM: canonicalization, rank fusion, dedup, and schema matching. The model is reserved for judgment, opt-in, and capped per request. LLM-filled fields are checked against the source and nulled if absent.
  208. - **Signal-driven routing.** The fetch ladder escalates to a real browser on observable signals, not domain guesses: SPA markers, challenge bodies, thin content. It learns per domain, unlearns when a site stops needing it, and `wigolo tune list` shows you exactly what it learned.
  209. - **Reads pages the way a browser does.** Tiered fetching waits out interstitial challenges and reuses clearances per domain, politely: robots.txt respected, per-domain rate limits, research-grade volumes. When a wall stays up, the failure is labeled and reported.
  210. ## Configuration
  211. A clean install works out of the box. Three settings raise output quality:
  212. ```bash
  213. # 1. Synthesis — the biggest lever (research / agent / search-answer write real prose)
  214. export WIGOLO_LLM_PROVIDER=gemini # or anthropic / openai / groq / ollama (keyless)
  215. export GEMINI_API_KEY=<your-key>
  216. # 2. Wider retrieval funnel
  217. export WIGOLO_SEARCH=hybrid # core engines + aggregator fallback
  218. export WIGOLO_GITHUB_TOKEN=... # GitHub code search 10 → 30 req/min
  219. # 3. Land more fetches, stay warm
  220. export WIGOLO_TLS_TIER=auto # per-domain learned fetch hardening
  221. export WIGOLO_EAGER_WARMUP=1 # pay the ~1s model load up front
  222. ```
  223. **Per-call habits that pay off:** query **arrays** (`["a","b","c"]`) for parallel breadth · `search_depth: "deep"` for queries that matter · `include_domains` as a hard filter for docs lookups. The full reference covers every environment variable, config-file key, search backend, cache TTL, and serve limit; it's in the [configuration guide](docs/configuration.md).
  224. ## Docs & examples
  225. **[docs/](docs/README.md)** — the complete manual:
  226. [getting started](docs/getting-started.md) · [installation & channels](docs/installation.md) · [configuration](docs/configuration.md) · [tools reference](docs/tools.md) · [CLI & shell](docs/cli.md) · [REST API](docs/rest-api.md) · [SDKs & integrations](docs/sdks.md) · [self-hosting](docs/self-hosting.md) · [agent skills](docs/skills.md) · [plugins](docs/plugins.md) · [troubleshooting & FAQ](docs/troubleshooting.md) · [privacy & security](docs/privacy-security.md)
  227. **[examples/](examples/README.md)** — runnable, each with a README (and most with a terminal recording): one-shot CLI, NDJSON shell pipelines, REST via curl, TypeScript & Python SDKs, Vercel AI SDK tools, pointing self-hosted n8n at a remote wigolo, watch-with-webhook, and writing your own search-engine plugin. The docs are also rendered on the site at **[wigolo.app/docs](https://wigolo.app/docs/)**.
  228. ## Beta & feedback
  229. wigolo is in **public beta**. Everything documented here works and is held to a 7,600-test suite; it's stable, and beta is about the polish bar. It stays beta until enough people have used it, kicked it, and starred it that calling it v1 means something. Your feedback shapes what comes next, and every report is read, usually the same day:
  230. - 🐛 **[Report a bug](https://github.com/KnockOutEZ/wigolo/issues/new?template=bug_report.yml)** — broke, misbehaved, surprised you
  231. - 💡 **[Request a feature](https://github.com/KnockOutEZ/wigolo/issues/new?template=feature_request.yml)** — something it should do
  232. - 💬 **[Ask anything](https://github.com/KnockOutEZ/wigolo/discussions)** — questions, setups, show & tell
  233. If wigolo earns a place in your setup, three things keep it going: a ⭐ **star** (it's how open source gets found), a **[☕ coffee](https://buymeacoffee.com/knockoutez)** (the open-source version is the full product; commercial licenses fund it, not gated features), or **[an email](mailto:ktowhid20@gmail.com)** that goes straight to the one developer who wrote the code.
  234. ## Troubleshooting
  235. `wigolo doctor` names any broken component and the exact env var or command that fixes it; `wigolo doctor --fix` repairs the common cases, and `wigolo verify` health-checks every component. A component failing during `init` doesn't break wigolo: `init` still exits 0, and core search / fetch / crawl / extract / cache work with no models and no browser. Quick hits:
  236. - **Slow or failed downloads** — re-run `wigolo warmup --all` (or `--browser` / `--embeddings` / `--reranker`); they resume and retry.
  237. - **Browser won't launch on Linux** — `wigolo warmup --browser` installs the OS libraries (or prints the exact command).
  238. - **Native build error / unusual Node** — use an LTS — **Node 22 or 24** — or Node 26 (supported; Current until it becomes LTS).
  239. - **Behind a proxy** — `USE_PROXY=true` + `PROXY_URL`; add `NODE_EXTRA_CA_CERTS` for TLS-inspecting proxies.
  240. - **Your agent asks permission on every call** — allow the tools in your client, then restart it; rules are read at session start. [Details](docs/troubleshooting.md#your-agent-keeps-asking-permission).
  241. The full guide covers per-symptom fixes, a "what still works when X fails" map, platform notes (incl. linux-arm64), and offline installs: **[docs/troubleshooting.md](docs/troubleshooting.md)**.
  242. ## FAQ
  243. <details>
  244. <summary><b>Free? What's the catch?</b></summary>
  245. No catch by design. The expensive parts (ranking, embeddings, the browser engine) run on *your* hardware, so there's no per-query cost to recover and no reason for a meter. It's funded by commercial licenses and sponsors, and the AGPL legally prevents a switch into a closed hosted product.
  246. </details>
  247. <details>
  248. <summary><b>Is the quality really on par with the paid services?</b></summary>
  249. The benchmark section above is a live 4-way run you can reproduce: everyday agent queries land at parity, the paid tools still win some deep-extraction edge cases, and crawling is where wigolo is strongest. Every result shows its scoring, so you don't have to take anyone's word for it.
  250. </details>
  251. <details>
  252. <summary><b>Won't public search engines block or rot?</b></summary>
  253. It's engineered for exactly that: 18 engines fused with rank fusion (any one failing barely moves results), a tiered fetch ladder with per-domain learning, and an optional aggregator fallback. Degraded backends are *reported in the output*, and the local cache means everything already seen keeps working regardless.
  254. </details>
  255. <details>
  256. <summary><b>Is this kind of scraping OK?</b></summary>
  257. wigolo reads the public web the way a browser does: robots.txt respected by default, per-domain rate limits, and research-grade volumes for one agent on one machine. It sits deliberately at the polite end of the spectrum.
  258. </details>
  259. <details>
  260. <summary><b>Can I use this at work?</b></summary>
  261. Yes. If you're a company or building a commercial product on wigolo, please take a commercial license or sponsor the project. See [LICENSING.md](LICENSING.md).
  262. </details>
  263. <details>
  264. <summary><b>Why 1.5 GB of disk?</b></summary>
  265. That's the on-device brain: a full browser engine plus the ranking and embedding models the cloud services run on their side and bill you for. Once it's on disk, every query uses it for free.
  266. </details>
  267. ## Available on
  268. - **npm** — [`wigolo`](https://www.npmjs.com/package/wigolo) *(primary channel — the Quickstart above)*
  269. - **PyPI** — [`wigolo`](https://pypi.org/project/wigolo/) *(Python SDK)*
  270. - **Docker** — [`ghcr.io/knockoutez/wigolo`](https://github.com/KnockOutEZ/wigolo/pkgs/container/wigolo) · [`towhid69420/wigolo`](https://hub.docker.com/r/towhid69420/wigolo)
  271. - **Official MCP Registry** — `io.github.KnockOutEZ/wigolo`
  272. - **Directories** — [Glama](https://glama.ai/mcp/servers/KnockOutEZ/wigolo) · [Smithery](https://smithery.ai/server/ktowhid20/wigolo) · [mcp.so](https://mcp.so/server/wigolo/KnockOutEZ) · [LobeHub](https://lobehub.com/mcp/knockoutez-wigolo)
  273. Homebrew, `curl | sh`, and the single-file binary are covered in the [installation guide](docs/installation.md). Use one channel per machine; they all share `~/.wigolo`.
  274. ## Sponsors
  275. Thank you to the sponsors below, who help keep wigolo maintained and free for everyone to use. Their support goes straight into the work.
  276. <div align="center">
  277. <a href="https://wigolo.app/go/testmu/?ref=readme">
  278. <picture>
  279. <source media="(prefers-color-scheme: dark)" srcset="assets/sponsors/testmu-ai-dark.svg">
  280. <img alt="TestMu AI" src="assets/sponsors/testmu-ai.svg" height="32">
  281. </picture>
  282. </a>
  283. <sub>**[TestMu AI](https://wigolo.app/go/testmu/?ref=readme)** (formerly LambdaTest) is the world's first full-stack agentic AI quality engineering platform, trusted by 18,000+ enterprises.</sub>
  284. </div>
  285. **wigolo is free for everyone.** If you or your company would like to help keep it maintained, there's room for more sponsors — reach out at **[ktowhid20@gmail.com](mailto:ktowhid20@gmail.com)**, or see [what sponsorship includes](https://wigolo.app/sponsors/) and the terms in [SPONSORS.md](SPONSORS.md). A one-off via [Buy Me a Coffee](https://buymeacoffee.com/knockoutez) is welcome too.
  286. ## Contributing
  287. Bug reports, feature requests, and PRs are all welcome; see **[CONTRIBUTING.md](CONTRIBUTING.md)**. Keep tool handlers thin, add tests, and run the suite before opening a PR. The friendliest entry point is the plugin system for custom search engines and extractors: [add a search engine in ~100 lines](docs/plugins.md), with a template in [`examples/plugin-search-engine`](examples/plugin-search-engine).
  288. ## License
  289. Free and open source under the **[GNU AGPL-3.0](LICENSE)**, and it'll stay that way. If you're a company, or you're making money with wigolo, please take a commercial license or sponsor the project. That's what keeps it maintained. See **[LICENSING.md](LICENSING.md)**.
  290. See **[SECURITY.md](SECURITY.md)** to report a vulnerability and **[TRADEMARK.md](TRADEMARK.md)** for use of the name.
  291. <div align="center">
  292. <br>
  293. wigolo is open source, free, and actively maintained.
  294. If it saves you a metered search bill, a ⭐, a sharp issue, or a **[☕ coffee](https://buymeacoffee.com/knockoutez)** helps keep it sustainable.
  295. <sub>Built and maintained by <a href="https://github.com/KnockOutEZ">@KnockOutEZ</a> · <a href="mailto:ktowhid20@gmail.com">ktowhid20@gmail.com</a> · <a href="https://x.com/yourtowhid">X</a> · <a href="https://www.linkedin.com/in/yourtowhid/">LinkedIn</a></sub>
  296. </div>
packaging/install.sh · Bundled script · 401 lines · 1 finding marked
  1. #!/bin/sh
  2. # wigolo bootstrap installer — local-first web intelligence for AI agents.
  3. #
  4. # Usage:
  5. # curl -fsSL https://wigolo.dev/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 5 on GitHub
  6. # sh install.sh --uninstall
  7. #
  8. # What it does:
  9. # 1. Detects your OS + CPU and bails early (with guidance) on unsupported ones.
  10. # 2. Installs wigolo under ~/.wigolo/ using a pinned, checksum-verified
  11. # language runtime — no system packages touched, no root required.
  12. # 3. Writes a launcher at ~/.wigolo/bin/wigolo and prints how to wire it into
  13. # your AI agent.
  14. #
  15. # This does NOT need any API keys for core work. Optional cloud keys add
  16. # answer synthesis; configure them later with `wigolo config`.
  17. #
  18. # Environment overrides (advanced / testing):
  19. # WIGOLO_INSTALL_PREFIX install root (default: $HOME/.wigolo)
  20. # WIGOLO_INSTALL_SOURCE install from a local package tarball instead of the
  21. # registry (absolute path to a `npm pack` .tgz)
  22. # HTTPS_PROXY/https_proxy honored for all downloads
  23. #
  24. # POSIX sh. set -eu (no pipefail — not POSIX).
  25. set -eu
  26. # ---------------------------------------------------------------------------
  27. # Pinned language runtime. Bump deliberately; both must move together.
  28. # ---------------------------------------------------------------------------
  29. NODE_VERSION="v22.23.1"
  30. NODE_DIST_BASE="https://nodejs.org/dist"
  31. PKG_NAME="wigolo"
  32. # Canonical release location for future prebuilt binaries (not yet published;
  33. # the runtime path below is the live path until a release ships them).
  34. BIN_RELEASE_BASE="https://github.com/KnockOutEZ/wigolo/releases/latest/download"
  35. # ---------------------------------------------------------------------------
  36. # Paths
  37. # ---------------------------------------------------------------------------
  38. PREFIX="${WIGOLO_INSTALL_PREFIX:-$HOME/.wigolo}"
  39. BIN_DIR="$PREFIX/bin"
  40. TOOL_DIR="$PREFIX/tool"
  41. RUNTIME_DIR="$PREFIX/runtime"
  42. TMP_DIR=""
  43. # ---------------------------------------------------------------------------
  44. # Output helpers (all to stderr so a piped install can stay quiet on stdout)
  45. # ---------------------------------------------------------------------------
  46. info() { printf '%s\n' "$*" >&2; }
  47. step() { printf '\n==> %s\n' "$*" >&2; }
  48. warn() { printf 'warning: %s\n' "$*" >&2; }
  49. die() {
  50. printf 'error: %s\n' "$*" >&2
  51. exit 1
  52. }
  53. cleanup() {
  54. if [ -n "$TMP_DIR" ] && [ -d "$TMP_DIR" ]; then
  55. rm -rf "$TMP_DIR"
  56. fi
  57. }
  58. trap cleanup EXIT INT TERM
  59. # ---------------------------------------------------------------------------
  60. # Download abstraction — curl or wget, HTTPS_PROXY honored automatically by
  61. # both tools via the standard env vars.
  62. # ---------------------------------------------------------------------------
  63. DL_TOOL=""
  64. detect_downloader() {
  65. if command -v curl >/dev/null 2>&1; then
  66. DL_TOOL="curl"
  67. elif command -v wget >/dev/null 2>&1; then
  68. DL_TOOL="wget"
  69. else
  70. die "neither curl nor wget found. Install one, or use the npm channel:
  71. npm install -g $PKG_NAME"
  72. fi
  73. }
  74. # download <url> <dest-file>
  75. download() {
  76. url="$1"
  77. dest="$2"
  78. if [ "$DL_TOOL" = "curl" ]; then
  79. curl -fSL --retry 3 -o "$dest" "$url" || die "download failed: $url"
  80. else
  81. wget -q -O "$dest" "$url" || die "download failed: $url"
  82. fi
  83. }
  84. # ---------------------------------------------------------------------------
  85. # sha256 — fail closed if no tool is available.
  86. # ---------------------------------------------------------------------------
  87. sha256_of() {
  88. file="$1"
  89. if command -v sha256sum >/dev/null 2>&1; then
  90. sha256sum "$file" | awk '{print $1}'
  91. elif command -v shasum >/dev/null 2>&1; then
  92. shasum -a 256 "$file" | awk '{print $1}'
  93. else
  94. die "no sha256 tool (sha256sum/shasum) found — cannot verify downloads. Aborting."
  95. fi
  96. }
  97. # verify_sha256 <file> <expected-hex>
  98. verify_sha256() {
  99. file="$1"
  100. expected="$2"
  101. [ -n "$expected" ] || die "empty expected checksum — refusing to trust $file"
  102. actual="$(sha256_of "$file")"
  103. if [ "$actual" != "$expected" ]; then
  104. die "checksum mismatch for $(basename "$file")
  105. expected: $expected
  106. actual: $actual"
  107. fi
  108. }
  109. # ---------------------------------------------------------------------------
  110. # Platform detection
  111. # ---------------------------------------------------------------------------
  112. OS=""
  113. ARCH=""
  114. detect_platform() {
  115. uname_s="$(uname -s 2>/dev/null || echo unknown)"
  116. uname_m="$(uname -m 2>/dev/null || echo unknown)"
  117. case "$uname_s" in
  118. Linux) OS="linux" ;;
  119. Darwin) OS="darwin" ;;
  120. MINGW* | MSYS* | CYGWIN* | Windows_NT)
  121. die "Windows is not supported by this installer. Use the npm channel:
  122. npm install -g $PKG_NAME"
  123. ;;
  124. *)
  125. die "unsupported OS: $uname_s. Use the npm channel:
  126. npm install -g $PKG_NAME"
  127. ;;
  128. esac
  129. case "$uname_m" in
  130. x86_64 | amd64) ARCH="x64" ;;
  131. arm64 | aarch64) ARCH="arm64" ;;
  132. armv7* | armv6*)
  133. die "32-bit ARM ($uname_m) is not supported. Try Docker, or the npm channel:
  134. npm install -g $PKG_NAME"
  135. ;;
  136. riscv*)
  137. die "RISC-V ($uname_m) is not supported. Try Docker, or the npm channel:
  138. npm install -g $PKG_NAME"
  139. ;;
  140. *)
  141. die "unsupported CPU architecture: $uname_m. Try Docker, or the npm channel:
  142. npm install -g $PKG_NAME"
  143. ;;
  144. esac
  145. if [ "$OS" = "linux" ]; then
  146. check_linux_libc
  147. fi
  148. }
  149. # musl / Alpine and old-glibc bail — the pinned runtime and native components
  150. # are built against modern glibc.
  151. check_linux_libc() {
  152. if [ -f /etc/alpine-release ]; then
  153. die "Alpine / musl libc is not supported by the prebuilt runtime.
  154. Use Docker (glibc-based image) or the npm channel:
  155. npm install -g $PKG_NAME"
  156. fi
  157. # ldd --version prints the libc flavor + version to stdout or stderr.
  158. ldd_out=""
  159. if command -v ldd >/dev/null 2>&1; then
  160. ldd_out="$(ldd --version 2>&1 || true)"
  161. fi
  162. case "$ldd_out" in
  163. *musl*)
  164. die "musl libc detected. Use Docker (glibc-based image) or the npm channel:
  165. npm install -g $PKG_NAME"
  166. ;;
  167. esac
  168. # Require glibc >= 2.28 (the runtime's build baseline).
  169. glibc_line="$(printf '%s\n' "$ldd_out" | head -n 1)"
  170. glibc_ver="$(printf '%s\n' "$glibc_line" | grep -oE '[0-9]+\.[0-9]+' | head -n 1)"
  171. if [ -n "$glibc_ver" ]; then
  172. glibc_major="${glibc_ver%%.*}"
  173. glibc_minor="${glibc_ver#*.}"
  174. if [ "$glibc_major" -lt 2 ] || { [ "$glibc_major" -eq 2 ] && [ "$glibc_minor" -lt 28 ]; }; then
  175. die "glibc $glibc_ver is too old (need >= 2.28). Use Docker or the npm channel:
  176. npm install -g $PKG_NAME"
  177. fi
  178. fi
  179. }
  180. # ---------------------------------------------------------------------------
  181. # Runtime install — download pinned tarball, verify against SHASUMS256.txt,
  182. # unpack under $RUNTIME_DIR.
  183. # ---------------------------------------------------------------------------
  184. NODE_BIN=""
  185. NPM_BIN=""
  186. install_runtime() {
  187. node_pkg="node-$NODE_VERSION-$OS-$ARCH"
  188. tarball="$node_pkg.tar.gz"
  189. tar_url="$NODE_DIST_BASE/$NODE_VERSION/$tarball"
  190. sums_url="$NODE_DIST_BASE/$NODE_VERSION/SHASUMS256.txt"
  191. # Already installed and correct version? Skip re-download on upgrade re-runs.
  192. if [ -x "$RUNTIME_DIR/bin/node" ]; then
  193. have="$("$RUNTIME_DIR/bin/node" --version 2>/dev/null || echo none)"
  194. if [ "$have" = "$NODE_VERSION" ]; then
  195. info "Runtime $NODE_VERSION already present — reusing."
  196. NODE_BIN="$RUNTIME_DIR/bin/node"
  197. NPM_BIN="$RUNTIME_DIR/bin/npm"
  198. return 0
  199. fi
  200. fi
  201. step "Downloading the bundled runtime ($node_pkg)"
  202. download "$tar_url" "$TMP_DIR/$tarball"
  203. step "Verifying runtime checksum (fail-closed)"
  204. download "$sums_url" "$TMP_DIR/SHASUMS256.txt"
  205. expected="$(grep " $tarball\$" "$TMP_DIR/SHASUMS256.txt" | awk '{print $1}')"
  206. [ -n "$expected" ] || die "no checksum entry for $tarball in SHASUMS256.txt"
  207. verify_sha256 "$TMP_DIR/$tarball" "$expected"
  208. info "Checksum OK."
  209. step "Unpacking the runtime into $RUNTIME_DIR"
  210. rm -rf "$RUNTIME_DIR"
  211. mkdir -p "$RUNTIME_DIR"
  212. # Strip the top-level node-<ver>-<os>-<arch>/ directory.
  213. tar -xzf "$TMP_DIR/$tarball" -C "$RUNTIME_DIR" --strip-components=1
  214. NODE_BIN="$RUNTIME_DIR/bin/node"
  215. NPM_BIN="$RUNTIME_DIR/bin/npm"
  216. [ -x "$NODE_BIN" ] || die "runtime unpack failed — $NODE_BIN missing"
  217. }
  218. # ---------------------------------------------------------------------------
  219. # Tool install — use the PINNED runtime's own package manager so any native
  220. # components resolve prebuilds for the correct runtime, into $TOOL_DIR.
  221. # ---------------------------------------------------------------------------
  222. install_tool() {
  223. mkdir -p "$TOOL_DIR"
  224. spec="$PKG_NAME"
  225. if [ -n "${WIGOLO_INSTALL_SOURCE:-}" ]; then
  226. [ -f "$WIGOLO_INSTALL_SOURCE" ] || die "WIGOLO_INSTALL_SOURCE not found: $WIGOLO_INSTALL_SOURCE"
  227. spec="$WIGOLO_INSTALL_SOURCE"
  228. step "Installing wigolo from local package: $spec"
  229. else
  230. step "Installing wigolo from the registry"
  231. fi
  232. # PATH so the runtime's node is what npm and node-gyp see.
  233. NPM_CONFIG_PREFIX="$TOOL_DIR" \
  234. PATH="$RUNTIME_DIR/bin:$PATH" \
  235. "$NPM_BIN" install -g --no-fund --no-audit "$spec" >&2 \
  236. || die "tool install failed"
  237. }
  238. # ---------------------------------------------------------------------------
  239. # Prebuilt binary path (canonical when a release ships one). Returns 0 if a
  240. # binary was installed, 1 if none is available for this platform.
  241. # ---------------------------------------------------------------------------
  242. try_prebuilt_binary() {
  243. # Skip entirely when installing from a local tarball (test / dev path).
  244. [ -z "${WIGOLO_INSTALL_SOURCE:-}" ] || return 1
  245. bin_name="wigolo-$OS-$ARCH"
  246. bin_url="$BIN_RELEASE_BASE/$bin_name"
  247. sums_url="$BIN_RELEASE_BASE/checksums.txt"
  248. # Probe the checksums file first; absence => no binary channel yet.
  249. if [ "$DL_TOOL" = "curl" ]; then
  250. curl -fsSL --retry 2 -o "$TMP_DIR/checksums.txt" "$sums_url" 2>/dev/null || return 1
  251. else
  252. wget -q -O "$TMP_DIR/checksums.txt" "$sums_url" 2>/dev/null || return 1
  253. fi
  254. expected="$(grep " $bin_name\$" "$TMP_DIR/checksums.txt" | awk '{print $1}')"
  255. [ -n "$expected" ] || return 1
  256. step "Downloading prebuilt binary ($bin_name)"
  257. download "$bin_url" "$TMP_DIR/$bin_name" || return 1
  258. step "Verifying binary checksum (fail-closed)"
  259. verify_sha256 "$TMP_DIR/$bin_name" "$expected"
  260. mkdir -p "$BIN_DIR"
  261. mv "$TMP_DIR/$bin_name" "$BIN_DIR/wigolo"
  262. chmod 0755 "$BIN_DIR/wigolo"
  263. info "Installed prebuilt binary to $BIN_DIR/wigolo"
  264. return 0
  265. }
  266. # ---------------------------------------------------------------------------
  267. # Shim — prepend the runtime's bin to PATH so the CLI's own tooling probes
  268. # (e.g. resolving a package runner for the browser engine) work, then exec the
  269. # installed CLI.
  270. # ---------------------------------------------------------------------------
  271. write_shim() {
  272. mkdir -p "$BIN_DIR"
  273. entry="$TOOL_DIR/lib/node_modules/$PKG_NAME/dist/index.js"
  274. [ -f "$entry" ] || die "CLI entry not found at $entry after install"
  275. cat > "$BIN_DIR/wigolo" <<EOF
  276. #!/bin/sh
  277. # wigolo launcher (generated by install.sh). Prepends the bundled runtime so
  278. # the CLI's package-runner probes resolve, then runs the installed CLI.
  279. export PATH="$RUNTIME_DIR/bin:\$PATH"
  280. exec "$RUNTIME_DIR/bin/node" "$TOOL_DIR/lib/node_modules/$PKG_NAME/dist/index.js" "\$@"
  281. EOF
  282. chmod 0755 "$BIN_DIR/wigolo"
  283. }
  284. # ---------------------------------------------------------------------------
  285. # Uninstall — remove the tool, but PRESERVE user data (cache/models/keys).
  286. # ---------------------------------------------------------------------------
  287. do_uninstall() {
  288. step "Removing the wigolo tool (preserving your data in $PREFIX)"
  289. rm -rf "$BIN_DIR" "$TOOL_DIR" "$RUNTIME_DIR"
  290. info "Removed: $BIN_DIR, $TOOL_DIR, $RUNTIME_DIR"
  291. info "Preserved: your cache, models, and keys under $PREFIX"
  292. info ""
  293. info "To wipe everything including data: rm -rf $PREFIX"
  294. exit 0
  295. }
  296. # ---------------------------------------------------------------------------
  297. # Closing message + doctor verdict.
  298. # ---------------------------------------------------------------------------
  299. finish() {
  300. step "Verifying the install"
  301. if "$BIN_DIR/wigolo" doctor >&2; then
  302. doctor_ok=1
  303. else
  304. doctor_ok=0
  305. fi
  306. info ""
  307. info "wigolo installed to $BIN_DIR/wigolo"
  308. info ""
  309. info "Add to your shell (so 'wigolo' resolves in your terminal):"
  310. info " export PATH=\"$BIN_DIR:\$PATH\""
  311. info ""
  312. info "Wire it into your AI agent (use the ABSOLUTE path — MCP clients do not"
  313. info "read your shell PATH):"
  314. info " claude mcp add wigolo -- $BIN_DIR/wigolo"
  315. info ""
  316. if [ "$doctor_ok" -eq 1 ]; then
  317. info "Health check: OK."
  318. else
  319. info "Health check reported issues above — run '$BIN_DIR/wigolo doctor' for detail."
  320. fi
  321. }
  322. # ---------------------------------------------------------------------------
  323. # Main
  324. # ---------------------------------------------------------------------------
  325. main() {
  326. for arg in "$@"; do
  327. case "$arg" in
  328. --uninstall)
  329. do_uninstall
  330. ;;
  331. -h | --help)
  332. info "wigolo installer"
  333. info " (no args) install or upgrade wigolo under $PREFIX"
  334. info " --uninstall remove the tool, preserving your cache/models/keys"
  335. exit 0
  336. ;;
  337. *)
  338. die "unknown argument: $arg (try --help)"
  339. ;;
  340. esac
  341. done
  342. detect_downloader
  343. detect_platform
  344. mkdir -p "$PREFIX" "$BIN_DIR"
  345. TMP_DIR="$(mktemp -d "${TMPDIR:-/tmp}/wigolo-install.XXXXXX")"
  346. step "Installing wigolo for $OS/$ARCH into $PREFIX"
  347. if try_prebuilt_binary; then
  348. info "Using prebuilt binary."
  349. else
  350. install_runtime
  351. install_tool
  352. write_shim
  353. fi
  354. finish
  355. }
  356. main "$@"

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.