@topy-ai/maggie 0.7.56 → 0.7.57

package/README-zh-TW.md

@@ -29,7 +29,9 @@ npx @topy-ai/maggie init --scope project --agent all
 npx @topy-ai/maggie doctor --scope project --project .
 ```
 
-目前 npm 版本為 `0.7.56`：新增 Maggie Security（`maggie-security` skill 與 `maggie security` 指令，共 46 個指令、29 個 MCP 工具），涵蓋套件、runtime、資料庫、Web server、Linux 發行版與 WordPress 的漏洞公告與 end-of-life 日期，以及 secrets、程式碼、網站與主機檢查、報告、CI gate 與每日監控。
+目前 npm 版本為 `0.7.57`：新增 `maggie security public-check`，對你**無法控制**的站點做被動、等同瀏覽器的檢查（安全 headers、TLS、首頁洩漏的版本與其已知 CVE、SPF/DMARC、security.txt），讓你能通知站主；只限真人互動執行，絕不探測、提交或掃描，主動掃描（web-scan、zap-baseline）與主機檢查仍須先驗證域名。
+
+0.7.56 新增 Maggie Security（`maggie-security` skill 與 `maggie security` 指令，共 46 個指令、29 個 MCP 工具），涵蓋套件、runtime、資料庫、Web server、Linux 發行版與 WordPress 的漏洞公告與 end-of-life 日期，以及 secrets、程式碼、網站與主機檢查、報告、CI gate 與每日監控。
 
 0.7.55 完成 feedback batch 31，共 16 條，來自一個以排程 AI agent 操作自家行銷產品、同時維護 PHP 主機的團隊，並同步發布 MaggieDash 0.2.15。
 
@@ -139,7 +141,7 @@ structure drift 或重複 treatment product 時 fail closed。
 deployment、memory、feedback 和 MaggieDash。內容先 draft/review，外部寫入、
 publish 與 production deployment 需要明確確認。
 
-目前 npm 版本為 `0.7.56`，包含 Maggie Security、batch 31 排程 agent routines、報告收件匣與無人值守 agent 限制、PHP runtime 盤點與主機鎖、pull 網站改寫、query 點子與社群佇列檢查，batch 30 MaggieDash 先裝核心、release privacy gate、feedback 備援、社群連結與圖片檢查、大量頁面產生與 app 檢查，batch 29 預約規則、部署、app QA、助理與社群功能，以及 batch 28 產品 app、assistant tools、mobile、product release、skills catalog 與 bridge host 功能、batch 26、27 feedback 修正與 idempotent `maggie update`與 Booking email-template 合約/CLI validator 同步。本版完成 2026-09-24 booking feedback batch：Calendar grid/free-slot entry 與 host modal focus-restoration evidence。本版新增 Starter marketplace provisioning plan；本版完成 feedback batches 22、23：加入 declarative browser interaction evidence、design markup/style/content-key gate、compiler source anchoring、entity double-escape protection、`update --help` read-only、noindex hypothetical indexability、可過期 baseline acknowledgement、DOM-only link extraction regression，以及 MaggieDash 0.2.10 的 content override、短期 browser session、CDN-safe public-session cache contracts。authentication 和 isolated dev server 仍由 host 負責。`maggie-booking` workflow、傳統 email/password、Stripe、Resend、public booking flow 及既有安全邊界維持不變；provider-bound video generation 與 transactional delivery 仍記錄在 issue #39，前一批延後功能仍在 issue #38，不會直接成為 active memory。0.7.33 記錄並審查一筆更正回饋；確認 0.7.32 已正確處理 batch index，沒有修改已驗證的 shared behavior。0.7.32 加入 feedback 一基索引支援、MaggieDash panel 的 source/freshness/error evidence、Consent Mode 與實際 write/no-op reconciliation、SEO baseline recapture、sitemap origin rebasing、content-diff scope、migration ledger reconciliation、deployment credential preflight、release provenance/runtime preflight、icon release gate、opt-in blog auto-publish gate，以及 least-privilege VPS deployer。也修復 top-level `maggie feedback` dispatcher parity。0.7.31 加入 update 差異摘要、atomic installer copy、subset install manifest merge，以及 inventory drift 時 doctor non-zero。0.7.30 補上 feedback tracking issue closeout gate 與 batch 14/15 audit ledger。0.7.29 修正 npm package landing page 使用英文 README；0.7.28 加入 versioned Gemini model policy、明確 fallback 與 provenance、bundled-first CLI
+目前 npm 版本為 `0.7.57`，包含 public-check、Maggie Security、batch 31 排程 agent routines、報告收件匣與無人值守 agent 限制、PHP runtime 盤點與主機鎖、pull 網站改寫、query 點子與社群佇列檢查，batch 30 MaggieDash 先裝核心、release privacy gate、feedback 備援、社群連結與圖片檢查、大量頁面產生與 app 檢查，batch 29 預約規則、部署、app QA、助理與社群功能，以及 batch 28 產品 app、assistant tools、mobile、product release、skills catalog 與 bridge host 功能、batch 26、27 feedback 修正與 idempotent `maggie update`與 Booking email-template 合約/CLI validator 同步。本版完成 2026-09-24 booking feedback batch：Calendar grid/free-slot entry 與 host modal focus-restoration evidence。本版新增 Starter marketplace provisioning plan；本版完成 feedback batches 22、23：加入 declarative browser interaction evidence、design markup/style/content-key gate、compiler source anchoring、entity double-escape protection、`update --help` read-only、noindex hypothetical indexability、可過期 baseline acknowledgement、DOM-only link extraction regression，以及 MaggieDash 0.2.10 的 content override、短期 browser session、CDN-safe public-session cache contracts。authentication 和 isolated dev server 仍由 host 負責。`maggie-booking` workflow、傳統 email/password、Stripe、Resend、public booking flow 及既有安全邊界維持不變；provider-bound video generation 與 transactional delivery 仍記錄在 issue #39，前一批延後功能仍在 issue #38，不會直接成為 active memory。0.7.33 記錄並審查一筆更正回饋；確認 0.7.32 已正確處理 batch index，沒有修改已驗證的 shared behavior。0.7.32 加入 feedback 一基索引支援、MaggieDash panel 的 source/freshness/error evidence、Consent Mode 與實際 write/no-op reconciliation、SEO baseline recapture、sitemap origin rebasing、content-diff scope、migration ledger reconciliation、deployment credential preflight、release provenance/runtime preflight、icon release gate、opt-in blog auto-publish gate，以及 least-privilege VPS deployer。也修復 top-level `maggie feedback` dispatcher parity。0.7.31 加入 update 差異摘要、atomic installer copy、subset install manifest merge，以及 inventory drift 時 doctor non-zero。0.7.30 補上 feedback tracking issue closeout gate 與 batch 14/15 audit ledger。0.7.29 修正 npm package landing page 使用英文 README；0.7.28 加入 versioned Gemini model policy、明確 fallback 與 provenance、bundled-first CLI
 dispatch、`maggie --version`、feedback batch review 聚合與重複偵測、marketplace enrichment evidence、booking
 worker/resolver evidence，以及 read-only migration preflight。它也包含 host-owned mobile app surface contract、signed-in
 camera-state QA、直接 Astro route resolution、correlated feedback batch，以及

package/README.md

@@ -89,8 +89,15 @@ Maggie keeps the existing project foundation and asks for decisions before
 shared routes, analytics, or publishing boundaries change. The current
 package ships 23 installable skills and a local-first MaggieDash foundation.
 
-This package is `0.7.56`. It adds Maggie Security, a new
-`maggie-security` skill and `maggie security` command family (46 commands, 29
+This package is `0.7.57`. It adds `maggie security public-check`: passive,
+browser-equivalent checks of sites you do **not** control (security headers,
+TLS, versions disclosed on the home page and their known CVEs, SPF/DMARC,
+`security.txt`), so you can tell an owner about a visible problem. It is
+interactive-only and never probes, submits or scans; the active scanners
+(`web-scan`, `zap-baseline`) and host checks stay verified-only.
+
+The 0.7.56 release added Maggie Security, a new
+`maggie-security` skill and `maggie security` command family (47 commands, 30
 MCP tools, 7 contracts under `contracts/maggie-security/`).
 
 - **Advisories for the whole stack.** Packages (npm, pnpm, Yarn, Bun,
@@ -837,8 +844,8 @@ artifact schemas.
 Recommended upgrade sequence for the current release:
 
 ```bash
