@topy-ai/maggie 0.7.53 → 0.7.54

package/bundled-tools/clis/maggie_mobile.py

@@ -28,6 +28,16 @@ made from: ``eas.json`` and ``package.json`` usually changed since. ``plan
 ``eas fingerprint:compare``, publish the update only when it matches, and
 always put the working copies back (verified by hash), even on failure. ``ota``
 is a dry run unless ``--confirm`` is given, because the update is published.
+
+``ota-guard`` checks the runtime an update would target against the runtimes
+of builds people have installed (a runtimes file kept with the app) and
+refuses when none matches. In a pnpm monorepo the fingerprint also hashes
+pnpm's virtual-store paths (``node_modules/.pnpm/<pkg>_<peer hash>``), so a
+dependency change in any workspace package can move the runtime;
+``ignorePaths`` and ``fileHookTransform`` cannot help because native module
+folders are added by their real path. With ``--publish --confirm`` it runs
+``eas update`` after a match and checks that the published runtime is the one
+that was checked.
 """
 
 from __future__ import annotations
@@ -180,6 +190,9 @@ def preflight(project: Path, app_dir: Path | None, config_json: Path | None, pro
     package = _load(app / "package.json") if (app / "package.json").is_file() else {}
     ignore = (app / ".fingerprintignore").read_text(encoding="utf-8") if (app / ".fingerprintignore").is_file() else ""
     errors, warnings, facts = check_profile(expo, eas, package, profile, platforms, auto_submit, raw, ignore)
+    if is_pnpm_monorepo(app) and any(runtime_policy(expo, platform)[0] == {"policy": "fingerprint"} or runtime_policy(expo, platform)[0] == "fingerprint" for platform in platforms):
+        warnings.append("pnpm monorepo with a fingerprint runtime: pnpm's virtual-store paths are part of the fingerprint, so a dependency change in another workspace package can move the runtime. Publish updates through `maggie mobile ota-guard --runtimes FILE` and set an explicit runtimeVersion (plus a native-change check) at the next native build")
+        facts["pnpmMonorepo"] = True
     return {
         "schemaVersion": SCHEMA,
         "appDir": str(app.relative_to(project)) if app.is_relative_to(project) else ".",
@@ -304,10 +317,70 @@ def ota(app: Path, build_ref: str, build_id: str, channel: str, environment: str
         report["steps"] = steps
 
 
+def is_pnpm_monorepo(app: Path) -> bool:
+    for folder in (app, *app.parents):
+        if (folder / "pnpm-workspace.yaml").is_file():
+            return True
+        if (folder / ".git").exists():
+            break
+    return False
+
+
+def load_runtimes(path: Path, platform: str) -> list[dict]:
+    """`maggie-mobile-runtimes.v1` ({"ios": [{"build", "eas_build_id", "runtime"}], "android": [...]})."""
+    data = _load(path)
+    builds = data.get(platform) or []
+    if not isinstance(builds, list) or not all(isinstance(item, dict) and item.get("runtime") for item in builds):
+        raise ValueError(f"{path} has no `{platform}` list of {{build, runtime}} entries")
+    return builds
+
+
+def fingerprint_command(platform: str) -> list[str]:
+    return shlex.split(os.environ.get("MAGGIE_MOBILE_FINGERPRINT", f"npx expo-updates fingerprint:generate --platform {platform}"))
+
+
+def ota_guard(app: Path, runtimes: Path, platform: str, runtime: str | None, publish: bool, channel: str | None, environment: str, message: str | None, confirm: bool) -> dict:
+    builds = load_runtimes(runtimes, platform)
+    report: dict = {"schemaVersion": "maggie-mobile-ota-guard.v1", "platform": platform, "installedBuilds": [{"build": item.get("build"), "runtime": item["runtime"]} for item in builds], "executed": False}
+    if not runtime:
+        result = subprocess.run(fingerprint_command(platform), cwd=app, capture_output=True, text=True, check=False)
+        try:
+            runtime = str(json.loads(result.stdout[result.stdout.find("{"):])["hash"]) if result.returncode == 0 else None
+        except (ValueError, KeyError):
+            runtime = None
+        if not runtime:
+            return {**report, "status": "failed", "reason": "could not compute the fingerprint (expo-updates fingerprint:generate)"}
+    report["runtime"] = runtime
+    match = next((item for item in builds if item["runtime"] == runtime), None)
+    if not match:
+        report.update(status="failed", reason=f"no installed build has runtime {runtime}; an update published now would reach nobody",
+                      fix=["the change needs a native build (new native module, permission, native config): build, then add its runtime to the runtimes file",
+                           "or only install paths moved (a dependency change elsewhere in the monorepo): publish from a temporary worktree with the build's lockfile and workspace file, after a frozen install, and confirm the fingerprint equals the build's runtime",
+                           "next native build: set an explicit runtimeVersion and keep a native-change check, so unrelated workspace changes cannot move it"])
+        return report
+    report["matchedBuild"] = match.get("build")
+    if not publish:
+        return {**report, "status": "passed"}
+    if not (channel and message):
+        raise ValueError("--publish needs an EAS Update channel on the profile and --message")
+    update = eas_command() + ["update", "--channel", channel, "--environment", environment, "--platform", platform, "--message", message, "--non-interactive"]
+    report["command"] = shlex.join(update)
+    if not confirm:
+        return {**report, "status": "dry-run", "note": "runtime matches; re-run with --confirm to publish"}
+    result = subprocess.run(update, cwd=app, capture_output=True, text=True, check=False)
+    published = re.search(r"Runtime version\s+([0-9a-f]{8,})", result.stdout or "")
+    report.update(executed=True, publishedRuntime=published.group(1) if published else None)
+    if result.returncode:
+        return {**report, "status": "failed", "reason": "eas update failed; see its output"}
+    if not published or published.group(1) != runtime:
+        return {**report, "status": "failed", "reason": "the published runtime differs from the checked one; check `eas update:list`"}
+    return {**report, "status": "published"}
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="maggie mobile", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     sub = parser.add_subparsers(dest="command", required=True)
-    for name in ("preflight", "plan", "ota"):
+    for name in ("preflight", "plan", "ota", "ota-guard"):
         command = sub.add_parser(name)
         command.add_argument("--project", type=Path, default=Path("."))
         command.add_argument("--app-dir", type=Path, help="Expo app folder inside a monorepo, e.g. apps/app")
@@ -319,6 +392,12 @@ def main(argv: list[str] | None = None) -> int:
         command.add_argument("--output", type=Path)
         if name in {"plan", "ota"}:
             command.add_argument("--build-ref", help="git commit or tag the installed store build was made from")
+        if name == "ota-guard":
+            command.add_argument("--runtimes", type=Path, required=True, help="maggie-mobile-runtimes.v1 JSON: installed builds' runtimes per platform")
+            command.add_argument("--runtime", help="use this runtime instead of computing the fingerprint")
+            command.add_argument("--publish", action="store_true", help="publish the update after a match")
+            command.add_argument("--message")
+            command.add_argument("--confirm", action="store_true")
         if name == "ota":
             command.add_argument("--build-id", required=True, help="EAS build id of the installed build (for fingerprint:compare)")
             command.add_argument("--message", required=True)
@@ -341,6 +420,10 @@ def main(argv: list[str] | None = None) -> int:
             report = {"schemaVersion": "maggie-mobile-release-plan.v1", "preflight": {key: report[key] for key in ("status", "errors", "warnings")}, "commands": plan_commands(args.profile, platforms, args.auto_submit, channel, args.environment, args.build_ref, drift), "costNotice": report["costNotice"], "executed": False}
             if drift is not None:
                 report["buildConfig"] = [{"file": item["file"], "differsFromBuild": item["differs"]} for item in drift]
+        elif args.command == "ota-guard":
+            if args.platform == "all":
+                raise ValueError("--platform ios or android: runtimes differ per platform")
+            report = ota_guard(app, (project / args.runtimes) if not args.runtimes.is_absolute() else args.runtimes, args.platform, args.runtime, args.publish, channel, environment, args.message, args.confirm)
         elif args.command == "ota":
             if report["status"] == "failed":
                 raise ValueError("preflight failed: " + "; ".join(report["errors"]))

package/bundled-tools/clis/maggie_product_release.py

@@ -27,6 +27,7 @@ import json
 import re
 import shutil
 import subprocess
+import time
 import sys
 import tempfile
 from datetime import date, datetime, timezone
@@ -264,6 +265,44 @@ def review_status(reviews_path: Path, package_version: str | None, chatgpt_plugi
     return {"schemaVersion": "maggie-product-review-status.v1", "passed": not errors, "reviews": rows, "errors": errors, "warnings": warnings}
 
 
+STAGED_ERROR = re.compile(r"cannot publish over (?:the )?previously (?:staged|published) version", re.I)
+
+
+def npm_view(package: str, npm_bin: str) -> dict:
+    completed = subprocess.run([npm_bin, "view", package, "dist-tags", "versions", "--json"], capture_output=True, text=True, check=False, timeout=60)
+    if completed.returncode:
+        return {}
+    try:
+        value = json.loads(completed.stdout or "{}")
+    except json.JSONDecodeError:
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def published(package: str, version: str, tag: str, wait: int, interval: float, publish_log: Path | None, view=None, sleep=time.sleep) -> dict:
+    """Wait until `version` is the registry's `tag` (latest). A staged publish can lag for minutes."""
+    npm_bin = shutil.which("npm") or "npm"
+    view = view or (lambda: npm_view(package, npm_bin))
+    log_says_staged = bool(publish_log and publish_log.is_file() and STAGED_ERROR.search(publish_log.read_text(encoding="utf-8", errors="replace")))
+    deadline = time.monotonic() + wait
+    checks = 0
+    while True:
+        checks += 1
+        data = view()
+        tags = data.get("dist-tags") or {}
+        versions = data.get("versions") or []
+        listed = version in (versions if isinstance(versions, list) else [versions])
+        current = tags.get(tag)
+        if current == version:
+            return {"passed": True, "package": package, "version": version, "tag": tag, "state": "live", "checks": checks,
+                    "note": "the earlier publish attempt was already accepted (staged), not a failure" if log_says_staged else None}
+        if time.monotonic() >= deadline:
+            state = "staged" if listed or log_says_staged else "missing"
+            return {"passed": False, "package": package, "version": version, "tag": tag, "state": state, "registryTag": current, "checks": checks,
+                    "note": "still propagating: check again before reporting it" if state == "staged" else "not on the registry: the publish did not happen"}
+        sleep(interval)
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="maggie product", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     sub = parser.add_subparsers(dest="command", required=True)
@@ -281,9 +320,18 @@ def main(argv: list[str] | None = None) -> int:
     review.add_argument("--reviews", type=Path, required=True, help="maggie-product-reviews.v1 JSON")
     review.add_argument("--package", type=Path)
     review.add_argument("--chatgpt-plugin", type=Path, help="ChatGPT app plugin.json with review.test_cases")
