mosaic-headless 1.2.0

package/tools/extract_placement.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Extract Mosaic's parent -> child placement rules from the node type factories.
+
+    python extract_placement.py <path-to-mosaic-plugin-root> <out-data-dir>
+
+Writes placement-rules.csv: one row per node type, saying which children it accepts.
+
+## Why this table matters more than it looks
+
+`canBeParentFor()` is the rule the *editor* uses to stop you dropping an element
+somewhere impossible. The REST commit path does not consult it. A node committed under
+an illegal parent is stored happily, HTTP 200, and the public page then dies with a
+bare error string (see references/failure-modes.md).
+
+So for anything writing Mosaic headlessly this is not documentation - it is the
+guardrail the API declines to enforce. Check the parent before you commit the child.
+
+## Reading the output
+
+    rule = any     canBeParentFor returns true unconditionally - takes any child
+    rule = none    returns false (the default on NodeTypeFactoryAbstract) - a leaf
+    rule = allow   accepts only the types in allowed_children
+    rule = complex the method body is not a simple instanceof chain; read the file
+
+`nested_rule` flags types that also implement `canBeNestedChildFor`, which adds a
+runtime ancestry condition a static parse cannot resolve (e.g. "only inside an
+accordion, and not under an accordion title"). Those need the source read, and the
+column names the file.
+"""
+import csv
+import os
+import re
+import sys
+
+RE_CLASS = re.compile(r"^\s*(?:final\s+)?(?:abstract\s+)?class\s+(\w+)\s+extends\s+(\w+)", re.M)
+RE_CAN_BE_PARENT = re.compile(
+    r"function\s+canBeParentFor\s*\([^)]*\)\s*:\s*bool\s*\{(.*?)\n    \}", re.S
+)
+RE_INSTANCEOF = re.compile(r"instanceof\s+(\w+)")
+RE_CTOR = re.compile(r"parent::__construct\s*\(\s*\$\w+\s*,\s*'([^']+)'", re.S)
+
+
+def read(path):
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        return fh.read()
+
+
+def walk(root, suffix):
+    for dirpath, _dirs, files in os.walk(root):
+        for fn in sorted(files):
+            if fn.endswith(suffix):
+                yield os.path.join(dirpath, fn)
+
+
+def extract(plugin_root, out_dir):
+    node_root = os.path.join(plugin_root, "Mosaic", "NodeTypes")
+    if not os.path.isdir(node_root):
+        sys.exit("no Mosaic/NodeTypes under %s" % plugin_root)
+
+    # factory class name -> type slug, so instanceof targets can be named as types
+    class_to_type, sources = {}, {}
+    for path in walk(node_root, "TypeFactory.php"):
+        src = read(path)
+        cls = RE_CLASS.search(src)
+        if not cls:
+            continue
+        sources[cls.group(1)] = (path, src, cls.group(2))
+        ctor = RE_CTOR.search(src)
+        if ctor:
+            class_to_type[cls.group(1)] = ctor.group(1)
+
+    def resolve(cls_name):
+        """A factory may inherit canBeParentFor from an abstract ancestor."""
+        seen = set()
+        while cls_name in sources and cls_name not in seen:
+            seen.add(cls_name)
+            path, src, parent = sources[cls_name]
+            m = RE_CAN_BE_PARENT.search(src)
+            if m:
+                return m.group(1), path
+            cls_name = parent
+        return None, None
+
+    rows = []
+    for cls_name, slug in sorted(class_to_type.items(), key=lambda kv: kv[1]):
+        body, defined_in = resolve(cls_name)
+        path, src, _parent = sources[cls_name]
+        nested = "yes" if "function canBeNestedChildFor" in src else ""
+
+        if body is None:
+            rule, allowed = "none", []          # inherited default on the abstract base
+        else:
+            stripped = re.sub(r"//.*|/\*.*?\*/", "", body, flags=re.S).strip()
+            if re.fullmatch(r"return\s+true\s*;", stripped):
+                rule, allowed = "any", []
+            elif re.fullmatch(r"return\s+false\s*;", stripped):
+                rule, allowed = "none", []
+            else:
+                targets = RE_INSTANCEOF.findall(stripped)
+                mapped = [class_to_type[t] for t in targets if t in class_to_type]
+                if mapped and re.fullmatch(
+                    r"return\s+(\$\w+\s+instanceof\s+\w+\s*(\|\|\s*)?)+;", stripped
+                ):
+                    rule, allowed = "allow", sorted(set(mapped))
+                else:
+                    rule, allowed = "complex", sorted(set(mapped))
+
+        rows.append(
+            {
+                "type": slug,
+                "rule": rule,
+                "allowed_children": "|".join(allowed),
+                "nested_rule": nested,
+                "declared_in": os.path.relpath(defined_in or path, plugin_root).replace(os.sep, "/"),
+            }
+        )
+
+    os.makedirs(out_dir, exist_ok=True)
+    with open(os.path.join(out_dir, "placement-rules.csv"), "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=["type", "rule", "allowed_children", "nested_rule", "declared_in"])
+        w.writeheader()
+        w.writerows(rows)
+
+    tally = {}
+    for r in rows:
+        tally[r["rule"]] = tally.get(r["rule"], 0) + 1
+    print("placement rules: %d types  %s" % (len(rows), tally))
+    print("with a runtime ancestry rule (canBeNestedChildFor): %d"
+          % sum(1 for r in rows if r["nested_rule"]))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    extract(sys.argv[1], sys.argv[2])

package/tools/extract_pluggables.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Extract Mosaic's pluggable registries (the extension points a headless caller writes against).
+
+Usage:
+    python extract_pluggables.py <path-to-mosaic-plugin-root> <out-data-dir>
+
+Writes:
+    pluggables.csv   one row per registered pluggable ID, keyed by the registry it belongs to
+
+Mosaic registers every extension point through a writer object whose `setID('...')`
+call carries the stable string that appears in stored node data. Grouping those by
+the Mosaic/Plugins/<Registry> directory they live in reproduces the registry list the
+editor UI shows, without needing a licensed install to read it back over REST.
+"""
+import csv
+import os
+import re
+import sys
+
+RE_SET_ID = re.compile(r"->setID\(\s*'([^']+)'\s*\)")
+RE_LABEL = re.compile(r"->setLabel\(\s*(?:esc_html__|__)\(\s*'([^']*)'")
+RE_NAMESPACE = re.compile(r"^namespace\s+([^;]+);", re.M)
+
+
+def read(path):
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        return fh.read()
+
+
+def extract(plugin_root, out_dir):
+    plugins_root = os.path.join(plugin_root, "Mosaic", "Plugins")
+    if not os.path.isdir(plugins_root):
+        sys.exit("no Mosaic/Plugins under %s" % plugin_root)
+
+    rows = []
+    for dirpath, _dirs, files in os.walk(plugins_root):
+        for fn in sorted(files):
+            if not fn.endswith(".php"):
+                continue
+            path = os.path.join(dirpath, fn)
+            relpath = os.path.relpath(path, plugin_root).replace(os.sep, "/")
+            parts = relpath.split("/")
+            registry = parts[2] if len(parts) > 2 else ""
+            src = read(path)
+            ns = RE_NAMESPACE.search(src)
+            for m in RE_SET_ID.finditer(src):
+                # the nearest setLabel after this setID belongs to the same writer chain
+                tail = src[m.end() : m.end() + 600]
+                nxt = RE_SET_ID.search(tail)
+                if nxt:
+                    tail = tail[: nxt.start()]
+                label = RE_LABEL.search(tail)
+                rows.append(
+                    {
+                        "registry": registry,
+                        "id": m.group(1),
+                        "label": label.group(1) if label else "",
+                        "namespace": ns.group(1) if ns else "",
+                        "file": relpath,
+                    }
+                )
+
+    # de-duplicate: the same ID can be registered once per context (element/template/...)
+    seen = set()
+    unique = []
+    for r in rows:
+        key = (r["registry"], r["id"], r["file"])
+        if key in seen:
+            continue
+        seen.add(key)
+        unique.append(r)
+
+    os.makedirs(out_dir, exist_ok=True)
+    with open(os.path.join(out_dir, "pluggables.csv"), "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=["registry", "id", "label", "namespace", "file"])
+        w.writeheader()
+        w.writerows(unique)
+
+    by_registry = {}
+    for r in unique:
+        by_registry.setdefault(r["registry"], set()).add(r["id"])
+    for reg in sorted(by_registry):
+        print("%-22s %d" % (reg, len(by_registry[reg])))
+    print("total rows: %d" % len(unique))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    extract(sys.argv[1], sys.argv[2])

package/tools/extract_style_properties.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""Extract Mosaic's supported style-property and style-state surface from the source.
+
+    python extract_style_properties.py <path-to-mosaic-plugin-root> <out-data-dir>
+
+Writes style-properties.csv and style-states.csv.
+
+A style value in Mosaic is addressed by (state, breakpoint, property). The two tables
+here cover the first and third axis; breakpoints are per-theme data, not source
+constants, and live in the `mosaic_breakpoints` table.
+
+`Mosaic/Builder/Style/SupportedStyleProperties.php` is the single registry of every
+CSS property the builder can emit. It is the closest thing Mosaic has to Elementor's
+control list, and it is the authoritative answer to "can I set X?" - a property that
+is not in this file cannot be set through the style system at all (only through the
+`customStyles` escape hatch, which is itself one of the entries).
+
+The factory class each property is registered with determines the VALUE SHAPE you must
+write, which matters more than the name:
+
+    CSSPropertyFactory                     a plain CSS keyword/value string
+    CSSCollectionVariablePropertyFactory   a length that may instead reference a
+                                           collection variable (the design-token layer)
+    CSSColorPropertyFactory                a colour, likewise token-referencable
+    CSSGrouppedPropertyFactory             one leg of a compound property - the group
+                                           name is what the data is keyed under, the
+                                           member is the individual CSS property
+    everything else                        a purpose-built shape (shadow, transform,
+                                           gradient, filter ...) - read the factory
+"""
+import csv
+import os
+import re
+import sys
+
+# StyleStateDataMeta declares each style property's validator chain, and many of the
+# ones registered as a plain CSSPropertyFactory are in fact restricted to an enum.
+# Without this, style-properties.csv reads as "any CSS string" and a legal-looking
+# value like white-space:pre-line is accepted, dropped, and never compiled.
+RE_STYLE_PROP = re.compile(
+    r"createDataSimple\(\s*'([^']+)'.*?(?=createDataSimple\(|createDataGroup\(|createDataArray\(|\Z)",
+    re.S)
+RE_ACCEPTED = re.compile(r"createValidatorAcceptedValues\(\s*\[(.*?)\]", re.S)
+
+RE_ADD = re.compile(
+    r'addCSSProperty\(\s*new\s+(\w+)\s*\(\s*"([^"]+)"'      # factory, first arg
+    r'(?:\s*,\s*"([^"]+)")?'                                 # optional member name
+    r'(?:\s*,\s*([\w\\]+)::class)?',                         # optional value class
+    re.S,
+)
+
+
+# createMeta('<stateID>', '<selector template>' [, order])  -- & stands for the element's
+# own selector, so the template is exactly what the compiled CSS rule will look like
+RE_STATE = re.compile(
+    r"createMeta\(\s*'([^']*)'\s*,\s*'((?:[^'\\]|\\.)*)'\s*(?:,\s*(\d+))?\s*\)", re.S
+)
+
+
+def extract_states(plugin_root, out_dir):
+    rows, seen = [], set()
+    for dirpath, _dirs, files in os.walk(os.path.join(plugin_root, "Mosaic")):
+        for fn in sorted(files):
+            if not fn.endswith(".php"):
+                continue
+            path = os.path.join(dirpath, fn)
+            with open(path, encoding="utf-8", errors="replace") as fh:
+                src = fh.read()
+            for state_id, selector, order in RE_STATE.findall(src):
+                if state_id in seen:
+                    continue
+                seen.add(state_id)
+                rows.append(
+                    {
+                        "state": state_id,
+                        "selector_template": selector.replace("\\'", "'"),
+                        "order": order,
+                        # states beginning with underscores are registered by a node type
+                        # and are only meaningful on that type's elements
+                        "scope": "global" if not state_id.startswith("_") else "node-type",
+                        "declared_in": os.path.relpath(path, plugin_root).replace(os.sep, "/"),
+                    }
+                )
+
+    rows.sort(key=lambda r: (r["scope"] != "global", r["state"]))
+    out = os.path.join(out_dir, "style-states.csv")
+    with open(out, "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=["state", "selector_template", "order", "scope", "declared_in"])
+        w.writeheader()
+        w.writerows(rows)
+    print("style states: %d (%d global, %d node-type scoped)"
+          % (len(rows), sum(1 for r in rows if r["scope"] == "global"),
+             sum(1 for r in rows if r["scope"] == "node-type")))
+
+
+def style_enums(plugin_root):
+    """property -> its accepted values, for the style properties restricted to an enum."""
+    path = os.path.join(plugin_root, "Mosaic", "Data", "StyleData", "StyleStateDataMeta.php")
+    if not os.path.exists(path):
+        return {}
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        src = fh.read()
+    out = {}
+    for m in RE_STYLE_PROP.finditer(src):
+        acc = RE_ACCEPTED.search(m.group(0))
+        if acc:
+            values = re.findall(r"'([^']+)'", acc.group(1))
+            if values:
+                out[m.group(1)] = values
+    return out
+
+
+def extract(plugin_root, out_dir):
+    enums = style_enums(plugin_root)
+    path = os.path.join(plugin_root, "Mosaic", "Builder", "Style", "SupportedStyleProperties.php")
+    if not os.path.exists(path):
+        sys.exit("no SupportedStyleProperties.php under %s" % plugin_root)
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        src = fh.read()
+
+    rows = []
+    for factory, first, member, value_class in RE_ADD.findall(src):
+        grouped = factory == "CSSGrouppedPropertyFactory"
+        rows.append(
+            {
+                "property": member if grouped else first,
+                "group": first if grouped else "",
+                "factory": factory,
+                "value_class": value_class.split("\\")[-1] if value_class else "",
+                "accepted_values": "|".join(enums.get(member if grouped else first, [])),
+                "tokenable": "yes" if (
+                    "CollectionVariable" in factory or "Color" in factory
+                    or "CollectionVariable" in (value_class or "")
+                ) else "",
+            }
+        )
+
+    os.makedirs(out_dir, exist_ok=True)
+    out = os.path.join(out_dir, "style-properties.csv")
+    with open(out, "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=["property", "group", "factory", "value_class",
+                                           "accepted_values", "tokenable"])
+        w.writeheader()
+        w.writerows(rows)
+
+    groups = {r["group"] for r in rows if r["group"]}
+    print("style properties: %d (%d in %d compound groups, %d token-referencable, "
+          "%d restricted to an enum)"
+          % (len(rows), sum(1 for r in rows if r["group"]), len(groups),
+             sum(1 for r in rows if r["tokenable"]),
+             sum(1 for r in rows if r["accepted_values"])))
+    by_factory = {}
+    for r in rows:
+        by_factory[r["factory"]] = by_factory.get(r["factory"], 0) + 1
+    for f, n in sorted(by_factory.items(), key=lambda kv: -kv[1]):
+        print("  %-42s %d" % (f, n))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    extract(sys.argv[1], sys.argv[2])
+    extract_states(sys.argv[1], sys.argv[2])

package/tools/mint_session.php

@@ -0,0 +1,52 @@
+<?php
+/**
+ * Mint a logged-in cookie and a matching wp_rest nonce, without a browser.
+ *
+ *   wp eval-file mint_session.php                 # first administrator
+ *   wp eval-file mint_session.php admin@site.com  # a specific account
+ *
+ * The catch: wp_create_nonce() mixes in wp_get_session_token(), which reads the
+ * session token out of the CURRENT REQUEST's logged-in cookie. Under WP-CLI there is
+ * no such cookie, so a nonce minted the obvious way is tied to an empty token while
+ * the cookie carries a real one, and the REST API rejects the pair. So: create the
+ * session explicitly, build the cookie around that token, then plant the cookie in
+ * $_COOKIE before creating the nonce, so both sides agree on the same session.
+ */
+$args = isset($args) ? $args : [];
+
+// Takes a login or email; falls back to the first administrator on the site. Never
+// hardcode an account here - this file ships.
+$who  = isset($args[0]) ? $args[0] : '';
+$user = null;
+if ($who !== '') {
+    $user = strpos($who, '@') !== false ? get_user_by('email', $who)
+                                        : get_user_by('login', $who);
+    if (!$user) {
+        echo "NO_SUCH_USER
+";
+        return;
+    }
+}
+if (!$user) {
+    $admins = get_users(array('role' => 'administrator', 'number' => 1));
+    $user = $admins ? $admins[0] : null;
+}
+if (!$user) {
+    echo "NO_ADMIN\n";
+    return;
+}
+
+$expiration = time() + 12 * HOUR_IN_SECONDS;
+
+$manager = WP_Session_Tokens::get_instance($user->ID);
+$token   = $manager->create($expiration);
+
+$cookie = wp_generate_auth_cookie($user->ID, $expiration, 'logged_in', $token);
+
+$_COOKIE[LOGGED_IN_COOKIE] = $cookie;
+wp_set_current_user($user->ID);
+
+echo 'COOKIE=' . LOGGED_IN_COOKIE . '=' . $cookie . "\n";
+echo 'NONCE=' . wp_create_nonce('wp_rest') . "\n";
+echo 'SITEURL=' . get_option('siteurl') . "\n";
+echo 'USER=' . $user->user_login . "\n";

package/tools/probe.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Put arbitrary node data on a live Mosaic page and report exactly what came out.
+
+    python probe.py --config lab.json --cases cases.json [--out results.csv]
+
+This is the instrument the rest of the skill's measurements are taken with. Reading
+Mosaic's source tells you what a value is *validated* against; it does not tell you
+what the compiler emits, and the two disagree often enough that guessing is not an
+option - a value can be accepted, stored, and produce no CSS at all.
+
+## Case format
+
+A case is one node committed alone onto the probe master, rendered, then deleted:
+
+    {"label": "boxShadow outside",
+     "type": "div",                        default "div"
+     "data": {"style": {...}},             merged into the node's data
+     "children": [...],                    optional child nodes, same shape
+     "expect": ["box-shadow", "8px"]}      substrings to look for in the output
+
+Results report, per case: whether the commit was accepted, whether the page survived,
+and the compiled CSS rule and rendered element that the probe produced - so a case
+that "worked" can be checked against what it actually emitted rather than trusted.
+
+## Reading the outcome
+
+    OK          committed, page healthy, every `expect` substring found
+    PARTIAL     committed and rendered, but some expectation missing
+    NO_OUTPUT   committed, page healthy, produced no CSS rule and no element
+    REJECTED    validator refused - HTTP 200 with an `exceptions` body
+    COMMIT_5xx  PHP fatal during commit
+    BROKE_PAGE  committed, and the page stopped rendering
+"""
+import argparse
+import csv
+import json
+import os
+import re
+import sys
+import uuid
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from sweep_node_types import (  # noqa: E402
+    MIN_HEALTHY_BYTES,
+    Client,
+    delete_subtree,
+    envelopes,
+    exceptions_of,
+    unwrap,
+)
+from sweep_properties import split_markup_and_css  # noqa: E402
+
+PROBE_ID = "probe-target"
+
+
+def records(node, parent_id, master_id, ordering="a0", out=None):
+    out = out if out is not None else []
+    nid = str(uuid.uuid4())
+    data = dict(node.get("data") or {})
+    if not out:                       # the outermost probe node carries the marker id
+        data.setdefault("attrID", PROBE_ID)
+    out.append({
+        "ID": nid, "parentType": "node", "parentID": parent_id, "ordering": ordering,
+        "status": "publish", "revision": "", "version": "",
+        "type": node.get("type", "div"), "data": data,
+        "documentType": "master", "documentID": master_id,
+    })
+    alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    for i, child in enumerate(node.get("children") or []):
+        records(child, nid, master_id, "a" + alphabet[i % len(alphabet)], out)
+    return out
+
+
+def rule_for(css, class_name):
+    """Every rule mentioning a class, including inside @media blocks."""
+    return re.findall(r"[^{}@]*\.%s\b[^{}]*\{[^{}]*\}" % re.escape(class_name), css)
+
+
+def run(client, cfg, cases, out_path):
+    master = cfg["masterID"]
+    key = "node/master/%s" % master
+    doc = unwrap(client.get("masterDocumentInstance/%s" % master), "masterDocumentInstance")
+    baseline = {n["ID"] for n in doc[key]}
+    base_html = client.page(cfg.get("path", ""))
+    if len(base_html) < MIN_HEALTHY_BYTES:
+        sys.exit("probe page already broken (%d bytes)" % len(base_html))
+
+    rows = []
+    for case in cases:
+        doc = unwrap(client.get("masterDocumentInstance/%s" % master), "masterDocumentInstance")
+        recs = records(case, cfg["parentNodeID"], master)
+        resp = client.commit("masterDocumentInstance/%s" % master, envelopes(doc),
+                             {key: [{"newRevisionRecord": r, "originalRevisionRecord": None}
+                                    for r in recs]})
+        err = exceptions_of(resp)
+        css_rule = element = ""
+        if err:
+            code = resp.get("_httperror")
+            outcome = "COMMIT_%d" % code if code and code >= 500 else "REJECTED"
+            detail = "PHP fatal during commit" if code else err[:220]
+        else:
+            html = client.page(cfg.get("path", ""))
+            if len(html) < MIN_HEALTHY_BYTES:
+                outcome, detail = "BROKE_PAGE", html.strip()[:160]
+            else:
+                markup, css = split_markup_and_css(html)
+                m = re.search(r'<([a-zA-Z0-9-]+)[^>]*\bid="%s"[^>]*>' % PROBE_ID, markup)
+                element = m.group(0)[:160] if m else ""
+                cls = re.search(r'class="(M_EL\d+)', element or "")
+                rules = rule_for(css, cls.group(1)) if cls else []
+                css_rule = " ".join(r.strip() for r in rules)[:400]
+                missing = [e for e in (case.get("expect") or []) if e not in css_rule + element]
+                if not (css_rule or element):
+                    outcome, detail = "NO_OUTPUT", ""
+                elif missing:
+                    outcome, detail = "PARTIAL", "missing: " + ", ".join(missing)
+                else:
+                    outcome, detail = "OK", ""
+        rows.append({"label": case.get("label", case.get("type", "?")), "outcome": outcome,
+                     "css": css_rule, "element": element, "detail": detail})
+        print("%-34s %-11s %s" % (rows[-1]["label"], outcome, (css_rule or detail)[:96]), flush=True)
+        delete_subtree(client, master, baseline, cfg["parentNodeID"])
+
+    if out_path:
+        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())))
+    return rows
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--config", required=True)
+    ap.add_argument("--cases", required=True)
+    ap.add_argument("--out")
+    a = ap.parse_args()
+    cfg = json.load(open(a.config, encoding="utf-8"))
+    cases = json.load(open(a.cases, encoding="utf-8"))
+    run(Client(cfg), cfg, cases, a.out)