-npx @topy-ai/maggie@0.7.56 update --scope project --project . --force
-npx @topy-ai/maggie@0.7.56 cleanup --scope project --project .
+npx @topy-ai/maggie@0.7.57 update --scope project --project . --force
+npx @topy-ai/maggie@0.7.57 cleanup --scope project --project .
 ```
 
 Maintainers should pass npm credentials through the repository helper, never

package/bundled-skills/maggie-security/SKILL.md

@@ -46,6 +46,7 @@ Follow [Maggie Memory Hook](../../references/memory-hook.md) at invocation and c
 | "are my dependencies safe?" | `maggie security deps` (every lockfile ecosystem + JavaScript copied into the site) | `security_deps_scan` |
 | "is my site configured safely?" | verify first: `maggie security domain-verify start --domain example.com` (the person adds the TXT record) then `maggie security domain-verify check --domain example.com`; then `maggie security headers --url https://example.com` and `maggie security tls --host example.com`; weekly `maggie security web-scan --url https://example.com` | `security_domain_verify_start`, `security_domain_verify_check`, `security_headers_check`, `security_tls_check`, `security_web_scan` |
 | "check my code before I commit" | `maggie security code-scan --changed-since HEAD` (full: `maggie security code-scan`) | `security_code_scan` |
+| "check a site we don't own (so we can tell them)" | `maggie security public-check --url https://example.com --outreach notes/` — passive only (headers, TLS, visible versions + known CVEs, SPF/DMARC, security.txt); interactive-only; never scan or probe a site you don't control (that's `web-scan`/`zap-baseline`, verified domains only) | `security_public_check` |
 | "are we being attacked / were we hacked?" | `maggie security logs-traffic --file access.log`, `maggie security logs-sigma --file access.log`, `maggie security logs-ioc --file access.log`; servers: `maggie security logs-remote --ssh web1=user@host` | `security_logs_check` |
 | "is my server hardened?" | `maggie security host-quick --ssh web1=user@host` (or `--print-collector` for the person to run), `maggie security host-nginx-config --ssh web1=user@host`, deep: `maggie security host-audit --ssh web1=user@host` | `security_host_check` |
 | "protect my server" (CrowdSec / fail2ban / Cloudflare) | `maggie security protect-plan --host web1 [--engine crowdsec\|fail2ban]` → the person reviews and runs it under the host lock; afterwards `maggie security protect-plan verify --plan FILE --ssh web1=user@host` | `security_protect_plan` |

