mosaic-headless 1.2.0

package/tools/sweep_node_properties.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""Re-probe node properties with a value shaped by their own validator chain.
+
+    python sweep_node_properties.py --config sweep.json --page moksa --csv out.csv
+
+Why this exists
+---------------
+`data/property-verification.csv` reports 91 of 170 probes as NO_EFFECT. That number
+is not a finding about Mosaic - it is an artefact of the probe. Every property in
+that run was sent the same string, `MPROP0000X`, regardless of what it wanted:
+
+    cssClasses    ValidatorArray      -> wanted a list
+    locked        ValidatorBoolean    -> wanted true/false
+    required      ValidatorInteger    -> wanted a number
+    target        ValidatorAccepted…  -> wanted one of _self|_blank|_parent|_top
+    tagName       ValidatorTagName    -> wanted a tag name
+
+The tell is that `tagName` and `attrID` are both in the NO_EFFECT list while the
+entire demo site is built on them. Same signature as the style sweep, where `color`
+and `paddingTop` came back ABSENT because the probe nodes were orphaned: when a
+sweep says something you know to be false, the sweep is what is broken.
+
+So this one derives the probe value from the declared validator chain, and asserts
+against the delivered markup rather than against a marker in the text.
+
+Statuses
+--------
+    APPLIED     the property changed the delivered HTML in the way it claims to
+    NO_EFFECT   correctly shaped value, committed, nothing changed in the markup
+    SKIPPED     no value could be derived from the validator chain; NOT a pass
+"""
+import argparse
+import csv
+import json
+import os
+import re
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from build_page import Surface, flatten  # noqa: E402
+from sweep_node_types import Client, envelopes, exceptions_of, unwrap  # noqa: E402
+
+MARK = "mprobe37"
+# 7 collided with the attrID (np-037) and the generated class (M_EL37), turning
+# substring checks into false APPLIEDs. Use a number that cannot occur by chance.
+MARK_INT = 371337
+
+# The base class every element data class extends. Properties declared on it apply
+# to every node type, so there is no concrete type to look them up by.
+ABSTRACT = "ElementMResourceDataAbstract"
+
+# Properties that are editor state by definition - they describe the node to the
+# builder UI and are not meant to reach the page. Probed anyway, but a NO_EFFECT on
+# these is the correct answer rather than a gap.
+EDITOR_ONLY = {"name", "locked", "currentStatus", "override"}
+
+
+ALPHA = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+
+def ordering(i):
+    """A monotonic fractional index with room for every probe.
+
+    build_page.ordering_for() wraps after 62 entries, so `i % 62` hands two siblings
+    the SAME ordering - and Mosaic drops the collisions silently. That is how a run
+    of 79 probes left 39 nodes in the database and still reported a result.
+    """
+    return "a" + ALPHA[i // 62] + ALPHA[i % 62]
+
+
+def kebab(name):
+    return re.sub(r"(?<!^)(?=[A-Z])", "-", name).lower()
+
+
+def probe_value(row):
+    """Derive a value from the validator chain, or None if we cannot."""
+    prop = row["property"]
+    chain = row.get("validators") or ""
+    enum = [v for v in (row.get("accepted_values") or "").split("|") if v]
+
+    if prop == "attrID":
+        return None                       # the sweep's own handle; cannot also test it
+    if prop == "style":
+        return None                       # a whole subsystem, swept separately
+    if prop == "cssClasses":
+        return [MARK + "-cls"]
+    if prop == "attributes":
+        return [{"name": "data-" + MARK, "value": "yes"}]
+    if prop == "tagName":
+        return "h4"
+    if enum:
+        return enum[-1] if enum[-1] != "inPlace" else enum[0]
+    if "ValidatorBoolean" in chain:
+        return True
+    if "ValidatorArray" in chain:
+        return [MARK]
+    if "ValidatorInteger" in chain:
+        return MARK_INT
+    if "ValidatorString" in chain or "ValidatorName" in chain:
+        return MARK
+    return None
+
+
+def opening_tag(html, attr):
+    m = re.search(r"<([a-zA-Z][\w-]*)\s[^>]*id=\"%s\"[^>]*>" % re.escape(attr), html)
+    return m.group(0) if m else None
+
+
+def searchable(tag):
+    """The tag with `id` and `class` removed.
+
+    Both carry the probe's own index and the generated M_EL number, so leaving them
+    in lets a value like `7` match itself and score a false APPLIED.
+    """
+    tag = re.sub(r'\sid="[^"]*"', "", tag)
+    return re.sub(r'\sclass="[^"]*"', "", tag)
+
+
+def judge(prop, value, tag):
+    """Did this property change the delivered markup the way it claims to?"""
+    if tag is None:
+        return "NO_ELEMENT", ""
+    body = searchable(tag)
+    if prop == "cssClasses":
+        return ("APPLIED" if MARK + "-cls" in tag else "NO_EFFECT"), tag[:110]
+    if prop == "attributes":
+        return ("APPLIED" if "data-" + MARK in body else "NO_EFFECT"), tag[:110]
+    if prop == "tagName":
+        return ("APPLIED" if tag.startswith("<h4") else "NO_EFFECT"), tag[:60]
+    if isinstance(value, str) and value and value in body:
+        return "APPLIED", tag[:110]
+    if isinstance(value, bool):
+        return ("APPLIED" if re.search(r"\b(hidden|disabled|readonly|required)\b", tag)
+                else "NO_EFFECT"), tag[:110]
+    if isinstance(value, int) and str(value) in body:
+        return "APPLIED", tag[:110]
+    if isinstance(value, list) and MARK in body:
+        return "APPLIED", tag[:110]
+    return "NO_EFFECT", tag[:110]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--config", required=True)
+    ap.add_argument("--page", required=True)
+    ap.add_argument("--csv")
+    a = ap.parse_args()
+
+    cfg = json.load(open(a.config, encoding="utf-8"))
+    here = os.path.dirname(os.path.abspath(__file__))
+    props = list(csv.DictReader(
+        open(os.path.join(here, "..", "data", "node-properties.csv"), encoding="utf-8")))
+    types = {r["type"]: r for r in csv.DictReader(
+        open(os.path.join(here, "..", "data", "node-types.csv"), encoding="utf-8"))}
+
+    # A property is probed on a node type that actually declares it: owner_class in
+    # node-properties.csv matches data_class in node-types.csv. Properties on the
+    # abstract base apply to everything, so those go on a div.
+    rendered = {r["type"] for r in csv.DictReader(
+        open(os.path.join(here, "..", "data", "node-verification.csv"),
+             encoding="utf-8")) if r["outcome"] == "RENDERED"}
+    by_class = {}
+    for r in types.values():
+        by_class.setdefault(r["data_class"], []).append(r["type"])
+
+    plan = []
+    for row in props:
+        value = probe_value(row)
+        if value is None:
+            plan.append((None, row["property"], None, "SKIPPED"))
+            continue
+        if row["owner_class"] == ABSTRACT:
+            hosts = ["div"]
+        else:
+            hosts = [t for t in by_class.get(row["owner_class"], []) if t in rendered]
+        if not hosts:
+            plan.append((None, row["property"], None, "NO_HOST"))
+            continue
+        plan.append((hosts[0], row["property"], value, None))
+
+    client = Client(cfg)
+    tei = unwrap(client.get("adminTemplateEditorInstance"), "adminTemplateEditorInstance")
+    master = tei["template"][-1]["masterID"]
+    instance = "masterDocumentInstance/%s" % master
+    doc = unwrap(client.get(instance), "masterDocumentInstance")
+    key = "node/master/%s" % master
+    body = next(n for n in doc[key] if n["type"] == "body")
+    host_div = next(n for n in doc[key]
+                    if n["parentID"] == body["ID"] and n["type"] == "div")
+    surface = Surface()
+
+    records, live, moved = [], [], set()
+    for i, (host, prop, value, pre) in enumerate(plan):
+        if pre is not None or host is None:
+            continue
+        attr = "np-%03d" % i
+        data = {"attrID": attr, prop: value}
+        # target and rel are anchor attributes, and button/menu-link only render an
+        # <a> when they carry a url - without one they are a <span> and the probe
+        # measures the missing companion rather than the property.
+        if prop in ("target", "rel"):
+            data["url"] = "https://example.com/" + MARK
+        node = {"type": host, "data": data}
+        if host == "text":
+            node["children"] = [{"type": "wysiwyg-text", "data": {"text": MARK}}]
+        live.append((attr, host, prop, value))
+        # `insertLocation` moves a code node's output out of the tree, so the probe
+        # correctly leaves no element where it was written. Absence IS the evidence.
+        if prop == "insertLocation" and value != "inPlace":
+            moved.add(attr)
+        for rec in flatten(node, host_div["ID"], master, surface, True,
+                           ordering=ordering(i), parent_type="div"):
+            records.append({"newRevisionRecord": rec, "originalRevisionRecord": None})
+
+    print("%d properties, %d probes, %d skipped"
+          % (len(props), len(live),
+             sum(1 for p in plan if p[3] in ("SKIPPED", "NO_HOST"))))
+    resp = client.commit(instance, envelopes(doc), {key: records})
+    err = exceptions_of(resp)
+    if err:
+        sys.exit("commit rejected: %s" % err[:400])
+
+    html = client.page(a.page)
+    rendered = len(set(re.findall(r'id="(np-\d+)"', html)))
+    print("probes rendered: %d of %d" % (rendered, len(live)))
+    if rendered != len(live) - len(moved):
+        # Contamination is the failure mode this sweep is most exposed to: probes
+        # from an earlier run share the id space, and two runs can give the same id
+        # to different node types. If the page does not carry exactly the probes
+        # this run planned, nothing measured from it means anything.
+        sys.exit("expected %d probes on the page, found %d - clear previous probes "
+                 "and re-run before believing any measurement"
+                 % (len(live) - len(moved), rendered))
+
+    rows = []
+    for attr, host, prop, value in live:
+        if attr in moved:
+            gone = opening_tag(html, attr) is None
+            rows.append([prop, host, json.dumps(value, ensure_ascii=False),
+                         "APPLIED" if gone else "NO_EFFECT",
+                         "output relocated out of the tree" if gone else "still in place"])
+            continue
+        status, evidence = judge(prop, value, opening_tag(html, attr))
+        if status == "NO_EFFECT" and prop in EDITOR_ONLY:
+            status = "EDITOR_ONLY"
+        rows.append([prop, host, json.dumps(value, ensure_ascii=False), status, evidence])
+    for host, prop, value, pre in plan:
+        if pre in ("SKIPPED", "NO_HOST"):
+            rows.append([prop, "", "", pre, ""])
+
+    counts = {}
+    for r in rows:
+        counts[r[3]] = counts.get(r[3], 0) + 1
+    print()
+    for k in ("APPLIED", "NO_EFFECT", "EDITOR_ONLY", "NO_ELEMENT", "NO_HOST",
+              "SKIPPED"):
+        if counts.get(k):
+            print("  %-12s %d" % (k, counts[k]))
+    applied = sorted({r[0] for r in rows if r[3] == "APPLIED"})
+    print("\n  APPLIED:", ", ".join(applied) or "-")
+
+    if a.csv:
+        with open(a.csv, "w", newline="", encoding="utf-8") as fh:
+            w = csv.writer(fh)
+            w.writerow(["property", "probed_on", "sent", "status", "evidence"])
+            w.writerows(sorted(rows))
+        print("\nwrote", a.csv)
+
+
+if __name__ == "__main__":
+    main()

package/tools/sweep_node_types.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""Place every node type on a real Mosaic document, ONE AT A TIME, and record what happened.
+
+    python sweep_node_types.py --config sweep.json --setup            # build master + template
+    python sweep_node_types.py --config sweep.json --sweep            # run the isolated sweep
+
+sweep.json needs: base, version, cookie, nonce, themeID. --setup fills in masterID,
+templateID and parentNodeID and writes them back.
+
+## Why one at a time
+
+A batch sweep is worthless here. Mosaic accepts structurally impossible placements at
+commit time - a second `master-root` nested inside a `div` commits fine - and then the
+*whole page* fails to render, emitting a bare string like
+`NodeMResourceFilterFunctionInterface parent is missing` as a 200 with a ~54 byte body.
+One bad type therefore destroys the evidence for every other type in the same batch.
+
+So each type gets the document to itself: commit -> render -> classify -> delete. A type
+that breaks the page only reports its own failure, and the next type starts from a clean
+tree. This costs one page load per type and is the only way the numbers mean anything.
+
+## Outcomes
+
+    RENDERED    committed, and its attrID appeared in the delivered HTML
+    COMMITTED   the row exists but nothing reached the page (usually needs content
+                or a specific parent to produce output)
+    BROKE_PAGE  committed, and the page stopped rendering - the silent-failure case
+    REJECTED    the commit came back with an `exceptions` body (HTTP 200)
+"""
+import argparse
+import csv
+import json
+import re
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+
+MARKER = "MOSAICSWEEP"
+# types whose job is to hold text get a wysiwyg-text child, so the assertion has
+# something to find beyond the wrapper element
+TEXT_HOLDERS = {"text", "button", "menu-link", "label", "submit-label", "accordion-title"}
+# a healthy render of the probe page is far bigger than this; anything smaller is
+# Mosaic's bare error string rather than a page
+MIN_HEALTHY_BYTES = 2000
+
+
+class Client:
+    def __init__(self, cfg):
+        self.cfg = cfg
+        self.base = cfg["base"].rstrip("/")
+        self.api = "%s/wp-json/mosaic/v%s" % (self.base, cfg["version"])
+
+    def _call(self, url, form=None):
+        data = urllib.parse.urlencode(form).encode() if form else None
+        req = urllib.request.Request(url, data=data, method="POST" if form else "GET")
+        req.add_header("Cookie", self.cfg["cookie"])
+        req.add_header("X-WP-Nonce", self.cfg["nonce"])
+        if form:
+            req.add_header("Content-Type", "application/x-www-form-urlencoded")
+        try:
+            with urllib.request.urlopen(req, timeout=120) as r:
+                return json.loads(r.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            return {"_httperror": e.code, "_body": e.read().decode("utf-8", "replace")[:400]}
+
+    def theme_url(self, tail):
+        return "%s/theme/%s/%s" % (self.api, self.cfg["themeID"], tail)
+
+    def get(self, tail):
+        return self._call(self.theme_url(tail))
+
+    def commit(self, tail, sync, revisions):
+        return self._call(
+            self.theme_url(tail + "/commit"),
+            {"syncCheckEnvelopes": json.dumps(sync), "revisionEnvelopes": json.dumps(revisions)},
+        )
+
+    def page(self, path=""):
+        """Fetch a public page, cache-busted. `path` picks a page other than the home page."""
+        req = urllib.request.Request("%s/%s?sweep=%s" % (self.base, path.strip("/") + "/" if path else "",
+                                                         uuid.uuid4().hex[:8]))
+        try:
+            with urllib.request.urlopen(req, timeout=120) as r:
+                return r.read().decode("utf-8", "replace")
+        except urllib.error.HTTPError as e:
+            return e.read().decode("utf-8", "replace")
+
+
+def envelopes(doc):
+    return {k: [[x["ID"], x["revision"]] for x in v] for k, v in doc.items()}
+
+
+def exceptions_of(resp):
+    """Mosaic returns validator rejections as HTTP 200 with an `exceptions` body."""
+    if "_httperror" in resp:
+        return "http%s: %s" % (resp["_httperror"], resp["_body"][:200])
+    for holder in (resp, resp.get("response") or {}):
+        if isinstance(holder, dict) and holder.get("exceptions"):
+            return json.dumps(holder["exceptions"], ensure_ascii=False)[:300]
+    return ""
+
+
+def unwrap(resp, what):
+    if "_httperror" in resp or "response" not in resp:
+        sys.exit("%s failed: %s" % (what, json.dumps(resp)[:400]))
+    return resp["response"]
+
+
+def setup(client, cfg, config_path):
+    """Create the master (which heals into a default node tree) and the template."""
+    tei = unwrap(client.get("adminMasterEditorInstance"), "adminMasterEditorInstance")
+    master_id = str(uuid.uuid4())
+    resp = client.commit(
+        "adminMasterEditorInstance",
+        envelopes(tei),
+        {
+            "master": [
+                {
+                    "newRevisionRecord": {
+                        "ID": master_id, "parentType": "", "parentID": "", "ordering": "a0",
+                        "status": "publish", "revision": "", "version": "", "name": "Sweep Master",
+                    },
+                    "originalRevisionRecord": None,
+                }
+            ]
+        },
+    )
+    err = exceptions_of(resp)
+    if err:
+        sys.exit("master commit rejected: %s" % err)
+
+    # opening the document instance is what heals the default tree into existence
+    doc = unwrap(client.get("masterDocumentInstance/%s" % master_id), "masterDocumentInstance")
+    nodes = doc["node/master/%s" % master_id]
+    divs = sorted([n for n in nodes if n["type"] == "div"], key=lambda n: n["ordering"])
+    if not divs:
+        sys.exit("healed master has no div to hang probes on")
+    parent = divs[0]["ID"]
+
+    tei = unwrap(client.get("adminTemplateEditorInstance"), "adminTemplateEditorInstance")
+    template_id = str(uuid.uuid4())
+    resp = client.commit(
+        "adminTemplateEditorInstance",
+        envelopes(tei),
+        {
+            "template": [
+                {
+                    "newRevisionRecord": {
+                        "ID": template_id, "parentType": "", "parentID": "", "ordering": "a0",
+                        "status": "publish", "revision": "", "version": "", "name": "Sweep Home",
+                        "masterID": master_id, "assign": "auto", "path": "archive-post.php",
+                        "conditions": [],
+                    },
+                    "originalRevisionRecord": None,
+                }
+            ]
+        },
+    )
+    err = exceptions_of(resp)
+    if err:
+        sys.exit("template commit rejected: %s" % err)
+
+    cfg.update({"masterID": master_id, "templateID": template_id, "parentNodeID": parent})
+    with open(config_path, "w", encoding="utf-8") as fh:
+        json.dump(cfg, fh, indent=1)
+    print("masterID=%s\ntemplateID=%s\nparentNodeID=%s" % (master_id, template_id, parent))
+
+    html = client.page()
+    print("baseline page: %d bytes%s" % (len(html), "" if len(html) >= MIN_HEALTHY_BYTES else "  <-- ALREADY BROKEN"))
+
+
+def probe_records(node_type, parent_id, master_id):
+    nid = str(uuid.uuid4())
+    attr = "sweep-%s" % node_type
+    base = {
+        "parentType": "node", "parentID": parent_id, "ordering": "a0", "status": "publish",
+        "revision": "", "version": "", "documentType": "master", "documentID": master_id,
+    }
+    recs = [{"newRevisionRecord": dict(base, ID=nid, type=node_type, data={"attrID": attr}),
+             "originalRevisionRecord": None}]
+    if node_type in TEXT_HOLDERS:
+        recs.append(
+            {"newRevisionRecord": dict(base, ID=str(uuid.uuid4()), parentID=nid, type="wysiwyg-text",
+                                       data={"text": "%s_%s" % (MARKER, node_type)}),
+             "originalRevisionRecord": None}
+        )
+    return attr, nid, recs
+
+
+def delete_subtree(client, master_id, keep_ids, parent_id=None):
+    """Remove the probe nodes, leaving the healed skeleton alone.
+
+    Deleting "everything not in the original baseline" does not work: heal() rebuilds
+    the master-root > document > body skeleton with FRESH ids whenever it decides one
+    is missing, so a fixed baseline id set marks those rebuilds as garbage, deletes
+    them, and heal makes new ones again - the document grows every round and later
+    types get measured on a dirty tree. Scope the delete to the probe parent's own
+    descendants instead, which the skeleton is never part of.
+    """
+    doc = unwrap(client.get("masterDocumentInstance/%s" % master_id), "masterDocumentInstance")
+    key = "node/master/%s" % master_id
+    if parent_id:
+        by_parent = {}
+        for n in doc[key]:
+            by_parent.setdefault(n["parentID"], []).append(n)
+        doomed, stack = [], list(by_parent.get(parent_id, []))
+        while stack:
+            n = stack.pop()
+            doomed.append(n)
+            stack.extend(by_parent.get(n["ID"], []))
+    else:
+        doomed = [n for n in doc[key] if n["ID"] not in keep_ids]
+    if not doomed:
+        return
+    # delete deepest-first so a parent never disappears out from under its child
+    depth = {n["ID"]: n for n in doc[key]}
+
+    def rank(n):
+        d, cur = 0, n
+        while cur and cur.get("parentType") == "node" and cur["parentID"] in depth:
+            cur = depth[cur["parentID"]]
+            d += 1
+        return -d
+
+    revisions = [
+        {"newRevisionRecord": dict(n, status="delete"), "originalRevisionRecord": n}
+        for n in sorted(doomed, key=rank)
+    ]
+    client.commit("masterDocumentInstance/%s" % master_id, envelopes(doc), {key: revisions})
+
+
+def sweep(client, cfg, types, out_path):
+    master_id = cfg["masterID"]
+    doc = unwrap(client.get("masterDocumentInstance/%s" % master_id), "masterDocumentInstance")
+    key = "node/master/%s" % master_id
+    baseline_ids = {n["ID"] for n in doc[key]}
+
+    baseline_html = client.page()
+    if len(baseline_html) < MIN_HEALTHY_BYTES:
+        sys.exit("baseline page is already broken (%d bytes); reset the theme first" % len(baseline_html))
+    print("baseline: %d bytes, %d nodes\n" % (len(baseline_html), len(baseline_ids)))
+
+    rows = []
+    for node_type in types:
+        doc = unwrap(client.get("masterDocumentInstance/%s" % master_id), "masterDocumentInstance")
+        attr, _nid, recs = probe_records(node_type, cfg["parentNodeID"], master_id)
+        resp = client.commit("masterDocumentInstance/%s" % master_id, envelopes(doc), {key: recs})
+        err = exceptions_of(resp)
+
+        if err:
+            # a 5xx is a PHP fatal on the server, not a graceful validator rejection -
+            # the two say very different things about whether the type is usable
+            code = resp.get("_httperror")
+            outcome = "COMMIT_%d" % code if code and code >= 500 else "REJECTED"
+            if code:
+                err = "PHP fatal / gateway error during commit"
+            tag, classes, echoed, size = "", "", "", ""
+        else:
+            html = client.page()
+            size = len(html)
+            if size < MIN_HEALTHY_BYTES:
+                outcome, tag, classes, echoed = "BROKE_PAGE", "", "", ""
+                err = html.strip()[:200]
+            else:
+                m = re.search(r'<([a-zA-Z0-9-]+)([^>]*\bid="%s"[^>]*)>' % re.escape(attr), html)
+                if m:
+                    outcome, tag = "RENDERED", m.group(1)
+                    c = re.search(r'class="([^"]*)"', m.group(2))
+                    classes = c.group(1) if c else ""
+                else:
+                    outcome, tag, classes = "COMMITTED", "", ""
+                echoed = "yes" if ("%s_%s" % (MARKER, node_type)) in html else ""
+
+        rows.append({"type": node_type, "outcome": outcome, "rendered_tag": tag,
+                     "rendered_classes": classes, "text_echoed": echoed,
+                     "page_bytes": size, "detail": err})
+        print("%-40s %-11s %s" % (node_type, outcome, tag or err[:60]), flush=True)
+        delete_subtree(client, master_id, baseline_ids, cfg["parentNodeID"])
+
+    with open(out_path, "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=list(rows[0].keys()))
+        w.writeheader()
+        w.writerows(rows)
+
+    tally = {}
+    for r in rows:
+        tally[r["outcome"]] = tally.get(r["outcome"], 0) + 1
+    print("\n" + "  ".join("%s=%d" % kv for kv in sorted(tally.items())) + "  -> %s" % out_path)
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--config", required=True)
+    ap.add_argument("--setup", action="store_true")
+    ap.add_argument("--sweep", action="store_true")
+    ap.add_argument("--types", help="comma-separated subset; overrides --edition")
+    ap.add_argument("--edition", default="all", choices=["all", "free", "pro"],
+                    help="which slice of node-types.csv to sweep (default: all)")
+    ap.add_argument("--node-types-csv", default="../data/node-types.csv")
+    ap.add_argument("--out", default="../data/node-verification.csv")
+    a = ap.parse_args()
+
+    cfg = json.load(open(a.config, encoding="utf-8"))
+    client = Client(cfg)
+    if a.setup:
+        setup(client, cfg, a.config)
+    if a.sweep:
+        if a.types:
+            wanted = a.types.split(",")
+        else:
+            with open(a.node_types_csv, encoding="utf-8") as fh:
+                wanted = [r["type"] for r in csv.DictReader(fh)
+                          if a.edition in ("all", r["edition"])]
+        sweep(client, cfg, wanted, a.out)
+    if not (a.setup or a.sweep):
+        ap.error("pass --setup and/or --sweep")