+    pub = sub.add_parser("published", help="wait until a just-published version is the registry's latest (staged publishes lag)")
+    pub.add_argument("--package-name", required=True)
+    pub.add_argument("--version", required=True)
+    pub.add_argument("--tag", default="latest")
+    pub.add_argument("--wait", type=int, default=600, help="seconds to keep checking (default 600)")
+    pub.add_argument("--interval", type=float, default=20)
+    pub.add_argument("--publish-log", type=Path, help="output of the publish command; 'Cannot publish over previously staged version' means it was already accepted")
     args = parser.parse_args(argv)
     try:
-        if args.command == "release-check":
+        if args.command == "published":
+            report = published(args.package_name, args.version, args.tag, args.wait, args.interval, args.publish_log)
+        elif args.command == "release-check":
             report = release_check(args.package.resolve(), args.server_json, args.changelog, args.pack)
         elif args.command == "smoke":
             report = smoke(args.package.resolve(), args.timeout)

package/bundled-tools/clis/maggie_social_share.py

@@ -7,7 +7,9 @@ import json
 import sys
 from datetime import datetime, timezone
 from pathlib import Path
+from urllib.error import HTTPError, URLError
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+from urllib.request import Request, urlopen
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from maggie_social_queue import check_campaigns, connection_health, parse_instant, plan_queue, reconcile, validate_adapters  # noqa: E402
@@ -43,6 +45,66 @@ def tracked_url(url: str, channel: str) -> str:
     return urlunsplit((parsed.scheme, parsed.netloc, parsed.path, urlencode(query), parsed.fragment))
 
 