package/bundled-skills/maggie-security/references/commands.md

@@ -53,6 +53,20 @@ findings never leave the machine.
 | `maggie security web-scan --url U [--profile safe\|full-safe]` | httpx fingerprint, then nuclei with the safe profile (no intrusive, fuzz, DoS, brute-force, OAST templates; ≤ 10 req/s; one scan per domain at a time) | the site |
 | `maggie security zap-baseline --url U` | weekly passive ZAP baseline in Docker; header rules skipped (headers covers them) | the site |
 
+## Public check (sites you do NOT control — passive only)
+
+`public-check` is the one web command that does not need domain verification,
+because it only does what any visitor already does: one GET of the home page, a
+TLS handshake, and public DNS. It never probes paths, never submits anything,
+and never runs an active scanner. Use it to spot a visible problem on someone
+else's site and tell them. It is interactive-only (refused under `--ci` or in a
+routine) and never writes to the ledger. `web-scan`, `zap-baseline` and the host
+checks stay verified-only — do not run them against a site you do not control.
+
+| Command | What it does | Contacted |
+|---|---|---|
+| `maggie security public-check --url U` / `--domain D` (repeatable) / `--domains FILE` `[--outreach DIR] [--rate N] [--max-sites N]` | per site: security headers + cookies, TLS certificate and protocols, versions disclosed on the home page (`generator` meta, `Server`/`X-Powered-By`, JS libraries) matched to known CVEs (OSV, WPVulnerability, KEV, EPSS), missing/weak SPF and DMARC, and missing `security.txt`. `--outreach` writes a disclosure-ready note per domain (what is visible, no exploit detail). | the site, system resolver, cloudflare-dns.com, api.osv.dev, wpvulnerability.net, KEV, api.first.org |
+
 ## Code
 
 | Command | What it does |

package/bundled-skills/maggie-security/registry/security-tools.registry.json

@@ -12,6 +12,10 @@
     "project-files": {
       "label": "Reads your project files",
       "modelNote": "Local server only."
+    },
+    "interactive-only": {
+      "label": "A person must run it",
+      "modelNote": "Refused under --ci or in a scheduled routine; it checks sites you do not control, so a person decides to run it."
     }
   },
   "cantDo": [
@@ -189,7 +193,7 @@
     },
     {
       "name": "security_secrets_scan",
-      "description": "Find API keys, passwords and tokens in git history, project files and served build output (dist/, public/ \u2026), including .env values copied into the build. Values are never returned: only the file, line and a 4+4 character preview. Reads project files only; contacts nothing.",
+      "description": "Find API keys, passwords and tokens in git history, project files and served build output (dist/, public/ …), including .env values copied into the build. Values are never returned: only the file, line and a 4+4 character preview. Reads project files only; contacts nothing.",
       "risk": "read",
       "scope": "workspace",
       "channels": [
@@ -353,6 +357,28 @@
         "verified-domain"
       ]
     },
