@runweave/server-linux-x64 0.1.8 → 0.1.10

package/payload/plugins/toolkit/skills/browse-record/scripts/browse_job.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+"""Private, frozen browsing batches; never writes work facts or schedules tasks."""
+import argparse
+import contextlib
+import datetime as dt
+import fcntl
+import hashlib
+import json
+import os
+from pathlib import Path
+import socket
+import subprocess
+import sys
+import tempfile
+import uuid
+from zoneinfo import ZoneInfo
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "suiji" / "scripts"))
+import suiji
+import zhihu_http
+import app_usage
+import source_adapter
+
+
+def require(ok, code):
+    if not ok:
+        raise suiji.Failure(code)
+
+
+def read(path):
+    return json.loads(suiji.private_read(path))
+
+
+def write(path, value):
+    path = Path(path)
+    fd, temporary = tempfile.mkstemp(dir=path.parent, prefix=".browse-")
+    try:
+        with os.fdopen(fd, "w") as stream:
+            json.dump(value, stream, ensure_ascii=False, indent=2)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+        directory = os.open(path.parent, os.O_RDONLY)
+        try:
+            os.fsync(directory)
+        finally:
+            os.close(directory)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+
+
+def digest(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()).hexdigest()
+
+
+def directory(path):
+    p = Path(path)
+    require(not p.is_symlink(), "SYMLINK_REJECTED")
+    p.mkdir(mode=0o700, parents=True, exist_ok=True)
+    require(not p.stat().st_mode & 0o077, "PRIVATE_DIRECTORY_REQUIRED")
+    return p
+
+
+def config(path):
+    c = read(path)
+    require(set(c) - {"scheduledGroup", "transport", "sessionFile", "effectiveFrom", "archivePath"} == {"schemaVersion", "timeZone", "serverId", "ownerId", "connectionId", "externalAccountId", "machine", "profile", "group", "stateDir", "suijiConfig", "tokenFile"}, "INVALID_CONFIG_FIELDS")
+    require(type(c.get("scheduledGroup", False)) is bool, "INVALID_SCHEDULED_GROUP_POLICY")
+    require(c.get("schemaVersion") == 1 and c.get("timeZone") == "Asia/Shanghai", "INVALID_CONFIG")
+    for key in ("serverId", "ownerId", "connectionId"):
+        uuid.UUID(c[key])
+    require(c.get("externalAccountId") and c.get("machine") == socket.gethostname(), "MACHINE_OR_ACCOUNT_BINDING_MISMATCH")
+    for key in ("stateDir", "suijiConfig", "tokenFile"):
+        require(Path(c[key]).is_absolute(), "ABSOLUTE_PRIVATE_PATH_REQUIRED")
+    connection = read(c["suijiConfig"])
+    require(connection.get("mcpPath") == "/mcp/browse" and all(connection.get(k) == c[k] for k in ("serverId", "ownerId")), "BROWSE_CREDENTIAL_IDENTITY_REQUIRED")
+    require(c.get("transport", "browser") in ("browser", "http", "app-usage"), "INVALID_TRANSPORT")
+    if c.get("transport") == "app-usage":
+        require(c.get("profile") == "local-archive" and c.get("group") == "app-usage", "ARCHIVE_BINDING_REQUIRED")
+        require(isinstance(c.get("archivePath"), str) and Path(c["archivePath"]).is_absolute(), "ABSOLUTE_ARCHIVE_PATH_REQUIRED")
+        require(c["externalAccountId"] == app_usage.source_identity(c["archivePath"]), "ARCHIVE_IDENTITY_CHANGED")
+    else:
+        require("archivePath" not in c, "ARCHIVE_REQUIRES_APP_USAGE_TRANSPORT")
+        require(c.get("profile") in ("profile-1", "profile-2", "profile-3") and c.get("group"), "BROWSER_BINDING_REQUIRED")
+    if c.get("transport") == "http":
+        require(isinstance(c.get("sessionFile"), str) and Path(c["sessionFile"]).is_absolute(), "ABSOLUTE_SESSION_PATH_REQUIRED")
+    else:
+        require("sessionFile" not in c, "HTTP_SESSION_REQUIRES_HTTP_TRANSPORT")
+    if "effectiveFrom" in c:
+        require(dt.date.fromisoformat(c["effectiveFrom"]).isoformat() == c["effectiveFrom"], "INVALID_EFFECTIVE_DATE")
+    return c
+
+
+@contextlib.contextmanager
+def lock(c):
+    root = directory(c["stateDir"])
+    locks = directory(Path.home() / ".runweave" / "browse-record" / "locks")
+    path = locks / (c["serverId"] + "-" + c["ownerId"] + "-" + c["connectionId"] + ".lock")
+    require(not path.is_symlink(), "SYMLINK_REJECTED")
+    with os.fdopen(os.open(path, os.O_CREAT | os.O_RDWR, 0o600), "w") as stream:
+        try:
+            fcntl.flock(stream, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            raise suiji.Failure("CONNECTION_BUSY") from None
+        yield root
+
+
+def command(argv, timeout=120):
+    result = subprocess.run(argv, capture_output=True, text=True, timeout=timeout, check=False)
+    if result.returncode != 0 or "### Error" in result.stdout:
+        code = next((c for c in ("NEEDS_LOGIN", "ACCOUNT_CHANGED_DURING_RUN", "ACCOUNT_CHANGED", "IDENTITY_UNAVAILABLE", "HISTORY_UNAVAILABLE_OR_PARSE_FAILED") if c in result.stdout), "BROWSER_UNAVAILABLE_OR_READ_FAILED")
+        raise suiji.Failure(code)
+    return result.stdout
+
+
+def browser_read(c, options, folder):
+    group = c["group"]
+    scheduled_run = os.environ.get("RUNWEAVE_SCHEDULED_TASK_RUN_ID")
+    if scheduled_run:
+        require(c.get("scheduledGroup") is True, "SCHEDULED_GROUP_NOT_AUTHORIZED")
+        uuid.UUID(scheduled_run)
+        group = "browser-group-scheduled-" + scheduled_run
+    resolution = json.loads(command([os.environ.get("RUNWEAVE_CLI_BIN", "rw"), "browser", "profile", "resolve", "--profile", c["profile"].split("-")[-1], "--group-id", group, "--json"]))
+    require(resolution.get("profileId") == c["profile"] and resolution.get("browserGroupId") == group, "BROWSER_BINDING_CHANGED")
+    write(folder / "browser-binding.json", {"machine": c["machine"], "profile": c["profile"], "group": group, "scheduledRunId": scheduled_run})
+    session = "browse-" + c["connectionId"]
+    cli = ["pnpm", "exec", "playwright", "cli", "-s=" + session]
+    # CDP credentials exist in process memory only; never saved in the config or batch.
+    command(cli + ["attach", "--cdp=" + resolution["cdpEndpoint"]])
+    try:
+        source = Path(__file__).with_name("zhihu-read.js").read_text()
+        script = folder / "reader.js"
+        descriptor = os.open(script, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(descriptor, "w") as stream:
+            stream.write(source.replace("/*BROWSE_OPTIONS*/ {}", json.dumps(options)))
+        try:
+            output = command(cli + ["run-code", "--filename=" + str(script)], timeout=1800)
+            require("### Result\n" in output, "BROWSER_RESULT_UNAVAILABLE")
+            return json.JSONDecoder().raw_decode(output.split("### Result\n", 1)[1])[0]
+        finally:
+            script.unlink(missing_ok=True)
+    finally:
+        command(cli + ["detach"])
+
+
+def authorize_http(c):
+    require(c.get("transport") == "http" and not os.environ.get("RUNWEAVE_SCHEDULED_TASK_RUN_ID"), "INTERACTIVE_HTTP_AUTHORIZATION_REQUIRED")
+    path = Path(c["sessionFile"])
+    directory(path.parent)
+    if path.exists() or path.is_symlink():
+        suiji.private_read(path)
+    resolution = json.loads(command([os.environ.get("RUNWEAVE_CLI_BIN", "rw"), "browser", "profile", "resolve", "--profile", c["profile"].split("-")[-1], "--group-id", c["group"], "--json"]))
+    require(resolution.get("profileId") == c["profile"] and resolution.get("browserGroupId") == c["group"], "BROWSER_BINDING_CHANGED")
+    cli = ["pnpm", "exec", "playwright", "cli", "-s=browse-http-auth-" + c["connectionId"]]
+    command(cli + ["attach", "--cdp=" + resolution["cdpEndpoint"]])
+    try:
+        script = """async page => {
+          const cookies = await page.context().cookies([
+            'https://www.zhihu.com/api/v4/me',
+            'https://api.zhihu.com/unify-consumption/read_history',
+            'https://zhuanlan.zhihu.com/api/articles/1'
+          ]);
+          return {cookies, userAgent:await page.evaluate(() => navigator.userAgent)};
+        }"""
+        output = command(cli + ["run-code", script])
+        require("### Result\n" in output, "HTTP_AUTHORIZATION_UNAVAILABLE")
+        auth = json.JSONDecoder().raw_decode(output.split("### Result\n", 1)[1])[0]
+        auth["cookies"] = [cookie for cookie in auth["cookies"] if cookie.get("domain", "").lstrip(".") in ("zhihu.com", "www.zhihu.com", "api.zhihu.com", "zhuanlan.zhihu.com")]
+        auth.update(schemaVersion=1, **{k: c[k] for k in ("machine", "profile", "externalAccountId")})
+        require(zhihu_http.Session(auth, c).identity() == c["externalAccountId"], "ACCOUNT_CHANGED")
+        write(path, auth)
+        return {"authorized": True, "transport": "http", "sessionFile": str(path), "accountHash": hashlib.sha256(c["externalAccountId"].encode()).hexdigest()[:12]}
+    finally:
+        command(cli + ["detach"])
+
+
+def client(c):
+    value, info = suiji.connect(read(c["suijiConfig"]), c["tokenFile"])
+    require(info.get("features", {}).get("browse"), "BROWSE_SERVICE_UNAVAILABLE")
+    return value
+
+
+def adapter_receipt(c, start, end, result=None, error=None):
+    begin = dt.datetime.combine(dt.date.fromisoformat(start), dt.time(), ZoneInfo(c["timeZone"]))
+    finish = dt.datetime.combine(dt.date.fromisoformat(end) + dt.timedelta(days=1), dt.time(), ZoneInfo(c["timeZone"]))
+    items = {}
+    for value in (result or {}).get("items", []):
+        observed, entry = value["observation"], value["entry"]
+        key = observed["contentType"] + ":" + observed["contentId"] + ":" + entry["browseDate"]
+        item = {"id": key, "version": digest({k: entry[k] for k in ("title", "body", "sourceUrl", "contentState")}), "occurredAt": observed["readTime"]}
+        if key not in items or item["occurredAt"] > items[key]["occurredAt"]:
+            items[key] = item
+    provider = "app-usage" if c.get("transport") == "app-usage" else "zhihu"
+    return source_adapter.receipt("browse", "browse:" + provider + ":" + c["connectionId"], begin.isoformat(), finish.isoformat(), c.get("effectiveFrom"),
+                                  dt.datetime.now(dt.timezone.utc).isoformat(), "unavailable" if error else result["coverage"]["state"], list(items.values()),
+                                  [error] if error else result["coverage"]["errors"])
+
+
+def prepare(c, config_path, start, end):
+    require(dt.date.fromisoformat(start).isoformat() == start and dt.date.fromisoformat(end).isoformat() == end and start <= end, "INVALID_DATE_RANGE")
+    with lock(c) as root:
+        active_root = directory(Path.home() / ".runweave" / "browse-record" / "active")
+        active_file = active_root / (c["serverId"] + "-" + c["ownerId"] + "-" + c["connectionId"] + ".json")
+        resume = None
+        if active_file.exists():
+            active = read(active_file)
+            path = Path(active["path"])
+            manifest = read(path / "manifest.json")
+            if manifest["state"] in ("prepared", "pending"):
+                require(path.parent == root.resolve(), "ORIGINAL_BATCH_BELONGS_TO_ANOTHER_STATE_DIRECTORY")
+                require(manifest["from"] == start and manifest["to"] == end, "RESOLVE_ORIGINAL_BATCH_FIRST")
+                return {"batch": str(path), "runId": manifest["runId"], "state": manifest["state"], "reused": True,
+                        **({"adapterReceipt": str(path / "adapter-receipt.json")} if (path / "adapter-receipt.json").exists() else {})}
+            if manifest["state"] == "collecting":
+                require(path.parent == root.resolve() and manifest["from"] == start and manifest["to"] == end and manifest["configHash"] == digest(c), "RECOVER_ORIGINAL_RANGE_FIRST")
+                if (path / "payload.json").exists():
+                    payload = read(path / "payload.json")
+                    require(payload["identityBefore"] == c["externalAccountId"] == payload["identityAfter"], "ACCOUNT_CHANGED")
+                    manifest.update(state="prepared", payloadHash=digest(payload))
+                    write(path / "manifest.json", manifest)
+                    return {"batch": str(path), "runId": manifest["runId"], "state": "prepared", "reused": True,
+                            **({"adapterReceipt": str(path / "adapter-receipt.json")} if (path / "adapter-receipt.json").exists() else {})}
+                resume = (manifest["runId"], path)
+        run = resume[0] if resume else str(uuid.uuid4())
+        path = resume[1] if resume else directory(root / run)
+        manifest = {"state": "collecting", "runId": run, "from": start, "to": end, "config": str(Path(config_path).resolve()), "configHash": digest(c), "leaseExpiresAt": (dt.datetime.now(dt.timezone.utc) + dt.timedelta(minutes=30)).isoformat()}
+        write(path / "manifest.json", manifest)
+        write(active_file, {"path": str(path), "runId": run})
+        try:
+            options = {"from": start, "to": end, "externalAccountId": c["externalAccountId"], "connectionId": c["connectionId"]}
+            if c.get("transport") == "app-usage":
+                result = app_usage.collect(c, options)
+            elif c.get("transport") == "http":
+                write(path / "http-binding.json", {"machine": c["machine"], "profile": c["profile"], "transport": "http", "scheduledRunId": os.environ.get("RUNWEAVE_SCHEDULED_TASK_RUN_ID")})
+                result = zhihu_http.collect(c, options)
+            else:
+                result = browser_read(c, options, path)
+            require(result.get("identityBefore") == c["externalAccountId"] == result.get("identityAfter"), "ACCOUNT_CHANGED")
+            write(path / "adapter-receipt.json", adapter_receipt(c, start, end, result))
+            payload = {k: result[k] for k in ("identityBefore", "identityAfter", "items", "coverage")}
+            payload.update(runId=run, connectionId=c["connectionId"], externalAccountId=c["externalAccountId"], **{"from": start, "to": end})
+            write(path / "payload.json", payload)
+            manifest.update(state="prepared", payloadHash=digest(payload), historyUnchanged=result["historyUnchanged"])
+            write(path / "manifest.json", manifest)
+            return {"batch": str(path), "runId": run, "coverage": result["coverage"], "historyUnchanged": result["historyUnchanged"], "adapterReceipt": str(path / "adapter-receipt.json")}
+        except Exception as error:
+            code = str(error)
+            reason = "needs-login" if code == "NEEDS_LOGIN" else "identity-changed" if "ACCOUNT_CHANGED" in code else "parse-failed" if "PARSE" in code else "unavailable"
+            write(path / "adapter-receipt.json", adapter_receipt(c, start, end, error=reason))
+            manifest["error"] = reason
+            try:
+                client(c).call("report_browse_failure", {"idempotencyKey": run, "input": {"runId": run, "connectionId": c["connectionId"], "externalAccountId": c["externalAccountId"], "from": start, "to": end, "reason": reason}})
+            except Exception:
+                manifest["failureReceiptUnconfirmed"] = True
+            manifest["state"] = "failed"
+            write(path / "manifest.json", manifest)
+            raise
+
+
+def batch(path):
+    path = Path(path).resolve()
+    meta = read(path / "manifest.json")
+    c = config(meta["config"])
+    require(digest(c) == meta["configHash"] and path.parent == Path(c["stateDir"]).resolve(), "BATCH_IDENTITY_CHANGED")
+    return path, meta, c
+
+
+def import_batch(path, reconcile=False):
+    path, meta, c = batch(path)
+    with lock(c) as root:
+        if reconcile and meta["state"] == "failed":
+            cli = client(c)
+            try:
+                receipt = cli.call("get_browse_run", {"runId": meta["runId"]})
+            except suiji.Failure as error:
+                require(str(error) == "NOT_FOUND", "RECEIPT_READ_UNAVAILABLE")
+                receipt = cli.call("report_browse_failure", {"idempotencyKey": meta["runId"], "input": {"runId": meta["runId"], "connectionId": c["connectionId"], "externalAccountId": c["externalAccountId"], "from": meta["from"], "to": meta["to"], "reason": meta["error"]}})
+            require(meta["error"] in receipt["coverage"]["errors"], "FAILURE_RECEIPT_MISMATCH")
+            write(path / "receipt.json", receipt)
+            meta["failureReceiptUnconfirmed"] = False
+            write(path / "manifest.json", meta)
+            return {"runId": meta["runId"], "failed": True, "reported": True}
+        payload = read(path / "payload.json")
+        require(digest(payload) == meta["payloadHash"], "FROZEN_PAYLOAD_CHANGED")
+        require(meta["state"] in ("prepared", "pending", "confirmed"), "BATCH_NOT_PREPARED")
+        cli = client(c)
+        if reconcile or meta["state"] in ("pending", "confirmed"):
+            try:
+                receipt = cli.call("get_browse_run", {"runId": meta["runId"]})
+            except suiji.Failure as error:
+                require(str(error) == "NOT_FOUND", "RECEIPT_READ_UNAVAILABLE")
+                receipt = None
+            if receipt:
+                require(receipt["connectionId"] == c["connectionId"] and receipt["from"] == meta["from"] and receipt["to"] == meta["to"], "RECEIPT_IDENTITY_MISMATCH")
+                write(path / "receipt.json", receipt)
+                meta["state"] = "confirmed"; write(path / "manifest.json", meta)
+                write(root / (c["connectionId"] + ".checkpoint.json"), {"runId": meta["runId"], "from": meta["from"], "to": meta["to"], "coverage": receipt["coverage"]})
+                return {"runId": meta["runId"], "confirmed": True, "receipt": receipt["receipt"]}
+        meta["state"] = "pending"; write(path / "manifest.json", meta)
+        cli.call("import_browse_entries", {"idempotencyKey": meta["runId"], "input": payload})
+        # Independent readback confirms commit even when the original response was lost.
+        receipt = cli.call("get_browse_run", {"runId": meta["runId"]})
+        require(receipt["connectionId"] == c["connectionId"], "RECEIPT_IDENTITY_MISMATCH")
+        write(path / "receipt.json", receipt)
+        meta["state"] = "confirmed"; write(path / "manifest.json", meta)
+        write(root / (c["connectionId"] + ".checkpoint.json"), {"runId": meta["runId"], "from": meta["from"], "to": meta["to"], "coverage": receipt["coverage"]})
+        return {"runId": meta["runId"], "confirmed": True, "receipt": receipt["receipt"]}
+
+
+def read_digest(c, config_path, day):
+    require(c.get("transport") != "app-usage", "APP_USAGE_HAS_NO_READING_DIGEST")
+    dt.date.fromisoformat(day)
+    with lock(c) as root:
+        cli = client(c)
+        entries, cursor, revision = [], None, None
+        while True:
+            args = {"source": "zhihu", "from": day, "to": day, "limit": 100}
+            if cursor:
+                args["cursor"] = cursor
+            page = cli.call("list_browse_entries", args)
+            require(revision in (None, page["browseRevision"]), "BROWSE_CHANGED: restart digest read")
+            revision = page["browseRevision"]
+            for entry in page["items"]:
+                if entry["source"]["connectionId"] == c["connectionId"]:
+                    value = cli.call("get_browse_entry", {"id": entry["id"]})["entry"]
+                    require(value["version"] == entry["version"] and not value["deletedAt"], "BROWSE_CHANGED")
+                    entries.append(value)
+            cursor = page["nextCursor"]
+            if not cursor:
+                break
+        path = directory(root / str(uuid.uuid4()))
+        refs = [{"id": e["id"], "version": e["version"], "hash": e["contentHash"]} for e in entries]
+        value = {"date": day, "connectionId": c["connectionId"], "entries": entries, "entryRefs": refs, "inputRevision": revision}
+        write(path / "input.json", value)
+        write(path / "manifest.json", {"state": "digest-input", "config": str(Path(config_path).resolve()), "configHash": digest(c), "inputHash": digest(value), "key": str(uuid.uuid4())})
+        return {"batch": str(path), "input": str(path / "input.json"), "count": len(entries)}
+
+
+def publish_digest(path, input_path):
+    path, meta, c = batch(path)
+    with lock(c):
+        frozen = read(path / "input.json")
+        require(digest(frozen) == meta["inputHash"], "DIGEST_INPUT_CHANGED")
+        value = read(input_path)
+        require(set(value) == {"title", "body", "entryRefs", "inputRevision"} and value["entryRefs"] == frozen["entryRefs"] and value["inputRevision"] == frozen["inputRevision"], "DIGEST_REFERENCES_CHANGED")
+        payload = {**value, "date": frozen["date"], "connectionId": c["connectionId"]}
+        if meta.get("payloadHash"):
+            require(meta["payloadHash"] == digest(payload), "FROZEN_DIGEST_CHANGED")
+        meta.update(state="pending-digest", payloadHash=digest(payload)); write(path / "manifest.json", meta)
+        cli = client(c)
+        result = cli.call("publish_browse_digest", {"idempotencyKey": meta["key"], "input": payload})
+        confirmed = cli.call("list_browse_digests", {"date": frozen["date"], "connectionId": c["connectionId"]})
+        require(any(item["id"] == result["digest"]["id"] and item["version"] == result["digest"]["version"] for item in confirmed["items"]), "DIGEST_READBACK_MISMATCH")
+        meta["state"] = "confirmed-digest"; write(path / "manifest.json", meta)
+        write(path / "receipt.json", result)
+        return {"confirmed": True, "id": result["digest"]["id"], "version": result["digest"]["version"]}
+
+
+def main():
+    os.umask(0o077)
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("command", choices=["authorize-http", "prepare", "import", "reconcile", "read", "publish-digest"])
+    for name in ("config", "from", "to", "batch", "date", "input"):
+        parser.add_argument("--" + name)
+    args = parser.parse_args()
+    if args.command in ("import", "reconcile"):
+        return import_batch(args.batch, args.command == "reconcile")
+    if args.command == "publish-digest":
+        return publish_digest(args.batch, args.input)
+    c = config(args.config)
+    if args.command == "authorize-http":
+        return authorize_http(c)
+    if args.command == "read":
+        return read_digest(c, args.config, args.date)
+    now = dt.datetime.now(ZoneInfo("Asia/Shanghai")).date()
+    start = getattr(args, "from") or max((now - dt.timedelta(days=1)).isoformat(), c.get("effectiveFrom", "0001-01-01"))
+    return prepare(c, args.config, start, args.to or now.isoformat())
+
+
+if __name__ == "__main__":
+    try:
+        print(json.dumps(main(), ensure_ascii=False))
+    except Exception as error:
+        print(json.dumps({"ok": False, "error": str(error) if isinstance(error, suiji.Failure) else type(error).__name__}), file=sys.stderr)
+        sys.exit(1)

package/payload/plugins/toolkit/skills/browse-record/scripts/zhihu-read.js

@@ -0,0 +1,126 @@
+/* global fetch, AbortSignal, URL, DOMParser, crypto */
+// Playwright run-code consumes this file as one function expression; evaluate callbacks run in the browser.
+// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+async page => {
+  // prepare substitutes only non-secret identity/range options into this expression.
+  const options = /*BROWSE_OPTIONS*/ {};
+  const tabs = new Map();
+  const errors = [];
+  const capturedAt = new Date().toISOString();
+  const deadline = Date.now() + 20 * 60 * 1000;
+  const apiOrigin = "https://api.zhihu.com";
+  const allowed = url => /^https:\/\/(?:api\.zhihu\.com\/unify-consumption\/read_history(?:\?[^#]*)?|www\.zhihu\.com\/api\/v4\/(?:me|answers\/\d+)(?:\?[^#]*)?|zhuanlan\.zhihu\.com\/api\/articles\/\d+)$/.test(url);
+  const request = async url => {
+    if (Date.now() > deadline && url !== "https://www.zhihu.com/api/v4/me") throw new Error("RUN_BUDGET_EXCEEDED");
+    if (!allowed(url)) throw new Error("UNTRUSTED_API_URL");
+    const origin = url.match(/^https:\/\/[^/]+/)[0];
+    let tab = tabs.get(origin);
+    if (!tab) { tab = await page.context().newPage(); tabs.set(origin, tab); await tab.goto(url, { timeout: 15000, waitUntil: "domcontentloaded" }); }
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const result = await tab.evaluate(async target => {
+        try {
+          const response = await fetch(target, { credentials: "include", signal: AbortSignal.timeout(15000) });
+          const text = await response.text();
+          let data; try { data = JSON.parse(text); } catch { return { status: response.status, error: "NON_JSON_OR_VERIFICATION" }; }
+          return { status: response.status, data };
+        } catch { return { status: 0, error: "TIMEOUT_OR_NETWORK" }; }
+      }, url);
+      if ((result.status === 0 || result.status === 429 || result.status >= 500) && attempt < 2) { await tab.waitForTimeout(500 * (attempt + 1)); continue; }
+      return result;
+    }
+  };
+  const identity = async () => {
+    const r = await request("https://www.zhihu.com/api/v4/me");
+    if (r.status !== 200 || typeof r.data?.id !== "string" || !r.data.id) throw new Error(r.status === 401 || r.status === 403 ? "NEEDS_LOGIN" : "IDENTITY_UNAVAILABLE");
+    return r.data.id;
+  };
+  const historyUrl = `${apiOrigin}/unify-consumption/read_history?offset=0&limit=20`;
+  const parseHistory = response => {
+    if (response.status !== 200 || !Array.isArray(response.data?.data) || typeof response.data?.paging?.is_end !== "boolean") throw new Error(response.status === 401 || response.status === 403 ? "NEEDS_LOGIN" : "HISTORY_UNAVAILABLE_OR_PARSE_FAILED");
+    return response.data;
+  };
+  const parse = card => {
+    const value = card.card_type === "single_card" ? card.data : null, extra = value?.extra;
+    if (!extra || typeof extra.content_token !== "string" || typeof extra.content_type !== "string" || !Number.isFinite(extra.read_time)) throw new Error("UNKNOWN_HISTORY_STRUCTURE");
+    const occurredAt = new Date(extra.read_time * (extra.read_time > 1e12 ? 1 : 1000)).toISOString();
+    const day = new Date(Date.parse(occurredAt) + 8 * 3600000).toISOString().slice(0, 10);
+    return { type: extra.content_type, id: extra.content_token, occurredAt, day, questionId: extra.question_token,
+      title: typeof value.header?.title === "string" ? value.header.title : "知乎浏览内容" };
+  };
+  const signature = value => JSON.stringify(value.data.map(card => { const x = parse(card); return [x.type,x.id,x.occurredAt]; }));
+  try {
+    const identityBefore = await identity();
+    if (options.externalAccountId && identityBefore !== options.externalAccountId) throw new Error("ACCOUNT_CHANGED");
+    if (options.probe) return { identityBefore };
+    const observed = new Map(); let pages = 0, stable = false;
+    let baseline; let baselinePages = new Map();
+    for (let round = 0; round < 3; round++) {
+      baselinePages = new Map();
+      let next = historyUrl, first, complete = false; const seenPages = new Set();
+      for (let index = 0; index < 100; index++) {
+        if (seenPages.has(next)) { errors.push("PAGINATION_LOOP"); break; }
+        seenPages.add(next);
+        let value;
+        try { value = parseHistory(await request(next)); } catch (e) { errors.push(e.message); break; }
+        baselinePages.set(next, signature(value));
+        pages++; if (index === 0) { first = signature(value); baseline = baseline ?? first; }
+        if (value.data.length > 20) { errors.push("PAGE_LIMIT_EXCEEDED"); break; }
+        for (const card of value.data) {
+          try { const item = parse(card); if (item.day >= options.from && item.day <= options.to) observed.set(`${item.type}:${item.id}:${item.occurredAt}`, item); }
+          catch { errors.push("UNKNOWN_HISTORY_STRUCTURE"); }
+        }
+        if (value.paging.is_end) { complete = true; break; }
+        try { const url = await tabs.get(apiOrigin).evaluate(value => { const u = new URL(value); return { href: u.href, origin: u.origin, limit: u.searchParams.get("limit") }; }, value.paging.next); if (!allowed(url.href) || url.origin !== apiOrigin || url.limit !== "20") throw new Error(); next = url.href; }
+        catch { errors.push("UNTRUSTED_PAGINATION"); break; }
+        if (index === 99) errors.push("PAGE_CAP_REACHED");
+      }
+      try { const check = parseHistory(await request(historyUrl)); if (signature(check) === first) { stable = complete; break; } }
+      catch { errors.push("HOMEPAGE_RECHECK_FAILED"); break; }
+      if (round === 2) errors.push("HISTORY_UNSTABLE");
+    }
+    const plain = async html => {
+      const tab = tabs.get("https://www.zhihu.com");
+      return tab.evaluate(value => {
+        const safe = value.replace(/<(script|style|iframe|object|embed|video|audio)[\s\S]*?<\/\1\s*>/gi, "").replace(/<(img|source|link|meta)\b[^>]*>/gi, "");
+        const doc = new DOMParser().parseFromString(safe, "text/html");
+        for (const node of doc.querySelectorAll("p,div,br,li,h1,h2,h3,blockquote")) node.append("\n");
+        return (doc.body.textContent ?? "").replace(/\n{3,}/g, "\n\n").trim();
+      }, html);
+    };
+    const bodies = new Map(); const items = [];
+    for (const observation of observed.values()) {
+      const key = observation.type + ":" + observation.id;
+      let content = bodies.get(key);
+      if (!content) {
+        const supported = ["answer", "article"].includes(observation.type) && /^\d+$/.test(observation.id);
+        let body = "", state = "metadata-only", reason = supported ? null : "unsupported-content-type";
+        if (supported) {
+          const url = observation.type === "answer" ? `https://www.zhihu.com/api/v4/answers/${observation.id}?include=content,paid_info` : `https://zhuanlan.zhihu.com/api/articles/${observation.id}`;
+          try {
+            const r = await request(url);
+            if (r.status === 200 && String(r.data?.id) === observation.id && typeof r.data.content === "string") {
+              body = await plain(r.data.content); state = body ? "available" : "metadata-only";
+              if (r.data.is_paid === true && r.data.paid_info?.has_purchased !== true) { state = "metadata-only"; reason = "paid-content-limited"; }
+              if (!body) reason = "empty-content";
+            } else reason = r.status === 403 ? "forbidden" : r.status === 404 ? "not-found" : "content-unavailable-or-id-mismatch";
+          } catch { reason = "content-timeout-or-parse-failed"; }
+        }
+        content = { body, state, reason }; bodies.set(key, content);
+      }
+      const sourceUrl = observation.type === "answer" && /^\d+$/.test(observation.questionId ?? "") ? `https://www.zhihu.com/question/${observation.questionId}/answer/${observation.id}` : observation.type === "article" ? `https://zhuanlan.zhihu.com/p/${observation.id}` : null;
+      items.push({ observation: { contentType: observation.type, contentId: observation.id, readTime: observation.occurredAt, observedAt: capturedAt },
+        entry: { captureId: await tabs.get("https://www.zhihu.com").evaluate(() => crypto.randomUUID()), browseDate: observation.day, occurredAt: observation.occurredAt, capturedAt, title: observation.title, body: content.body, userNote: "", source: { provider: "zhihu", displayName: "知乎", connectionId: options.connectionId }, contentType: observation.type, captureMethod: "connector", sourceUrl, contentState: { state: content.state, reason: content.reason }, attachmentIds: [] } });
+    }
+    const identityAfter = await identity();
+    if (identityAfter !== identityBefore) throw new Error("ACCOUNT_CHANGED_DURING_RUN");
+    let historyUnchanged = false;
+    try { historyUnchanged = baseline === signature(parseHistory(await request(historyUrl))); }
+    catch { errors.push("HISTORY_RECHECK_FAILED"); }
+    for (const [url, before] of baselinePages) {
+      try { if (signature(parseHistory(await request(url))) !== before) historyUnchanged = false; }
+      catch { historyUnchanged = false; errors.push("HISTORY_RECHECK_FAILED"); }
+    }
+    if (!historyUnchanged) errors.push("HISTORY_CHANGED_DURING_CONTENT_READ");
+    return { identityBefore, identityAfter, items, historyUnchanged, coverage: { state: stable && errors.length === 0 ? "complete" : "partial", pages, metadata: items.length, content: items.filter(i => i.entry.contentState.state === "available").length, errors: [...new Set(errors)].slice(0,200) } };
+  } finally { for (const tab of tabs.values()) await tab.close(); }
+}