에이전트 강화
게시자의 자체 명령입니다. PlugMCP 엔드포인트가 아닙니다.
Host a copy with our keys and logs.
npx -y [email protected]Claude Code에는 로컬 명령용 설치 링크가 없습니다. 아래 명령을 복사해 터미널에서 실행합니다.
TARGET_DEV_URL=<value> TARGET_STAGING_URL=<value> SLACK_BOT_TOKEN=<secret> FIGMA_API_TOKEN=<secret> ARGUS_REDACT_SENSITIVE=<value> claude mcp add io.github.ironclawdevs27-argus -- npx -y argusqa-os@10.0.0터미널에서 실행합니다.
{ "mcpServers": { "io.github.ironclawdevs27-argus": { "command": "npx", "args": [ "-y", "[email protected]" ], "env": { "TARGET_DEV_URL": "<value>", "TARGET_STAGING_URL": "<value>", "SLACK_BOT_TOKEN": "<secret>", "FIGMA_API_TOKEN": "<secret>", "ARGUS_REDACT_SENSITIVE": "<value>" } } }}claude_desktop_config.json
원격 URL인가요, 내 컴퓨터에서 실행하는 명령인가요? 두 설치 방식의 차이
PlugMCP에서 실행
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
실행One line in your MCP config gives Claude (or any MCP agent) a real Chrome audit engine — 67 audit categories · 149 finding types · zero test files to write or maintain. And with Aegis, what it finds never leaks your secrets to the LLM.
AI agents now write most of the code — and they judge their own work by whether it compiles and looks done, not by what actually happens in the browser. The uncaught exception on the third click. The form that posts credentials over HTTP. The 4-second LCP. The button that vanished in dark mode. The API endpoint hammered in an infinite loop.
Argus closes that gap. It drives a real Chrome (via the Chrome DevTools Protocol) against your locally-running app and hands the agent — or you — a structured, severity-ranked bug report. The agent fixes; Argus re-checks; the loop closes before the code leaves your machine.
No install.
npxfetches Argus on first run.
1 — Add two lines to .mcp.json in your project root:
{
"mcpServers": {
"chrome-devtools": { "command": "npx", "args": ["-y", "chrome-devtools-mcp@latest"] },
"argus": { "command": "npx", "args": ["-y", "argusqa-os"] }
}
}
Or via the Claude Code CLI:
claude mcp add chrome-devtools -- npx -y chrome-devtools-mcp@latest
claude mcp add argus -- npx -y argusqa-os
2 — Launch Chrome (auto-detects your Chrome, sets the right flags):
npx -y -p argusqa-os argus-chrome
# macOS
open -a "Google Chrome" --args --remote-debugging-port=9222 --headless=new
# Windows (PowerShell)
& "C:\Program Files\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9222 --headless=new --no-sandbox --disable-gpu --user-data-dir="$env:TEMP\chrome-argus"
# Linux
google-chrome --remote-debugging-port=9222 --headless=new --no-sandbox
3 — Ask your agent:
Run argus_audit on http://localhost:3000
That's it. Findings come back structured and severity-ranked — into the conversation, to Slack, or as a local report.html. Something off? npx -y -p argusqa-os argus-doctor diagnoses your setup in one command.
This is what Argus looks like inside an agentic coding session:
You: Build me a checkout page with a card form.
Agent: [writes the code, dev server renders it]
You: Run argus_audit on http://localhost:3000/checkout
Argus: ● 2 critical · 3 warnings
● uncaught TypeError in checkout.js (visible on submit)
● form posts over HTTP — security_no_https
▲ card inputs missing labels + autocomplete (a11y/WCAG)
▲ LCP 4.1s — hero image unoptimized
▲ duplicate POST /api/cart ×7 — likely render loop
Agent: [fixes all five]
You: Run argus_get_context
Argus: ✓ resolved: 5 · persisting: 0 · new: 0
argus_get_context diffs against the previous snapshot, so the agent knows exactly what it fixed, what it broke, and what remains — no re-reading walls of output.
"But my agent can already drive a browser…" — it can. Driving isn't judging. A raw browser MCP (Playwright MCP, bare chrome-devtools-mcp) gives the agent hands and eyes; the agent must then re-derive what to check every session, burning context on console-log spelunking. Argus is the judgment layer on top: 149 codified finding types with thresholds, severity policy, cross-run baselines, flakiness filtering, dedup, root-cause hints — returned in one call, redacted by default.
32 analysis engines, 149 distinct issue types, zero test-file maintenance:
And every finding is post-processed with:
All findings are classified as
critical/warning/infoand routed to the right Slack channel — or surfaced in the local HTML report. For per-finding severity tables and detection methods, see REFERENCE.md.
Argus audits the rendered output, not your source — so it is framework-agnostic by construction. If it runs in Chrome, Argus can audit it:
Honest limits: Chrome/Chromium rendering only (no Safari/Firefox engine differences), web only (no native mobile/desktop apps), and backend services are checked through the traffic the page generates — not as standalone API test suites.
Default ON. Argus audits your app for secrets and vulnerabilities — so its findings are exactly the data you least want leaving your machine. Aegis redacts them at every external boundary before they cross. For teams adopting AI agents, this is the difference between "we use an AI QA tool" and "we can tell our security lead exactly why it's safe."
A finding sent to an external sink — an MCP tool response (which lands in the calling agent's context window and transits to that agent's model provider), a Slack message, a GitHub PR comment + its ::error annotations, the hosted/CI HTML report, or CI logs — is reduced to a need-to-know projection: a sensitive finding crosses as its type + route + severity + a 🔒 marker, and never its raw payload (message, evidence, request/response bodies, headers, cookies, stack). URLs are projected with the query string stripped (tokens hide there). A benign finding keeps its message — but that message is still scrubbed for any accidentally-embedded secret or PII.
This implements the OWASP LLM02:2025 — Sensitive Information Disclosure mitigations (data minimization, redaction, deny-by-default egress filtering) at Argus's own boundaries. An optional, local-only re-hydration vault (ARGUS_REDACT_VAULT=1) can mint reversible, information-free tokens for diff-stable artifacts — re-inflate locally with npm run report:rehydrate. Full behavior change is documented in CHANGELOG.md.
Ask Claude (or any MCP client) — no terminal required:
Every tool response is projected through the Aegis egress boundary before it reaches the agent, and carries an optional
redactionrider ({ redacted, total }) when sensitive detail was withheld.
Example prompts:
Run argus_audit on http://localhost:3000/checkout
Run argus_audit_full on http://localhost:3000/dashboard
Run argus_compare
Run argus_get_context
Argus's own correctness is enforced the way it audits yours:
npm audit: 0 vulnerabilities · CodeQL + Dependabot on every PR · Socket.dev: 100/100/100 on vulnerability/quality/license0600, owner-onlyNo local install needed. Use the Quick Start above, then add your target URL:
# .env in your project root
TARGET_DEV_URL=http://localhost:3000
TARGET_STAGING_URL=https://staging.example.com # optional — enables argus_compare
Optional — Slack notifications:
chat:write, files:write, files:readxoxb-... token#bugs-critical, #bugs-warnings, #bugs-digest and run /invite @BugBot in eachSLACK_BOT_TOKEN=xoxb-...
SLACK_CHANNEL_CRITICAL=C0000000000
SLACK_CHANNEL_WARNINGS=C0000000001
SLACK_CHANNEL_DIGEST=C0000000002
Without Slack: Argus auto-generates
reports/report.htmland opens it in your browser — zero extra config.
npm install --save-dev argusqa-os
npx argus init # interactive wizard — detects framework, discovers routes, writes .env
npm run crawl # run after Chrome is started
git clone https://github.com/ironclawdevs27/Argus.git
cd Argus
npm install
npm run init # interactive setup wizard
Manual setup (skip the wizard):
cp .env.example .env
# Fill in TARGET_DEV_URL and optional Slack tokens
Then configure your routes in src/config/targets.js:
export const routes = [
{ path: '/', name: 'Home', critical: true, waitFor: 'main' },
{ path: '/login', name: 'Login', critical: true, waitFor: 'form' },
{ path: '/dashboard', name: 'Dashboard', critical: true, waitFor: '[data-testid="dashboard"]' },
{ path: '/settings', name: 'Settings', critical: false, waitFor: null },
];
critical: true — errors on this route go to #bugs-criticalwaitFor — CSS selector Argus waits for before capturing (signals page-ready)npm run chrome # Launch Chrome with --remote-debugging-port=9222 (auto-detects binary)
npm run doctor # Pre-flight check: Chrome reachable, .mcp.json valid, .env has TARGET_DEV_URL
npm run crawl # Batch audit of all configured routes
npm run compare # Dev vs staging diff (CSS-only if no staging URL)
npm run watch # Passive monitor — polls open Chrome tab every 1s
npm run report:html # Generate reports/report.html from last JSON audit
npm run report:pdf # Export HTML report to A4 PDF (requires: npm install puppeteer)
npm run server # Start Slack slash-command server (port 3001)
npm run init # Interactive setup wizard
npm run test:unit # 562 unit tests — no Chrome required
npm run test:harness # 171-block correctness harness — requires Chrome
npm run test:harness:log # same, but tees full output to harness-results.txt
npm run test:coverage # merged unit + harness coverage gate (requires Chrome)
Watch mode — live monitoring as you (or your agent) develop:
# Terminal 1: start your app
npm run dev
# Terminal 2: start Argus watcher
npm run watch
# Ctrl+C → stops monitor and writes reports/report.html
Slack slash command (on-demand from any channel):
/argus-retest https://staging.example.com/checkout
To expose the server via tunnel: cloudflared tunnel --url http://localhost:3001 (free, no account required). Set the resulting URL as the Request URL in Slack App → Slash Commands.
Argus ships as a composite GitHub Action: on every PR it maps the diff to affected routes, audits them, and blocks the merge only on findings the PR introduces (baseline-aware) — with an idempotent PR comment and a Check Run.
Add to your repo's secrets (Settings → Secrets → Actions):
The included workflow runs on push to main, daily at 6 AM UTC, and on manual trigger. If critical issues are found, the pipeline fails.
First stop for anything broken:
npx -y -p argusqa-os argus-doctor— it checks Chrome reachability, MCP config validity, and required env keys, and prints the exact fix for each failure.
Chrome DevTools MCP not connecting
claude mcp add chrome-devtools -- npx chrome-devtools-mcp@latest
# Restart Claude Code after adding
Slack messages not posting
xoxb- (not xoxp-, xoxe-, or xapp-)/invite @BugBot in each channelchat:write, files:write, files:readScreenshots are blank
pageSettleMs in src/config/targets.js or add a waitFor selector for the route/argus-retest returns "dispatch_failed"
CSS analysis returns empty results
CI pipeline fails immediately
sleep 3 to sleep 5 in .github/workflows/argus.ymlArgus is a complementary layer, not a replacement for unit or E2E tests:
All 998 harness assertions pass (998/998) — there are currently no known MCP- or Chrome-layer restrictions. Lighthouse runs headless (after the lighthouse_audit argument fix); the remaining soft assertions (perf traces, GC-dependent heap-growth) are promoted to counted hard assertions only in the weekly strict-soft lane (harness-strict.yml) via ARGUS_HARNESS_STRICT_SOFT. Scope limits: Chrome/Chromium only, web apps only — see Works With Your Stack.
Want audits without running Chrome or npm — with history, trends, schedules, and a team dashboard? Argus Cloud is in founding-member early access: $19/month, locked forever (regular $29).
The open-source engine on this page stays MIT and fully-featured, always — the hosted tier sells convenience and memory, never detections.
src/
argus.js — single-page audit entry point
mcp-server.js — 9 MCP tools exposed to Claude / any MCP client
orchestration/ — crawl loop, Slack/GitHub dispatch, env comparison, watch mode
utils/ — 32 analysis engines (accessibility, security, performance, PDF, recording, etc.)
adapters/browser.js — CdpBrowserAdapter — wraps all chrome-devtools-mcp calls
config/targets.js — routes, thresholds, auth steps
cli/
init.js — argus init interactive setup wizard
chrome-launcher.js — npm run chrome / argus-chrome — launches Chrome with correct flags
doctor.js — npm run doctor / argus-doctor — pre-flight checks
pr-validate.js — headless CI entry point for GitHub Actions
test-harness/ — 171-block correctness harness, 998 hard assertions, 64 fixture pages
test/unit/ — 562 Vitest unit tests (no Chrome required)
landing/ — Product landing page (React 19 + Vite + Tailwind)
Contributions are welcome — fixture pages, new detection categories, framework route-discovery, docs. Start with CONTRIBUTING.md.
npm run test:unit — verify without Chrome (562 tests)npm run test:harness — full integration coverage (requires Chrome on port 9222)MIT © ironclawdevs27
Argus Panoptes — the all-seeing giant of Greek mythology who never slept.
Automated web QA via Chrome DevTools MCP — a11y, security, visual, env diff, CI; Aegis redaction.
{ "mcpServers": { "io.github.ironclawdevs27-argus": { "command": "npx", "args": [ "-y", "[email protected]" ], "env": { "TARGET_DEV_URL": "<value>", "TARGET_STAGING_URL": "<value>", "SLACK_BOT_TOKEN": "<secret>", "FIGMA_API_TOKEN": "<secret>", "ARGUS_REDACT_SENSITIVE": "<value>" } } }}도구
아직 도구 목록이 없습니다. 원격 서버는 첫 상태 확인 후에 도구 목록이 생깁니다.
FAQ
이 페이지에서 Cursor, Claude Desktop, Claude Code 또는 VS Code용 stdio 설정을 복사합니다. PlugMCP 프록시가 아니라 게시자의 설치 방식을 사용합니다.
게시자가 등록한 환경 변수: TARGET_DEV_URL, TARGET_STAGING_URL, SLACK_BOT_TOKEN, FIGMA_API_TOKEN, ARGUS_REDACT_SENSITIVE.
Argus은(는) stdio를 통해 로컬에서 실행됩니다.
마지막 확인: 2026-11-09. Automated web QA via Chrome DevTools MCP — a11y, security, visual, env diff, CI; Aegis redaction.