+    {
+      "name": "security_public_check",
+      "description": "Passively check sites you do NOT control, the way a visitor's browser does: grade security headers, the TLS certificate, versions disclosed on the home page and their known CVEs, SPF/DMARC and security.txt. One home-page GET, a TLS handshake and public DNS only; never probes paths, submits anything or runs an active scanner. For telling an owner about a visible problem; interactive use only.",
+      "risk": "read",
+      "scope": "workspace",
+      "channels": [
+        "in-app",
+        "mcp",
+        "claude",
+        "chatgpt",
+        "cli"
+      ],
+      "idempotent": true,
+      "openWorld": true,
+      "user": {
+        "label": "Check another site passively",
+        "detail": "Browser-equivalent checks of a site you do not own, so you can tell its owner. No scanning."
+      },
+      "gates": [
+        "interactive-only"
+      ]
+    },
     {
       "name": "security_code_scan",
       "description": "Look for unsafe code patterns in the project (unescaped HTML, server-side requests to user URLs, SQL built from strings, open redirects, insecure cookies, eval, secrets in public build variables, root containers) with semgrep and Maggie's own rules. Reads project files only; no rules are downloaded.",

package/bundled-tools/clis/maggie_security_mcp.py

@@ -64,6 +64,9 @@ SCHEMAS: dict[str, dict] = {
         "host": {"type": "string", "pattern": DOMAIN}, "port": {"type": "integer", "minimum": 1, "maximum": 65535}}},
     "security_web_scan": {"type": "object", "required": ["url"], "additionalProperties": False, "properties": {
         "url": {"type": "string", "pattern": r"^https?://[A-Za-z0-9.-]+(:\d+)?(/[^\s]*)?$"}, "profile": {"enum": ["safe", "full-safe"]}}},
+    "security_public_check": {"type": "object", "additionalProperties": False, "properties": {
+        "url": {"type": "string", "pattern": r"^https?://[A-Za-z0-9.-]+(:\d+)?(/[^\s]*)?$"},
+        "domains": {"type": "array", "items": {"type": "string", "pattern": DOMAIN}, "minItems": 1, "maxItems": 50}}},
     "security_code_scan": {"type": "object", "additionalProperties": False, "properties": {
         "changed_since": {"type": "string", "pattern": r"^[A-Za-z0-9._/~^-]{1,80}$"}}},
     "security_logs_check": {"type": "object", "required": ["mode"], "additionalProperties": False, "properties": {
@@ -94,7 +97,8 @@ SCHEMAS: dict[str, dict] = {
         "confirm": {"type": "boolean"}, "confirmation": {"type": "string", "maxLength": 80}}},
 }
 NETWORK_TOOLS = {"security_vuln_watch", "security_osv_query", "security_wp_check", "security_eol_check", "security_deps_scan",
-                 "security_domain_verify_check", "security_headers_check", "security_tls_check", "security_web_scan", "security_uptime_status",
+                 "security_domain_verify_check", "security_headers_check", "security_tls_check", "security_web_scan", "security_public_check",
+                 "security_uptime_status",
                  "security_checklist_get", "security_package_vet", "security_exposure_check", "security_image_scan"}
 
 
@@ -207,6 +211,13 @@ class Server:
             return ["tls", "--host", args.get("host", "x.invalid"), "--port", str(args.get("port", 443))]
         if name == "security_web_scan":
             return ["web-scan", "--url", args.get("url", "https://x.invalid"), "--profile", args.get("profile", "safe")]
+        if name == "security_public_check":
+            argv = ["public-check"]
+            if args.get("url"):
+                argv += ["--url", args["url"]]
+            for domain in args.get("domains") or []:
+                argv += ["--domain", domain]
+            return argv
         if name == "security_code_scan":
             return ["code-scan"] + (["--changed-since", args["changed_since"]] if args.get("changed_since") else [])
         if name == "security_logs_check":

package/bundled-tools/clis/maggie_security_web.py

@@ -30,6 +30,7 @@ import ssl
 import struct
 import subprocess
 import tempfile
+import time
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -883,6 +884,303 @@ def zap_baseline(ctx: core.Context):
     return ctx.finish(findings, covered=[f"url:{url}"])
 
 
