DeepSeek Harness plugin

dsh-web-recon

Work out how a web system actually works — once. Captures its real HTTP API and accessibility tree in a dedicated, fenced browser, then keeps a reusable playbook so later automation never pays to

Jump to install

Source facts

Repository
sherconan/dsh-web-recon
Latest update
Aug 14, 2026
Category
Tools & Capabilities
GitHub stars
0
Format
plugin
Catalog evidence
Upstream dsh.bundle evidence
Evidence path
package.json#dsh.bundle
Checked against
0.1.0-rc.8
Upstream check date
2026-08-20

This evidence comes from the upstream catalog. This site has not installed, run, or security-reviewed the plugin.

Install

Start with a prompt that asks an agent to review the GitHub repository and source. Switch to the command if you want to install it yourself.

Copy this prompt into DSH, Codex, or another agent and ask it to review the GitHub repository and source first.

Do not install or run any commands yet. Read this plugin's GitHub repository, README, and relevant source code. Then answer the questions below clearly and directly so I can decide whether it fits my needs:

1. What is this plugin, and what problem does it solve?
2. Who is it for, and what are its typical use cases?
3. How is it used after installation? Include one minimal example.
4. What known limitations or privacy, security, compatibility, or maintenance risks does it have?
5. Give a clear recommendation: recommend, conditionally recommend, or do not recommend, with reasons.

Distinguish statements documented by the repository, inferences from source code, and unknowns. If evidence is insufficient, say so explicitly. Do not guess or simply repeat the README.

GitHub: https://github.com/sherconan/dsh-web-recon
Plugin: dsh-web-recon
Author: sherconan

Check the source files

Read the README and other files from this plugin directory before installing.

File explorer4 files
README.mdSource · read only
README language

dsh-web-recon · Web system reconnaissance

English | 中文

A plugin for DeepSeek Harness. Work out how a web system operates — once.

The problem

The usual way an agent automates a web back-office is: screenshot, find the button, click, screenshot again. That approach has three faults:

1. Expensive. A screenshot costs thousands of tokens; a workflow costs dozens of screenshots. 2. Brittle. It keys on coordinates and pixels, so a redesign breaks everything. 3. Nothing is retained. Two hours spent working a system out is spent again in the next session.

Underneath the buttons there is an HTTP API. Underneath the pixels there is an accessibility tree. Both are far cheaper and far more stable.

This plugin turns one reconnaissance pass into a durable playbook for that system — its endpoints, how it authenticates, the controls worth knowing — so later work follows the playbook instead of the screen.

What it produces

One pass over a single-page application, actual output:

6 application endpoints identified; accessibility tree of 896 nodes
API hosts: api.gleif.org, challengemanagement.gleif.org

| Method | Host          | Path                     | Query            | Auth  |
| GET    | api.gleif.org | /api/v1/lei-records      | filter[fulltext] | none  |
| GET    | api.gleif.org | /api/v1/autocompletions  | q, field         | none  |
| GET    | challenge…    | /users/auth              | —                | XSRF  |

No button was clicked, and the system's search API is now known. Note that the UI and the API live on different hosts — the norm for a SPA, and something you can never discover by looking at the screen.

Install

dsh plugin --profile web add github:sherconan/dsh-web-recon

Plain JavaScript, no runtime dependencies, no build step. No Playwright, no downloaded browsers — it speaks the Chrome DevTools Protocol over Node's built-in WebSocket.

Requires Chrome, Chromium or Edge on the machine (or set DSH_WEB_RECON_CHROME to an executable).

Security boundary

This plugin touches signed-in sessions, so the boundary came first:

  • A dedicated browser. It runs its own Chrome against its own user-data directory and never drives your everyday browser. The only sessions it can reach are the ones you signed into inside it. Your mail, your bank, your intranet are out of reach because they were never logged into here.
  • An origin allow-list. Unauthorised origins are refused, not warned about. Authorisations are timestamped, so the list doubles as an audit trail.
  • Credentials are yours to type. Signing in is the only action that opens a visible window, and you sign in yourself. Everything else runs headless. The plugin never types a password and never asks you for one.
  • Summaries only. Raw captures and full trees never enter the conversation — returning them would hand back the tokens the plugin exists to save.

Tools

ToolPurpose
web_site_authorize / web_site_revoke / web_site_listManage origin authorisation
web_browser_loginOpen a visible window so you can sign in
web_browser_closeShut the dedicated browser down
web_reconReconnoitre a page; build and accumulate its playbook
web_replayCall an endpoint from the playbook — no screenshots, no clicking
web_playbook_list / web_playbook_getRead what is already known (check this before reconnoitring again)

Replay: doing the work

With a playbook in hand, web_replay calls the endpoint directly:

  • Credentials never pass through this plugin. The request is issued from a page inside the dedicated browser, so cookies, CSRF and CORS are handled exactly as the real application handles them. No credential value is read, stored or printed.
  • Credential mode adapts. It tries with the session first; if the endpoint is public (CORS allows any origin, which by rule forbids credentialed requests) it retries once without credentials and tells you which mode succeeded.
  • State-changing requests are refused by default. POST/PUT/PATCH/DELETE require the user's explicit agreement and an explicit opt-in flag; the model may not self-confirm.
  • Responses are distilled to a status, a shape summary and a bounded excerpt, rather than dumped whole into context.

Where playbooks live

$DSH_HOME/web-recon/playbooks/<site>.json — readable, editable JSON. Repeat passes accumulate endpoints as a union, and anyone who knows the system can correct the file by hand.

Known limits

  • Server-rendered pages expose no separate API; there the playbook's value is its control inventory.
  • Some endpoints fire only after a specific action. Pass interact with a CSS selector to click once during the pass.
  • Playbooks go stale when the target system is redesigned. Re-run reconnaissance; endpoints accumulate rather than replace.
  • Playbooks record endpoint shapes, not field semantics. What a parameter means is still for you or the model to work out.
  • No multi-step orchestration yet: chaining sign-in → list → process-each is still the model's job.

License

MIT