+# Only a definite "gone" answer drops an article. Blocked (403/429), failing
+# (5xx) or unreachable pages are kept: a firewall or an outage must never empty
+# the list of articles to share.
+GONE = {404, 410}
+
+
+def fetch_status(url: str, timeout: float = 10.0) -> int | None:
+    """Final HTTP status after redirects, or None when the page could not be reached."""
+    for method in ("HEAD", "GET"):
+        request = Request(url, method=method, headers={"User-Agent": "MaggieSocialShare/1.0 (+link check)", "Accept": "text/html,*/*"})
+        try:
+            with urlopen(request, timeout=timeout) as response:
+                return int(response.status)
+        except HTTPError as error:
+            # Some servers refuse HEAD; ask again with GET before deciding.
+            if method == "HEAD" and error.code in {400, 403, 405, 501}:
+                continue
+            return int(error.code)
+        except (URLError, TimeoutError, OSError):
+            return None
+    return None
+
+
+def link_verdict(status: int | None) -> str:
+    if status in GONE:
+        return "gone"
+    if status is not None and 200 <= status < 400:
+        return "live"
+    return "unknown"
+
+
+def check_links(urls: list[str], cache_path: Path | None, ttl_hours: float, now: datetime, fetch=fetch_status) -> dict:
+    cache: dict = {}
+    if cache_path and cache_path.is_file():
+        try:
+            cache = json.loads(cache_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            cache = {}
+    results = []
+    for url in dict.fromkeys(urls):
+        cached = cache.get(url)
+        fresh = False
+        if isinstance(cached, dict) and cached.get("checked_at"):
+            try:
+                fresh = (now - parse_instant(cached["checked_at"], "checked_at")).total_seconds() < ttl_hours * 3600
+            except ValueError:
+                fresh = False
+        if fresh:
+            status, source = cached.get("status"), "cache"
+        else:
+            status, source = fetch(url), "fetched"
+            cache[url] = {"status": status, "checked_at": now.isoformat().replace("+00:00", "Z")}
+        results.append({"url": url, "status": status, "verdict": link_verdict(status), "source": source})
+    if cache_path:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        cache_path.write_text(json.dumps(cache, indent=2) + "\n", encoding="utf-8")
+    gone = [item for item in results if item["verdict"] == "gone"]
+    return {"valid": True, "checked": len(results), "skip": gone, "keep": [item for item in results if item["verdict"] != "gone"], "results": results}
+
+
 def plan(content: dict, channels: list[str], workspace_domain: str | None = None) -> dict:
     errors = [f"missing {key}" for key in REQUIRED if not content.get(key)]
     invalid = [channel for channel in channels if channel not in LIMITS]
@@ -73,6 +135,40 @@ def plan(content: dict, channels: list[str], workspace_domain: str | None = None
     }
 
 
+def shared_picture_errors(posts: list[dict], label: str) -> list[str]:
+    """Posts written together for several channels share one picture.
+
+    A channel may differ only when a person picked its picture
+    (`image_source: "user"`)."""
+    automatic = [post for post in posts if post.get("image_source") != "user"]
+    pictures = {post.get("image_url") or None for post in automatic}
+    if len(pictures) <= 1:
+        return []
+    by_picture: dict[str, list[str]] = {}
+    for post in automatic:
+        by_picture.setdefault(post.get("image_url") or "(none)", []).append(str(post.get("channel") or post.get("name") or post.get("id")))
+    detail = "; ".join(f"{', '.join(names)}: {picture}" for picture, names in by_picture.items())
+    return [f"{label}: channels written together must share one picture ({detail}); set image_source user on a channel whose picture a person chose"]
+
+
+def picture_groups(value: dict) -> dict:
+    """Check that drafts written from one idea share one picture across channels."""
+    drafts = value.get("drafts", []) if isinstance(value, dict) else value
+    groups: dict[str, list[dict]] = {}
+    for draft in drafts:
+        key = draft.get("idea_id") or draft.get("group_id")
+        if key:
+            groups.setdefault(str(key), []).append(draft)
+    errors: list[str] = []
+    report = []
+    for key, items in sorted(groups.items()):
+        problems = shared_picture_errors(items, f"idea {key}")
+        errors.extend(problems)
+        automatic = [item.get("image_url") for item in items if item.get("image_source") != "user"]
+        report.append({"idea_id": key, "channels": [item.get("channel") for item in items], "picture": automatic[0] if automatic and not problems else None, "shared": not problems})
+    return {"valid": not errors, "errors": errors, "ideas": report}
+
+
 def validate(value: dict) -> list[str]:
     errors = [f"missing {key}" for key in REQUIRED if not value.get(key)]
     if value.get("status") not in {"draft", "approved", "scheduled", "publishing", "published", "failed", "cancelled"}:
@@ -84,7 +180,10 @@ def validate(value: dict) -> list[str]:
         errors.append(f"canonical_url is on {host_of(value['canonical_url'])}, not the workspace domain {domain}")
     elif not domain and value.get("status") in LIVE_STATUSES:
         errors.append("workspace_domain is required before approval: the source must be published on the workspace's own domain")
-    for channel in value.get("channels", []):
+    channels = value.get("channels", [])
+    if value.get("image_url"):
+        errors.extend(shared_picture_errors([{**channel, "image_url": channel.get("image_url", value["image_url"])} for channel in channels], "draft"))
+    for channel in channels:
         name = channel.get("name")
         if name not in LIMITS:
             errors.append(f"unsupported channel: {name}")
@@ -114,6 +213,13 @@ def main() -> int:
     create.add_argument("--channels", default="linkedin,facebook")
     create.add_argument("--workspace-domain", help="the workspace's own site domain; the source must be published there")
     create.add_argument("--output")
+    create.add_argument("--check-link", action="store_true", help="fetch canonical_url first and refuse a definite 404/410")
+    pictures = sub.add_parser("pictures", help="check that drafts written from one idea share one picture on every channel")
+    pictures.add_argument("input", help='JSON: {"drafts": [{"id", "idea_id", "channel", "image_url", "image_source"?}]}')
+    links = sub.add_parser("link-check", help="drop articles whose link is gone (404/410) before planning posts; keep blocked or failing pages")
+    links.add_argument("input", help="JSON: a list of URLs or article objects with canonical_url, or {\"articles\": [...]}")
+    links.add_argument("--cache", default=".maggie/social-link-cache.json", help="verdict cache (default: .maggie/social-link-cache.json); 'none' disables it")
+    links.add_argument("--ttl-hours", type=float, default=6.0)
     check = sub.add_parser("validate", help="validate a draft channel contract")
     check.add_argument("input")
     adapters = sub.add_parser("adapters", help="check canonical OAuth scope sets and shared OAuth clients")
@@ -134,6 +240,15 @@ def main() -> int:
     schema.add_argument("input")
     args = parser.parse_args()
     try:
+        if args.command == "link-check":
+            raw = json.loads(Path(args.input).read_text(encoding="utf-8"))
+            articles = raw.get("articles", []) if isinstance(raw, dict) else raw
+            urls = [item if isinstance(item, str) else item.get("canonical_url") or item.get("url") for item in articles]
+            result = check_links([url for url in urls if url], None if args.cache == "none" else Path(args.cache), args.ttl_hours, datetime.now(timezone.utc))
+            by_url = {item["url"]: item for item in result["results"]}
+            result["articles"] = [item for item in articles if by_url.get(item if isinstance(item, str) else (item.get("canonical_url") or item.get("url")), {}).get("verdict") != "gone"]
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 0
         value = read(Path(args.input))
         now = datetime.now(timezone.utc)
         if args.command == "schema-check":
@@ -143,6 +258,8 @@ def main() -> int:
             result = validate_adapters(value)
         elif args.command == "connections":
             result = connection_health(value, parse_instant(args.now, "--now") if args.now else now)
+        elif args.command == "pictures":
+            result = picture_groups(value if isinstance(value, dict) else {"drafts": value})
         elif args.command == "reconcile":
             result = reconcile(value)
         elif args.command == "campaigns":
@@ -156,6 +273,10 @@ def main() -> int:
             return 0
         else:
             if args.command == "plan":
+                if args.check_link and value.get("canonical_url"):
+                    status = fetch_status(value["canonical_url"])
+                    if link_verdict(status) == "gone":
+                        raise ValueError(f"canonical_url answers HTTP {status}: the article is gone; pick a live article (blocked or failing pages are not treated as gone)")
                 value = plan(value, [item.strip() for item in args.channels.split(",") if item.strip()], args.workspace_domain)
                 if args.output:
                     Path(args.output).parent.mkdir(parents=True, exist_ok=True)

package/bundled-tools/integrations/maggie-api-pull.md

@@ -74,6 +74,28 @@ The import is draft-only and never publishes. It rejects missing IDs, invalid
 slugs, and empty content; changed source checksums stop for manual conflict
 review. Approval and publication are separate MaggieDash transitions.
 
+## Where a delivered post went live
+
+A pulled post is useful to other channels (social posts that link it,
+internal links) only once its live URL is known; without it a planner falls
+back to an older stored URL, which after a platform move answers 404. So:
+
+1. When the site publishes a delivered post, it reports the URL it went live
+   at (`POST /content-tracking/report-state` with the content ID, the URL and
+   `published`) and records it locally:
+   `maggie blog live-urls record --content-id ID --url URL`. The site's report
+   is authoritative.
+2. A scheduled sitemap match fills the gaps:
+   `maggie blog live-urls match --sitemap https://example.com/sitemap.xml --write --report-body .maggie/live-urls-report.json`,
+   then send that body with `maggie api report-state --body-file … --execute`.
+
+Matching is **additive**: a post that already has a live URL keeps it, and a
+post this run did not find is left as it was — never marked unmatched — so the
+match can run daily without retiring earlier matches. When translated copies
+share the slug (`/blog/x`, `/zh-hans/blog/x`), the URL **without a locale
+segment** wins. The same two rules apply to the platform's own sitemap
+matching for API Pull destinations.
+
 ## Project context synchronization
 
 `GET /project-context` returns sanitized, read-only context scoped by the API

package/package.json

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