+# --------------------------------------------------------------------------- public-check (passive, browser-equivalent)
+
+# A public check only looks at what any visitor already sees: one GET of the
+# home page, a TLS handshake, and public DNS. It never probes paths, never
+# submits anything and never runs an active scanner (that is `web-scan` /
+# `zap-baseline`, which stay verified-only). The point is to spot a problem on
+# a site you do NOT control so you can tell its owner.
+
+# <meta name="generator"> product -> how to record it in a stack.
+GENERATORS = [
+    (re.compile(r"WordPress\s+([0-9]+(?:\.[0-9]+){1,2})", re.I), "wordpress-core"),
+    (re.compile(r"Drupal\s+([0-9]+(?:\.[0-9]+){0,2})", re.I), ("npm", "drupal")),
+    (re.compile(r"Joomla!?\s*-?\s*([0-9]+(?:\.[0-9]+){1,2})", re.I), ("npm", "joomla")),
+]
+# Server / X-Powered-By token -> runtime or service name used by the matchers.
+SERVER_RUNTIMES = [
+    (re.compile(r"nginx/([0-9]+(?:\.[0-9]+){1,2})", re.I), "nginx"),
+    (re.compile(r"Apache/([0-9]+(?:\.[0-9]+){1,2})", re.I), "apache"),
+    (re.compile(r"PHP/([0-9]+(?:\.[0-9]+){1,2})", re.I), "php"),
+    (re.compile(r"OpenSSL/([0-9]+(?:\.[0-9]+){1,2}[a-z]?)", re.I), "openssl"),
+]
+ASSET_RE = re.compile(r"""(?:src|href)\s*=\s*['"]([^'"]+?\.(?:js|css))(?:\?[^'"]*)?['"]""", re.I)
+GENERATOR_RE = re.compile(r"""<meta[^>]+name\s*=\s*['"]generator['"][^>]+content\s*=\s*['"]([^'"]+)['"]""", re.I)
+
+
+def resolve_txt(ctx: core.Context, name: str) -> list[str]:
+    """Best-effort TXT lookup: the system resolver, then public DoH. Never raises."""
+    values: list[str] = []
+    try:
+        servers = system_resolvers()
+        if servers:
+            values = dns_txt_udp(name, servers[0])
+    except OSError:
+        values = []
+    if not values:
+        try:
+            values = dns_txt_doh(ctx, name) or []
+        except (core.DegradedError, OSError, ValueError):
+            values = []
+    return values
+
+
+def remote_fingerprint(host: str, response: dict, site: str) -> dict:
+    """A maggie-security-stack.v1 built only from the home page a visitor receives."""
+    body = response.get("body") or b""
+    text = body.decode("utf-8", errors="replace") if isinstance(body, (bytes, bytearray)) else str(body)
+    headers = response.get("headers") or {}
+    components: list[dict] = []
+    runtimes: list[dict] = []
+    wordpress: dict = {}
+    seen: set[tuple] = set()
+
+    generator = ""
+    match = GENERATOR_RE.search(text)
+    if match:
+        generator = match.group(1)
+        for rx, target in GENERATORS:
+            got = rx.search(generator)
+            if not got:
+                continue
+            if target == "wordpress-core":
+                wordpress = {"core": got.group(1), "plugins": [], "themes": []}
+            else:
+                eco, cname = target
+                key = (eco, cname, got.group(1))
+                if key not in seen:
+                    seen.add(key)
+                    components.append({"purl": core.make_purl(eco, cname, got.group(1)), "ecosystem": eco, "name": cname,
+                                       "version": got.group(1), "scope": "runtime", "direct": True, "location": f"https://{host}/ (generator)"})
+            break
+
+    for header in ("server", "x-powered-by"):
+        value = " ".join(headers.get(header) or [])
+        for rx, name in SERVER_RUNTIMES:
+            got = rx.search(value)
+            if got and ("runtime", name) not in seen:
+                seen.add(("runtime", name))
+                runtimes.append({"name": name, "version": got.group(1), "source": f"{header} header", "host": None})
+
+    import maggie_security_inventory as inventory
+
+    extractors = inventory._retire_extractors()
+    assets = 0
+    for raw in ASSET_RE.findall(text):
+        if assets >= 40:
+            break
+        assets += 1
+        basename = raw.rstrip("/").rsplit("/", 1)[-1]
+        for lib, (name_res, _content_res, npm) in extractors.items():
+            version = None
+            for rx in name_res:
+                got = rx.search(basename)
+                if got:
+                    version = got.group(1)
+                    break
+            if not version:
+                continue
+            version = re.sub(r"([.-](min|slim|pack|prod|production|umd|esm|bundle|js))+$", "", version).rstrip(".-_")
+            key = ("npm", npm, version)
+            if key in seen:
+                break
+            seen.add(key)
+            components.append({"purl": core.make_purl("npm", npm, version), "ecosystem": "npm", "name": npm, "version": version,
+                               "scope": "runtime", "direct": None, "location": f"https://{host}/{basename}"})
+            break
+
+    site_type = "wordpress" if wordpress else "custom"
+    digest = core.sha256_bytes(core.canonical_json([components, runtimes, wordpress]).encode("utf-8"))
+    return {"schema": "maggie-security-stack.v1", "site": {"id": site, "type": site_type, "domains": [host], "hosting": None},
+            "collected_at": core.iso(), "hash": f"sha256:{digest}", "sources": [{"kind": "homepage", "path": f"https://{host}/"}],
+            "components": components, "runtimes": runtimes, "wordpress": wordpress, "images": [], "hosts": [],
+            "watch": {"products": []}, "generator": generator}
+
+
+def email_dns_findings(ctx: core.Context, host: str, site: str) -> list[dict]:
+    """Passive email-spoofing hygiene from public DNS: SPF and DMARC on the registrable domain."""
+    domain = registrable(host)
+    findings: list[dict] = []
+    spf = [v for v in resolve_txt(ctx, domain) if v.lower().startswith("v=spf1")]
+    if not spf:
+        findings.append(core.make_finding(
+            kind="misconfiguration", command="public-check", primary_id="email-spf-missing", site=site, title=f"{domain} has no SPF record",
+            severity="low", severity_source="maggie", confidence="confirmed", target={"host": domain}, asvs_ids=[],
+            remediation={"summary": "Publish an SPF TXT record so receivers can reject mail forged from this domain.", "steps": [],
+                         "snippets": [{"kind": "dns", "text": f'{domain}. TXT "v=spf1 -all"  # tighten to your real senders'}],
+                         "references": ["https://datatracker.ietf.org/doc/html/rfc7208"], "cheat_sheet": None}))
+    elif any("+all" in v.lower() for v in spf):
+        findings.append(core.make_finding(
+            kind="misconfiguration", command="public-check", primary_id="email-spf-permissive", site=site,
+            title=f"{domain} SPF ends in +all (anyone may send as this domain)", severity="medium", severity_source="maggie",
+            confidence="confirmed", target={"host": domain}, evidence=[{"path": "SPF", "excerpt": core.clean_excerpt(spf[0], 200)}],
+            remediation={"summary": "Replace +all with -all (or ~all) so forged senders are rejected.", "steps": [], "snippets": [],
+                         "references": [], "cheat_sheet": None}))
+    dmarc = [v for v in resolve_txt(ctx, f"_dmarc.{domain}") if v.lower().startswith("v=dmarc1")]
+    if not dmarc:
+        findings.append(core.make_finding(
+            kind="misconfiguration", command="public-check", primary_id="email-dmarc-missing", site=site, title=f"{domain} has no DMARC record",
+            severity="low", severity_source="maggie", confidence="confirmed", target={"host": f"_dmarc.{domain}"}, asvs_ids=[],
+            remediation={"summary": "Publish a DMARC record so spoofed mail is reported and (later) rejected.", "steps": [],
+                         "snippets": [{"kind": "dns", "text": f'_dmarc.{domain}. TXT "v=DMARC1; p=none; rua=mailto:dmarc@{domain}"'}],
+                         "references": ["https://datatracker.ietf.org/doc/html/rfc7489"], "cheat_sheet": None}))
+    elif any(re.search(r"\bp\s*=\s*none\b", v, re.I) for v in dmarc):
+        findings.append(core.make_finding(
+            kind="misconfiguration", command="public-check", primary_id="email-dmarc-none", site=site,
+            title=f"{domain} DMARC policy is p=none (monitoring only, no enforcement)", severity="info", severity_source="maggie",
+            confidence="confirmed", target={"host": f"_dmarc.{domain}"}, evidence=[{"path": "DMARC", "excerpt": core.clean_excerpt(dmarc[0], 200)}],
+            remediation={"summary": "Once reports look clean, move the policy to quarantine then reject.", "steps": [], "snippets": [],
+                         "references": [], "cheat_sheet": None}))
+    return findings
+
+
+def securitytxt_finding(ctx: core.Context, base: str, host: str, site: str) -> dict | None:
+    """One GET of /.well-known/security.txt; a missing file is an info nudge, not a risk."""
+    try:
+        response = fetch(urllib.parse.urljoin(base + "/", "/.well-known/security.txt"), follow=False, timeout=10)
+    except (OSError, ssl.SSLError):
+        return None
+    if response.get("status") == 200 and b"contact" in (response.get("body") or b"").lower():
+        return None
+    return core.make_finding(
+        kind="misconfiguration", command="public-check", primary_id="no-security-txt", site=site,
+        title="No security.txt: no published way to report a vulnerability", severity="info", severity_source="maggie",
+        confidence="confirmed", target={"url": f"https://{host}/.well-known/security.txt", "host": host}, asvs_ids=[],
+        remediation={"summary": "Publish /.well-known/security.txt with a Contact: line so researchers can reach you.", "steps": [],
+                     "snippets": [{"kind": "text", "text": f"Contact: mailto:security@{registrable(host)}\nExpires: <date>"}],
+                     "references": ["https://www.rfc-editor.org/rfc/rfc9116"], "cheat_sheet": None})
+
+
+def advisory_findings_remote(ctx: core.Context, stack: dict) -> tuple[list[dict], list[str]]:
+    """Run the same advisory engine as vuln-watch over the passively-built remote stack."""
+    import maggie_security_intel as intel
+
+    findings: list[dict] = []
+    notes: list[str] = []
+    try:
+        osv, ok = intel.match_osv(ctx, stack, "public-check")
+        findings += osv
+        if not ok:
+            notes.append("OSV lookup was degraded; version advisories may be incomplete")
+        soft, _cov = intel.software_findings(ctx, stack, "public-check")
+        findings += soft
+        if stack.get("wordpress", {}).get("core"):
+            wp, wp_ok = intel.wordpress_findings(ctx, stack, "public-check", budget=1)
+            findings += wp
+            if not wp_ok:
+                notes.append("WordPress advisory lookup was degraded")
+        kev = intel.load_kev(ctx)
+        intel.apply_kev(findings, kev, stack)
+        intel.join_epss(ctx, findings)
+    except core.DegradedError as error:
+        notes.append(f"advisory lookup degraded: {core.clean_excerpt(str(error), 160)}")
+    return findings, notes
+
+
+SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
+
+
+def outreach_markdown(host: str, findings: list[dict]) -> str:
+    """A disclosure-ready note for the site owner: what is visible, not how to exploit it."""
+    by_sev: dict[str, list[dict]] = {}
+    for f in findings:
+        by_sev.setdefault(f["severity"], []).append(f)
+    lines = [f"# Security notes for {host}", "",
+             "We ran only passive checks — the same requests any visitor's browser makes "
+             "(your home page, a TLS handshake, and public DNS). We did not probe, log in, "
+             "or scan. Here is what is publicly visible, so you can decide what to fix.", ""]
+    actionable = [s for s in ("critical", "high", "medium", "low") if by_sev.get(s)]
+    if not actionable:
+        lines += ["Nothing notable was visible from the outside. ", ""]
+    for sev in ("critical", "high", "medium", "low", "info"):
+        items = sorted(by_sev.get(sev) or [], key=lambda f: f["title"])
+        if not items:
+            continue
+        lines.append(f"## {sev.title()}")
+        for f in items:
+            fix = (f.get("remediation") or {}).get("summary") or ""
+            lines.append(f"- **{f['title']}**" + (f" — {fix}" if fix else ""))
+        lines.append("")
+    lines += ["---",
+              "_Sent by <your name / company>. We have no affiliation with this site and "
+              "hold no further details beyond the public observations above. If you would "
+              "rather not hear from us again, just reply and we will stop._"]
+    return "\n".join(lines)
+
+
+def _public_targets(args) -> list[str]:
+    """Base URLs to check, de-duplicated; a bare domain becomes https://domain/."""
+    raw: list[str] = []
+    if getattr(args, "url", None):
+        raw.append(args.url)
+    raw += list(getattr(args, "domain", None) or [])
+    if getattr(args, "domains", None):
+        for line in Path(args.domains).read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line and not line.startswith("#"):
+                raw.append(line)
+    bases = [(item if "://" in item else f"https://{item}") for item in raw]
+    return list(dict.fromkeys(b for b in bases if host_of(b)))
+
+
+def public_check(ctx: core.Context):
+    args = ctx.args
+    ctx.args.no_ledger = True  # these are other people's sites: never touch the local ledger
+    bases = _public_targets(args)
+    if not bases:
+        raise core.UsageError("give --url, one or more --domain, or --domains FILE")
+    if len(bases) > args.max_sites:
+        raise core.PolicyError(f"{len(bases)} domains exceeds --max-sites {args.max_sites}; raise it deliberately")
+    outreach_dir = Path(args.outreach) if args.outreach else None
+    if outreach_dir:
+        outreach_dir.mkdir(parents=True, exist_ok=True)
+    all_findings: list[dict] = []
+    sites: list[dict] = []
+    for index, base in enumerate(bases):
+        host = host_of(base)
+        if index:
+            time.sleep(max(0.0, 1.0 / max(args.rate, 0.2)))  # be a polite visitor between sites
+        require_ownership(ctx, host, public_check=True)  # interactive-only; refuses in CI/routines
+        entry = {"host": host, "notes": []}
+        try:
+            response = fetch(urllib.parse.urljoin(base + "/", "/"), timeout=15)
+        except (OSError, ssl.SSLError) as error:
+            entry["notes"].append(f"home page not reachable: {core.clean_excerpt(str(error), 160)}")
+            sites.append(entry)
+            continue
+        if response.get("left_domain"):
+            entry["notes"].append(f"redirects off-domain to {response['left_domain']}; checked only the first response")
+        # The remote site is unrelated to the local project, so detect the serving
+        # layer from its response headers alone, never from files on this machine.
+        layer = detect_serving(Path("/nonexistent-maggie-prospect"), response["headers"], "auto")
+        findings = grade_response(ctx, response["url"], response, layer, response["url"].startswith("https://"))
+        findings += native_tls(ctx, host, 443, None)
+        stack = remote_fingerprint(host, response, ctx.site)
+        entry["detected"] = {"generator": stack.get("generator") or None,
+                             "components": [f"{c['name']} {c['version']}" for c in stack["components"]],
+                             "runtimes": [f"{r['name']} {r['version']}" for r in stack["runtimes"]]}
+        advisories, notes = advisory_findings_remote(ctx, stack)
+        findings += advisories
+        entry["notes"] += notes
+        findings += email_dns_findings(ctx, host, ctx.site)
+        sec = securitytxt_finding(ctx, base, host, ctx.site)
+        if sec:
+            findings.append(sec)
+        for f in findings:
+            f.setdefault("target", {}).setdefault("host", host)
+        entry["counts"] = {s: sum(1 for f in findings if f["severity"] == s) for s in SEVERITY_ORDER if any(x["severity"] == s for x in findings)}
+        all_findings += findings
+        if outreach_dir:
+            report = outreach_dir / f"{registrable(host)}.md"
+            report.write_text(outreach_markdown(host, findings), encoding="utf-8")
+            entry["outreach"] = str(report)
+        sites.append(entry)
+    all_findings.sort(key=lambda f: (SEVERITY_ORDER.get(f["severity"], 9), f["title"]))
+    ctx.run["inputs"].update({"mode": "public-check (passive, unverified)", "sites": sites, "label": "unverified domains (public check)"})
+    return ctx.finish(all_findings, covered=[f"url:{host_of(b)}" for b in bases])
+
+
 # --------------------------------------------------------------------------- registration
 
 
@@ -923,6 +1221,15 @@ def _zap(p: argparse.ArgumentParser) -> None:
     p.add_argument("--image", help="pinned ZAP image reference (default ghcr.io/zaproxy/zaproxy:stable)")
 
 
+def _public(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--url", help="one site to check")
+    p.add_argument("--domain", action="append", help="a domain to check (repeatable)")
+    p.add_argument("--domains", help="file with one domain per line")
+    p.add_argument("--outreach", help="write a disclosure-ready note per domain into this directory")
+    p.add_argument("--rate", type=float, default=0.5, help="sites per second between domains (default 0.5)")
+    p.add_argument("--max-sites", type=int, default=50, help="refuse a run with more domains than this")
+
+
 COMMANDS = [
     core.Command("domain-verify", "prove you control a domain (DNS TXT or a token file) before any active check", ["doh", "dns", "target-site"], _dv,
                  domain_verify, findings=False),
@@ -933,4 +1240,8 @@ COMMANDS = [
                  _scan, web_scan),
     core.Command("zap-baseline", "weekly passive ZAP baseline scan of your verified site (Docker)", ["target-site", "doh", "dns"], _zap, zap_baseline,
                  routine_safe=False),
+    core.Command("public-check",
+                 "passive, browser-equivalent checks of sites you do not control (headers, TLS, visible versions and their known CVEs, SPF/DMARC, "
+                 "security.txt) so you can tell the owner; never probes or scans",
+                 ["target-site", "doh", "dns", "osv-api", "wpvulnerability", "kev", "epss"], _public, public_check, routine_safe=False),
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topy-ai/maggie",
-  "version": "0.7.56",
+  "version": "0.7.57",
   "description": "Install and manage Maggie Skills for AI coding agents",
   "license": "MIT",
   "type": "module",