session-bundle-kit 0.3.1__py3-none-any.whl

session_bundle_kit/__init__.py

@@ -0,0 +1,20 @@
+"""Session bundle export, import, and diff toolkit."""
+
+from session_bundle_kit.bundle import SessionBundle
+from session_bundle_kit.diff import diff_bundles
+from session_bundle_kit.export import export_playwright_context
+from session_bundle_kit.import_bundle import import_bundle, validate_bundle
+from session_bundle_kit.models import BUNDLE_SPEC, BUNDLE_VERSION
+from session_bundle_kit.security import scan_plaintext_secrets
+
+__all__ = [
+    "BUNDLE_SPEC",
+    "BUNDLE_VERSION",
+    "SessionBundle",
+    "diff_bundles",
+    "export_playwright_context",
+    "import_bundle",
+    "scan_plaintext_secrets",
+    "validate_bundle",
+]
+__version__ = "0.3.1"

session_bundle_kit/bundle.py

@@ -0,0 +1,123 @@
+"""Session bundle zip read/write."""
+
+from __future__ import annotations
+
+import json
+import zipfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote, unquote
+
+from session_bundle_kit.models import (
+    BUNDLE_VERSION,
+    BundleManifest,
+    IndexedDbMeta,
+    OriginStorage,
+)
+
+
+@dataclass(slots=True)
+class SessionBundle:
+    manifest: BundleManifest
+    cookies: list[dict[str, Any]] = field(default_factory=list)
+    origins: list[OriginStorage] = field(default_factory=list)
+    indexeddb: list[IndexedDbMeta] = field(default_factory=list)
+
+    def to_playwright_storage_state(self) -> dict[str, Any]:
+        return {
+            "cookies": self.cookies,
+            "origins": [origin.to_dict() for origin in self.origins],
+        }
+
+    @classmethod
+    def from_playwright_storage_state(
+        cls,
+        payload: dict[str, Any],
+        *,
+        indexeddb: list[IndexedDbMeta] | None = None,
+    ) -> SessionBundle:
+        cookies = payload.get("cookies", [])
+        origins_raw = payload.get("origins", [])
+        origins = [OriginStorage.from_dict(item) for item in origins_raw if isinstance(item, dict)]
+        idb = indexeddb or []
+        manifest = BundleManifest(
+            version=BUNDLE_VERSION,
+            source="playwright-storage-state",
+            cookie_count=len(cookies) if isinstance(cookies, list) else 0,
+            origin_count=len(origins),
+            indexeddb_count=len(idb),
+        )
+        return cls(
+            manifest=manifest,
+            cookies=cookies if isinstance(cookies, list) else [],
+            origins=origins,
+            indexeddb=idb,
+        )
+
+    def write_zip(self, path: Path | str) -> None:
+        target = Path(path)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(target, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+            zf.writestr("manifest.json", json.dumps(self.manifest.to_dict(), indent=2))
+            zf.writestr("cookies.json", json.dumps(self.cookies, indent=2))
+            for origin in self.origins:
+                name = _origin_path(origin.origin)
+                zf.writestr(name, json.dumps(origin.to_dict(), indent=2))
+            if self.indexeddb:
+                zf.writestr(
+                    "indexeddb/metadata.json",
+                    json.dumps([item.to_dict() for item in self.indexeddb], indent=2),
+                )
+
+    @classmethod
+    def read_zip(cls, path: Path | str) -> SessionBundle:
+        target = Path(path)
+        if not target.is_file():
+            raise FileNotFoundError(f"Bundle not found: {target}")
+
+        with zipfile.ZipFile(target, "r") as zf:
+            names = zf.namelist()
+            if "manifest.json" not in names:
+                raise ValueError("Bundle missing manifest.json")
+            manifest_raw = json.loads(zf.read("manifest.json"))
+            if not isinstance(manifest_raw, dict):
+                raise ValueError("manifest.json must be a JSON object")
+            if "version" not in manifest_raw:
+                raise ValueError("manifest.json missing required field 'version'")
+            manifest = BundleManifest.from_dict(manifest_raw)
+            cookies = json.loads(zf.read("cookies.json")) if "cookies.json" in names else []
+            if not isinstance(cookies, list):
+                raise ValueError("cookies.json must be a JSON array")
+
+            origins: list[OriginStorage] = []
+            for name in names:
+                if name.startswith("origins/") and name.endswith(".json"):
+                    payload = json.loads(zf.read(name))
+                    if isinstance(payload, dict):
+                        origins.append(OriginStorage.from_dict(payload))
+
+            indexeddb: list[IndexedDbMeta] = []
+            if "indexeddb/metadata.json" in names:
+                raw = json.loads(zf.read("indexeddb/metadata.json"))
+                if isinstance(raw, list):
+                    indexeddb = [
+                        IndexedDbMeta.from_dict(item) for item in raw if isinstance(item, dict)
+                    ]
+
+        return cls(
+            manifest=manifest,
+            cookies=cookies,
+            origins=origins,
+            indexeddb=indexeddb,
+        )
+
+
+def _origin_path(origin: str) -> str:
+    safe = quote(origin, safe="")
+    return f"origins/{safe}.json"
+
+
+def origin_from_path(path: str) -> str:
+    name = Path(path).stem
+    return unquote(name)

session_bundle_kit/cli.py

@@ -0,0 +1,189 @@
+"""Click CLI for session-bundle."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import click
+
+from session_bundle_kit.diff import diff_bundles, format_diff
+from session_bundle_kit.export import export_playwright_context
+from session_bundle_kit.import_bundle import import_bundle
+
+EXIT_OK = 0
+EXIT_VALIDATION = 1
+EXIT_ERROR = 2
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(package_name="session-bundle-kit")
+@click.option("--show-deal", is_flag=True, help="Print Multilogin coupon info and exit.")
+@click.pass_context
+def main(ctx: click.Context, show_deal: bool) -> None:
+    """Export, import, and diff browser session bundles."""
+    if show_deal:
+        from session_bundle_kit.deal import print_show_deal
+
+        print_show_deal()
+        ctx.exit(0)
+
+
+@main.command("export")
+@click.option(
+    "--playwright-context",
+    "context_path",
+    type=click.Path(exists=True, path_type=Path),
+    required=True,
+)
+@click.option("-o", "--output", "output_path", type=click.Path(path_type=Path), required=True)
+def export_cmd(context_path: Path, output_path: Path) -> None:
+    """Export Playwright storage state JSON to a session bundle zip."""
+    try:
+        bundle = export_playwright_context(context_path, output_path)
+        click.echo(
+            f"Exported {bundle.manifest.cookie_count} cookies, "
+            f"{bundle.manifest.origin_count} origins -> {output_path}"
+        )
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+
+
+@main.command("import")
+@click.argument("bundle_path", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--dry-run/--apply",
+    "dry_run",
+    default=True,
+    show_default=True,
+    help="Validate only; never writes browser state (default).",
+)
+@click.option("--json", "as_json", is_flag=True)
+def import_cmd(bundle_path: Path, dry_run: bool, as_json: bool) -> None:
+    """Validate or import a session bundle."""
+    report = import_bundle(bundle_path, dry_run=dry_run)
+    if as_json:
+        click.echo(json.dumps(report.to_dict(), indent=2))
+    else:
+        status = "VALID" if report.valid else "INVALID"
+        click.echo(f"{status}: {bundle_path}")
+        click.echo(
+            f"  cookies={report.cookie_count} origins={report.origin_count} "
+            f"localStorage keys={report.local_storage_keys} "
+            f"sessionStorage keys={report.session_storage_keys} "
+            f"indexedDB meta={report.indexeddb_count}"
+        )
+        for issue in report.issues:
+            click.echo(f"  issue: {issue}")
+        for warning in report.warnings:
+            click.echo(f"  warn: {warning}", err=True)
+    if not report.valid:
+        sys.exit(EXIT_VALIDATION)
+    sys.exit(EXIT_OK)
+
+
+@main.command("diff")
+@click.argument("left_bundle", type=click.Path(exists=True, path_type=Path))
+@click.argument("right_bundle", type=click.Path(exists=True, path_type=Path))
+@click.option("--json", "as_json", is_flag=True)
+def diff_cmd(left_bundle: Path, right_bundle: Path, as_json: bool) -> None:
+    """Diff two session bundle zip files."""
+    try:
+        result = diff_bundles(left_bundle, right_bundle)
+        click.echo(json.dumps(result.to_dict(), indent=2) if as_json else format_diff(result))
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+
+
+@main.command("mlx-pull")
+@click.option("--profile-id", required=True, help="MLX profile UUID.")
+@click.option(
+    "-o",
+    "--output",
+    "output_path",
+    type=click.Path(path_type=Path),
+    required=True,
+    help="Output bundle.zip (session-bundle-v1).",
+)
+@click.option("--folder-id", envvar="MLX_FOLDER_ID", help="MLX folder UUID (export API).")
+@click.option("--token", envvar="MLX_TOKEN")
+@click.option("--launcher-url", default=None, help="Launcher base (MLX_LAUNCHER_URL).")
+@click.option("--no-unlock", is_flag=True, help="Skip Cloud API profile unlock.")
+def mlx_pull_cmd(
+    profile_id: str,
+    output_path: Path,
+    folder_id: str | None,
+    token: str | None,
+    launcher_url: str | None,
+    no_unlock: bool,
+) -> None:
+    """Export MLX profile session cookies to a neutral bundle.zip."""
+    from session_bundle_kit.mlx import MlxBundleClient, launcher_url_from_env, require_mlx_extra
+
+    require_mlx_extra()
+    if not token:
+        raise click.ClickException("--token or MLX_TOKEN required.")
+
+    client = MlxBundleClient(
+        token=token,
+        launcher_base=launcher_url or launcher_url_from_env(),
+    )
+    try:
+        result = client.pull_bundle(
+            profile_id,
+            output_path,
+            folder_id=folder_id,
+            unlock=not no_unlock,
+        )
+        click.echo(json.dumps(result, indent=2))
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+    finally:
+        client.close()
+
+
+@main.command("mlx-push")
+@click.option("--profile-id", required=True, help="MLX profile UUID.")
+@click.option(
+    "--bundle",
+    "bundle_path",
+    type=click.Path(exists=True, path_type=Path),
+    required=True,
+)
+@click.option("--token", envvar="MLX_TOKEN")
+@click.option("--launcher-url", default=None, help="Launcher base (MLX_LAUNCHER_URL).")
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Validate bundle and report import plan without calling MLX API.",
+)
+def mlx_push_cmd(
+    profile_id: str,
+    bundle_path: Path,
+    token: str | None,
+    launcher_url: str | None,
+    dry_run: bool,
+) -> None:
+    """Push session-bundle-v1 cookies to an MLX profile (Launcher import + unlock)."""
+    from session_bundle_kit.mlx import MlxBundleClient, launcher_url_from_env, require_mlx_extra
+
+    require_mlx_extra()
+    if not dry_run and not token:
+        raise click.ClickException("--token or MLX_TOKEN required (or use --dry-run).")
+
+    client = MlxBundleClient(
+        token=token or "",
+        launcher_base=launcher_url or launcher_url_from_env(),
+    )
+    try:
+        result = client.push_bundle(profile_id, bundle_path, dry_run=dry_run)
+        click.echo(json.dumps(result, indent=2))
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+    finally:
+        client.close()
+
+
+if __name__ == "__main__":
+    main()

session_bundle_kit/deal.py

@@ -0,0 +1,25 @@
+"""Multilogin partner coupon output for --show-deal."""
+
+from __future__ import annotations
+
+import click
+
+SHOW_DEAL_TEXT = """Partner info (affiliate links — optional, not required for session-bundle)
+
+Moving Playwright sessions into isolated profiles? MLX Launcher cookie import
+fits after export/dry-run — not as a substitute for matching proxy/fingerprint.
+
+Multilogin X — antidetect browser & cloud phone (verify eligibility before checkout)
+
+  SAAS50  — browser plans (eligible new purchases)
+  MIN50   — cloud phone (eligible new purchases)
+
+  https://multilogin.com/?ref=SAAS50
+  Coupons: https://anti-detect.github.io/
+  Scripts: https://t.me/Multilogin_Scripts_Bot
+
+Disclosure: we may earn a commission. Offers change; confirm on vendor site."""
+
+
+def print_show_deal() -> None:
+    click.echo(SHOW_DEAL_TEXT)

session_bundle_kit/diff.py

@@ -0,0 +1,120 @@
+"""Diff two session bundles."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from session_bundle_kit.bundle import SessionBundle
+
+
+@dataclass(slots=True)
+class BundleDiff:
+    cookies_added: int = 0
+    cookies_removed: int = 0
+    cookies_changed: int = 0
+    cookie_domains_added: list[str] = field(default_factory=list)
+    cookie_domains_removed: list[str] = field(default_factory=list)
+    cookie_domains_changed: list[str] = field(default_factory=list)
+    origins_added: list[str] = field(default_factory=list)
+    origins_removed: list[str] = field(default_factory=list)
+    storage_keys_changed: list[str] = field(default_factory=list)
+    indexeddb_changed: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "cookies": {
+                "added": self.cookies_added,
+                "removed": self.cookies_removed,
+                "changed": self.cookies_changed,
+                "domains_added": self.cookie_domains_added,
+                "domains_removed": self.cookie_domains_removed,
+                "domains_changed": self.cookie_domains_changed,
+            },
+            "origins": {
+                "added": self.origins_added,
+                "removed": self.origins_removed,
+            },
+            "storage_keys_changed": self.storage_keys_changed,
+            "indexeddb_changed": self.indexeddb_changed,
+        }
+
+
+def _cookie_key(cookie: dict[str, Any]) -> tuple[str, str, str]:
+    return (
+        str(cookie.get("domain", "")),
+        str(cookie.get("path", "/")),
+        str(cookie.get("name", "")),
+    )
+
+
+def _cookie_domain(cookie: dict[str, Any]) -> str:
+    return str(cookie.get("domain", ""))
+
+
+def diff_bundles(left_path: Path | str, right_path: Path | str) -> BundleDiff:
+    left = SessionBundle.read_zip(left_path)
+    right = SessionBundle.read_zip(right_path)
+    result = BundleDiff()
+
+    left_cookies = {_cookie_key(c): c for c in left.cookies}
+    right_cookies = {_cookie_key(c): c for c in right.cookies}
+    added_keys = set(right_cookies) - set(left_cookies)
+    removed_keys = set(left_cookies) - set(right_cookies)
+    result.cookies_added = len(added_keys)
+    result.cookies_removed = len(removed_keys)
+    result.cookie_domains_added = sorted({_cookie_domain(right_cookies[k]) for k in added_keys})
+    result.cookie_domains_removed = sorted({_cookie_domain(left_cookies[k]) for k in removed_keys})
+
+    changed_domains: set[str] = set()
+    for key in set(left_cookies) & set(right_cookies):
+        if left_cookies[key].get("value") != right_cookies[key].get("value"):
+            result.cookies_changed += 1
+            changed_domains.add(_cookie_domain(left_cookies[key]))
+    result.cookie_domains_changed = sorted(changed_domains)
+
+    left_origins = {o.origin: o for o in left.origins}
+    right_origins = {o.origin: o for o in right.origins}
+    result.origins_added = sorted(set(right_origins) - set(left_origins))
+    result.origins_removed = sorted(set(left_origins) - set(right_origins))
+
+    for origin in set(left_origins) & set(right_origins):
+        lo = left_origins[origin]
+        ro = right_origins[origin]
+        lk = {e.name: e.value for e in lo.local_storage + lo.session_storage}
+        rk = {e.name: e.value for e in ro.local_storage + ro.session_storage}
+        for name in set(lk) | set(rk):
+            if lk.get(name) != rk.get(name):
+                result.storage_keys_changed.append(f"{origin}::{name}")
+
+    left_idb = {(d.origin, d.database_name): d for d in left.indexeddb}
+    right_idb = {(d.origin, d.database_name): d for d in right.indexeddb}
+    for key in set(left_idb) | set(right_idb):
+        if left_idb.get(key) != right_idb.get(key):
+            result.indexeddb_changed.append(f"{key[0]}::{key[1]}")
+
+    return result
+
+
+def format_diff(diff: BundleDiff) -> str:
+    lines = [
+        "Session Bundle Diff",
+        "===================",
+        f"Cookies: +{diff.cookies_added} -{diff.cookies_removed} ~{diff.cookies_changed}",
+        f"  domains added:   {', '.join(diff.cookie_domains_added) or '(none)'}",
+        f"  domains removed: {', '.join(diff.cookie_domains_removed) or '(none)'}",
+        f"  domains changed: {', '.join(diff.cookie_domains_changed) or '(none)'}",
+        f"Origins added: {', '.join(diff.origins_added) or '(none)'}",
+        f"Origins removed: {', '.join(diff.origins_removed) or '(none)'}",
+        f"Storage keys changed: {len(diff.storage_keys_changed)}",
+        f"IndexedDB changed: {len(diff.indexeddb_changed)}",
+    ]
+    if diff.storage_keys_changed:
+        lines.append("")
+        lines.append("Storage changes:")
+        for item in diff.storage_keys_changed[:20]:
+            lines.append(f"  - {item}")
+        if len(diff.storage_keys_changed) > 20:
+            lines.append(f"  ... and {len(diff.storage_keys_changed) - 20} more")
+    return "\n".join(lines) + "\n"

session_bundle_kit/export.py

@@ -0,0 +1,33 @@
+"""Export Playwright storage state to bundle zip."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from session_bundle_kit.bundle import SessionBundle
+from session_bundle_kit.models import IndexedDbMeta
+
+
+def load_playwright_context(path: Path | str) -> dict[str, Any]:
+    payload = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError("Playwright storage state must be a JSON object")
+    return payload
+
+
+def export_playwright_context(
+    context_path: Path | str,
+    output_path: Path | str,
+    *,
+    indexeddb_metadata: list[IndexedDbMeta] | None = None,
+) -> SessionBundle:
+    """Create a session bundle zip from Playwright storage state JSON."""
+    payload = load_playwright_context(context_path)
+    bundle = SessionBundle.from_playwright_storage_state(
+        payload,
+        indexeddb=indexeddb_metadata,
+    )
+    bundle.write_zip(output_path)
+    return bundle

session_bundle_kit/import_bundle.py

@@ -0,0 +1,110 @@
+"""Import and validate session bundles."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from session_bundle_kit.bundle import SessionBundle
+from session_bundle_kit.models import BUNDLE_SPEC, BUNDLE_VERSION, SUPPORTED_SPECS
+from session_bundle_kit.security import scan_plaintext_secrets
+
+
+@dataclass(slots=True)
+class ImportReport:
+    valid: bool
+    bundle_path: str
+    cookie_count: int = 0
+    origin_count: int = 0
+    indexeddb_count: int = 0
+    local_storage_keys: int = 0
+    session_storage_keys: int = 0
+    issues: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    dry_run: bool = True
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "valid": self.valid,
+            "bundle_path": self.bundle_path,
+            "dry_run": self.dry_run,
+            "counts": {
+                "cookies": self.cookie_count,
+                "origins": self.origin_count,
+                "indexeddb": self.indexeddb_count,
+                "local_storage_keys": self.local_storage_keys,
+                "session_storage_keys": self.session_storage_keys,
+            },
+            "issues": self.issues,
+            "warnings": self.warnings,
+        }
+
+
+def validate_bundle(path: Path | str) -> ImportReport:
+    report = ImportReport(valid=True, bundle_path=str(path), dry_run=True)
+    try:
+        bundle = SessionBundle.read_zip(path)
+    except (OSError, ValueError, json.JSONDecodeError) as exc:
+        report.valid = False
+        report.issues.append(str(exc))
+        return report
+
+    _validate_manifest(bundle, report)
+
+    report.cookie_count = len(bundle.cookies)
+    report.origin_count = len(bundle.origins)
+    report.indexeddb_count = len(bundle.indexeddb)
+    report.local_storage_keys = sum(len(o.local_storage) for o in bundle.origins)
+    report.session_storage_keys = sum(len(o.session_storage) for o in bundle.origins)
+
+    if bundle.manifest.cookie_count != report.cookie_count:
+        report.issues.append(
+            f"manifest cookie_count={bundle.manifest.cookie_count} "
+            f"but cookies.json has {report.cookie_count}"
+        )
+    if bundle.manifest.origin_count != report.origin_count:
+        report.issues.append(
+            f"manifest origin_count={bundle.manifest.origin_count} "
+            f"but found {report.origin_count} origin files"
+        )
+
+    for cookie in bundle.cookies:
+        if not cookie.get("name") or not cookie.get("domain"):
+            report.issues.append(f"cookie missing name/domain: {cookie!r}")
+            report.valid = False
+
+    report.warnings.extend(scan_plaintext_secrets(bundle))
+    if report.issues:
+        report.valid = False
+    return report
+
+
+def _validate_manifest(bundle: SessionBundle, report: ImportReport) -> None:
+    manifest = bundle.manifest
+    if manifest.spec not in SUPPORTED_SPECS:
+        report.warnings.append(
+            f"unknown bundle spec {manifest.spec!r} (supported: {sorted(SUPPORTED_SPECS)})"
+        )
+    if manifest.version > BUNDLE_VERSION:
+        report.warnings.append(
+            f"bundle version {manifest.version} is newer than toolkit v{BUNDLE_VERSION}"
+        )
+    elif manifest.version < BUNDLE_VERSION:
+        report.warnings.append(
+            f"bundle version {manifest.version} is older than current spec {BUNDLE_SPEC}"
+        )
+    if manifest.spec != BUNDLE_SPEC and manifest.version == BUNDLE_VERSION:
+        report.warnings.append(f"expected spec {BUNDLE_SPEC!r}, got {manifest.spec!r}")
+
+
+def import_bundle(path: Path | str, *, dry_run: bool = True) -> ImportReport:
+    """Validate a bundle; dry-run performs no writes (default)."""
+    report = validate_bundle(path)
+    report.dry_run = dry_run
+    if not dry_run:
+        report.warnings.append(
+            "Live browser import not implemented; use Playwright storage_state API"
+        )
+    return report

session_bundle_kit/mlx.py

@@ -0,0 +1,285 @@
+"""MLX profile session export (pull) and bundle import (push)."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from session_bundle_kit.bundle import SessionBundle
+from session_bundle_kit.import_bundle import validate_bundle
+from session_bundle_kit.models import BUNDLE_SPEC, BUNDLE_VERSION, BundleManifest
+
+_MLX_HINT = "Install MLX support with: pip install session-bundle-kit[mlx]"
+DEFAULT_CLOUD_BASE = "https://api.multilogin.com"
+DEFAULT_LAUNCHER_BASE = "https://launcher.mlx.yt:45001"
+
+
+def require_mlx_extra() -> None:
+    if importlib.util.find_spec("httpx") is None:
+        raise ImportError(_MLX_HINT)
+
+
+def token_from_env() -> str | None:
+    return os.environ.get("MLX_TOKEN")
+
+
+def launcher_url_from_env() -> str:
+    return (
+        os.environ.get("MLX_LAUNCHER_URL")
+        or os.environ.get("MLX_LAUNCHER_HOST")
+        or DEFAULT_LAUNCHER_BASE
+    ).rstrip("/")
+
+
+def cloud_url_from_env() -> str:
+    return os.environ.get("MLX_CLOUD_URL", DEFAULT_CLOUD_BASE).rstrip("/")
+
+
+def cookies_to_mlx(cookies: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Playwright storage_state cookies → MLX Launcher import format."""
+    payload: list[dict[str, Any]] = []
+    for cookie in cookies:
+        item: dict[str, Any] = {
+            "domain": cookie.get("domain", ""),
+            "name": cookie.get("name", ""),
+            "value": cookie.get("value", ""),
+            "path": cookie.get("path", "/"),
+            "httpOnly": bool(cookie.get("httpOnly", False)),
+            "secure": bool(cookie.get("secure", False)),
+        }
+        expires = cookie.get("expires")
+        if expires not in (None, -1, "-1"):
+            item["expirationDate"] = expires
+        if cookie.get("sameSite"):
+            item["sameSite"] = cookie["sameSite"]
+        payload.append(item)
+    return payload
+
+
+def cookies_from_mlx(cookies: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """MLX export cookies → Playwright storage_state cookie list."""
+    payload: list[dict[str, Any]] = []
+    for cookie in cookies:
+        item: dict[str, Any] = {
+            "domain": cookie.get("domain", ""),
+            "name": cookie.get("name", ""),
+            "value": cookie.get("value", ""),
+            "path": cookie.get("path", "/"),
+            "httpOnly": bool(cookie.get("httpOnly", False)),
+            "secure": bool(cookie.get("secure", False)),
+        }
+        expires = cookie.get("expirationDate", cookie.get("expires"))
+        if expires not in (None, -1, "-1"):
+            item["expires"] = expires
+        if cookie.get("sameSite"):
+            item["sameSite"] = cookie["sameSite"]
+        payload.append(item)
+    return payload
+
+
+def parse_mlx_cookie_export(data: dict[str, Any]) -> list[dict[str, Any]]:
+    """Normalize MLX ``/cookies/export`` data.cookies (array or JSON string)."""
+    raw = data.get("cookies")
+    if raw is None:
+        return []
+    if isinstance(raw, str):
+        parsed = json.loads(raw)
+        if isinstance(parsed, str):
+            parsed = json.loads(parsed)
+        raw = parsed
+    if not isinstance(raw, list):
+        raise RuntimeError("MLX export cookies must be a JSON array")
+    mlx_cookies = [item for item in raw if isinstance(item, dict)]
+    return cookies_from_mlx(mlx_cookies)
+
+
+def bundle_from_mlx_cookies(
+    cookies: list[dict[str, Any]],
+    *,
+    profile_id: str,
+) -> SessionBundle:
+    """Build neutral session-bundle-v1 from MLX-exported cookies only."""
+    manifest = BundleManifest(
+        version=BUNDLE_VERSION,
+        spec=BUNDLE_SPEC,
+        source="mlx-profile-export",
+        cookie_count=len(cookies),
+        origin_count=0,
+        indexeddb_count=0,
+    )
+    return SessionBundle(
+        manifest=manifest,
+        cookies=cookies,
+        origins=[],
+        indexeddb=[],
+    )
+
+
+class MlxBundleClient:
+    """Pull (export) and push (import) session bundles via MLX APIs."""
+
+    def __init__(
+        self,
+        *,
+        token: str,
+        cloud_base: str | None = None,
+        launcher_base: str | None = None,
+        timeout: float = 60.0,
+        transport: Any | None = None,
+    ) -> None:
+        require_mlx_extra()
+        import httpx  # noqa: PLC0415
+
+        cloud_kwargs: dict[str, Any] = {
+            "base_url": (cloud_base or cloud_url_from_env()).rstrip("/"),
+            "timeout": timeout,
+        }
+        launcher_kwargs: dict[str, Any] = {
+            "base_url": (launcher_base or launcher_url_from_env()).rstrip("/"),
+            "timeout": timeout,
+        }
+        if transport is not None:
+            cloud_kwargs["transport"] = transport
+            launcher_kwargs["transport"] = transport
+
+        self._cloud = httpx.Client(**cloud_kwargs)
+        self._launcher = httpx.Client(**launcher_kwargs)
+        self._token = token
+
+    def close(self) -> None:
+        self._cloud.close()
+        self._launcher.close()
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self._token}",
+        }
+
+    def unlock_profile(self, profile_id: str) -> dict[str, Any]:
+        response = self._cloud.get(
+            "/profile/unlock",
+            headers=self._headers(),
+            params={"profile_ids": profile_id},
+        )
+        return _check(response)
+
+    def export_cookies(
+        self,
+        profile_id: str,
+        *,
+        folder_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        body: dict[str, str] = {"profile_id": profile_id}
+        if folder_id:
+            body["folder_id"] = folder_id
+        response = self._launcher.post(
+            "/api/v1/cookies/export",
+            headers=self._headers(),
+            json=body,
+        )
+        data = _check(response)
+        return parse_mlx_cookie_export(data)
+
+    def import_cookies(self, profile_id: str, cookies: list[dict[str, Any]]) -> dict[str, Any]:
+        response = self._launcher.post(
+            "/api/v1/cookies/import",
+            headers=self._headers(),
+            json={"profile_id": profile_id, "cookies": cookies},
+        )
+        return _check(response)
+
+    def pull_bundle(
+        self,
+        profile_id: str,
+        output_path: Path | str,
+        *,
+        folder_id: str | None = None,
+        unlock: bool = True,
+    ) -> dict[str, Any]:
+        """Export MLX profile cookies into a session-bundle-v1 zip."""
+        unlock_result: dict[str, Any] | None = None
+        if unlock:
+            unlock_result = self.unlock_profile(profile_id)
+
+        cookies = self.export_cookies(profile_id, folder_id=folder_id)
+        bundle = bundle_from_mlx_cookies(cookies, profile_id=profile_id)
+        bundle.write_zip(output_path)
+
+        return {
+            "profile_id": profile_id,
+            "output": str(output_path),
+            "spec": BUNDLE_SPEC,
+            "cookie_count": len(cookies),
+            "origin_count": 0,
+            "indexeddb_metadata": 0,
+            "unlock": unlock_result,
+            "note": (
+                "MLX export provides cookies only; localStorage/sessionStorage/IDB "
+                "are not included in Launcher cookie export"
+            ),
+        }
+
+    def push_bundle(
+        self,
+        profile_id: str,
+        bundle_path: Path | str,
+        *,
+        dry_run: bool = False,
+    ) -> dict[str, Any]:
+        """Import session-bundle-v1 cookies into an MLX profile."""
+        report = validate_bundle(bundle_path)
+        bundle = SessionBundle.read_zip(bundle_path)
+        mlx_cookies = cookies_to_mlx(bundle.cookies)
+
+        result: dict[str, Any] = {
+            "profile_id": profile_id,
+            "bundle_path": str(bundle_path),
+            "spec": bundle.manifest.spec,
+            "valid": report.valid,
+            "cookie_count": len(mlx_cookies),
+            "origin_count": len(bundle.origins),
+            "indexeddb_metadata": len(bundle.indexeddb),
+            "dry_run": dry_run,
+            "issues": list(report.issues),
+            "warnings": list(report.warnings),
+            "note": (
+                "localStorage/sessionStorage/IDB are manifest-only; cookies pushed via Launcher"
+            ),
+        }
+
+        if not report.valid:
+            raise RuntimeError(f"Bundle validation failed: {', '.join(report.issues)}")
+
+        if dry_run:
+            result["would_import_cookies"] = len(mlx_cookies)
+            return result
+
+        unlock = self.unlock_profile(profile_id)
+        imported = self.import_cookies(profile_id, mlx_cookies)
+        result["unlock"] = unlock
+        result["import"] = imported
+        return result
+
+
+# Backward-compatible alias
+MlxBundlePusher = MlxBundleClient
+
+
+def _check(response: Any) -> dict[str, Any]:
+    body = response.json()
+    if response.status_code >= 400:
+        status = body.get("status", {}) if isinstance(body, dict) else {}
+        message = status.get("message") if isinstance(status, dict) else response.text
+        raise RuntimeError(message or f"HTTP {response.status_code}")
+    if isinstance(body, dict):
+        status = body.get("status", {})
+        if isinstance(status, dict) and status.get("error_code"):
+            raise RuntimeError(str(status.get("message") or status["error_code"]))
+        data = body.get("data")
+        return data if isinstance(data, dict) else {"raw": data}
+    return {"raw": body}

session_bundle_kit/models.py

@@ -0,0 +1,113 @@
+"""Bundle data models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+BUNDLE_VERSION = 1
+BUNDLE_SPEC = "session-bundle-v1"
+SUPPORTED_SPECS = frozenset({BUNDLE_SPEC})
+
+
+@dataclass(slots=True)
+class StorageEntry:
+    name: str
+    value: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {"name": self.name, "value": self.value}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> StorageEntry:
+        return cls(name=str(data.get("name", "")), value=str(data.get("value", "")))
+
+
+@dataclass(slots=True)
+class OriginStorage:
+    origin: str
+    local_storage: list[StorageEntry] = field(default_factory=list)
+    session_storage: list[StorageEntry] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "origin": self.origin,
+            "localStorage": [e.to_dict() for e in self.local_storage],
+            "sessionStorage": [e.to_dict() for e in self.session_storage],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> OriginStorage:
+        return cls(
+            origin=str(data.get("origin", "")),
+            local_storage=[
+                StorageEntry.from_dict(item)
+                for item in data.get("localStorage", [])
+                if isinstance(item, dict)
+            ],
+            session_storage=[
+                StorageEntry.from_dict(item)
+                for item in data.get("sessionStorage", [])
+                if isinstance(item, dict)
+            ],
+        )
+
+
+@dataclass(slots=True)
+class IndexedDbMeta:
+    origin: str
+    database_name: str
+    version: int | None = None
+    object_stores: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "origin": self.origin,
+            "database_name": self.database_name,
+        }
+        if self.version is not None:
+            payload["version"] = self.version
+        if self.object_stores:
+            payload["object_stores"] = self.object_stores
+        return payload
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> IndexedDbMeta:
+        stores = data.get("object_stores", [])
+        return cls(
+            origin=str(data.get("origin", "")),
+            database_name=str(data.get("database_name", "")),
+            version=data.get("version"),
+            object_stores=[str(s) for s in stores] if isinstance(stores, list) else [],
+        )
+
+
+@dataclass(slots=True)
+class BundleManifest:
+    version: int = BUNDLE_VERSION
+    spec: str = BUNDLE_SPEC
+    source: str = "playwright-storage-state"
+    cookie_count: int = 0
+    origin_count: int = 0
+    indexeddb_count: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "spec": self.spec,
+            "version": self.version,
+            "source": self.source,
+            "cookie_count": self.cookie_count,
+            "origin_count": self.origin_count,
+            "indexeddb_count": self.indexeddb_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> BundleManifest:
+        return cls(
+            version=int(data.get("version", BUNDLE_VERSION)),
+            spec=str(data.get("spec", BUNDLE_SPEC)),
+            source=str(data.get("source", "unknown")),
+            cookie_count=int(data.get("cookie_count", 0)),
+            origin_count=int(data.get("origin_count", 0)),
+            indexeddb_count=int(data.get("indexeddb_count", 0)),
+        )

session_bundle_kit/security.py

@@ -0,0 +1,38 @@
+"""Security checks for session bundle contents."""
+
+from __future__ import annotations
+
+import re
+
+from session_bundle_kit.bundle import SessionBundle
+
+_SECRET_KEY_RE = re.compile(
+    r"(password|passwd|pwd|passphrase|secret|credential|api[_-]?key|auth[_-]?token)",
+    re.IGNORECASE,
+)
+_INLINE_PASSWORD_RE = re.compile(
+    r'["\']?(?:password|passwd|pwd)["\']?\s*[:=]\s*["\']?[^"\']{4,}',
+    re.IGNORECASE,
+)
+
+
+def scan_plaintext_secrets(bundle: SessionBundle) -> list[str]:
+    """Return warnings for likely plaintext secrets in web storage."""
+    warnings: list[str] = []
+    for origin in bundle.origins:
+        for store, entries in (
+            ("localStorage", origin.local_storage),
+            ("sessionStorage", origin.session_storage),
+        ):
+            for entry in entries:
+                if _SECRET_KEY_RE.search(entry.name):
+                    warnings.append(
+                        f"{store} key {entry.name!r} on {origin.origin} "
+                        "may store a plaintext password or secret"
+                    )
+                elif _INLINE_PASSWORD_RE.search(entry.value):
+                    warnings.append(
+                        f"{store} value on {origin.origin} (key {entry.name!r}) "
+                        "looks like embedded credential JSON"
+                    )
+    return warnings

session_bundle_kit-0.3.1.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: session-bundle-kit
+Version: 0.3.1
+Summary: Playwright storage_state zip export — backup sessions, diff bundles, MLX cookie pull/push. CLI: session-bundle.
+Project-URL: Homepage, https://github.com/session-bundle-kit/session-bundle-kit
+Project-URL: Documentation, https://github.com/session-bundle-kit/session-bundle-kit#readme
+Project-URL: Repository, https://github.com/session-bundle-kit/session-bundle-kit
+Project-URL: Issues, https://github.com/session-bundle-kit/session-bundle-kit/issues
+Author: session-bundle-kit contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: browser-backup,browser-session-migration,chrome-136,context-backup,cookie-export,indexeddb-manifest,localstorage-backup,multilogin-cookies,playwright-storage-state,portable-session,session-bundle,session-diff,session-export,session-restore,storage-state,zip-export
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.34; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Provides-Extra: mlx
+Requires-Dist: httpx>=0.27; extra == 'mlx'
+Description-Content-Type: text/markdown
+
+# session-bundle-kit
+
+**Playwright session export & backup** — zip storage_state cookies and localStorage; MLX cookie pull/push for profile migration.
+
+[![PyPI version](https://img.shields.io/pypi/v/session-bundle-kit.svg)](https://pypi.org/project/session-bundle-kit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/session-bundle-kit.svg)](https://pypi.org/project/session-bundle-kit/)
+[![License: MIT](https://img.shields.io/pypi/l/session-bundle-kit.svg)](https://pypi.org/project/session-bundle-kit/)
+
+```bash
+pip install session-bundle-kit
+session-bundle export state.json -o bundle.zip
+```
+
+CLI: **`session-bundle`** · Python **3.10+** · optional **`[mlx]`** for Launcher helpers
+
+**Playwright session export & backup** — zip `storage_state` cookies and localStorage; MLX cookie pull/push for profile migration.
+
+Export and compare **browser session bundles** — cookies, `localStorage`, `sessionStorage`, and IndexedDB metadata — from Playwright storage state JSON.
+
+Pure Python zip format. Optional MLX push for cookie import into antidetect profiles.
+
+## Problem
+
+Playwright `storage_state.json` is a single file mixing cookies and per-origin storage. Teams need:
+
+- Portable **zip bundles** with a manifest for CI and backups
+- **Dry-run validation** before restoring sessions
+- **Diff** between two session snapshots
+- Push cookies into **MLX profiles** after export
+
+## Install
+
+```bash
+pip install session-bundle-kit
+```
+
+MLX profile push:
+
+```bash
+pip install session-bundle-kit[mlx]
+```
+
+## Quick start
+
+```bash
+# Export Playwright storage state -> bundle zip
+session-bundle export --playwright-context ./state.json -o bundle.zip
+
+# Validate bundle (dry-run default)
+session-bundle import bundle.zip --dry-run
+
+# Compare two bundles
+session-bundle diff bundle_a.zip bundle_b.zip
+```
+
+## Bundle format (spec v1)
+
+```
+bundle.zip
+├── manifest.json          # spec, version, counts, source
+├── cookies.json           # Playwright cookie list
+├── origins/
+│   └── https%3A%2F%2Fexample.com.json   # localStorage + sessionStorage
+└── indexeddb/
+    └── metadata.json      # IDB database names/versions (metadata only)
+```
+
+IndexedDB **metadata** is included for audit/diff; full IDB binary export is out of scope.
+
+`manifest.json` example:
+
+```json
+{
+  "spec": "session-bundle-v1",
+  "version": 1,
+  "source": "playwright-storage-state",
+  "cookie_count": 12,
+  "origin_count": 3,
+  "indexeddb_count": 0
+}
+```
+
+## CLI
+
+| Command | Description |
+|---------|-------------|
+| `session-bundle export --playwright-context FILE -o OUT.zip` | Create bundle from Playwright state |
+| `session-bundle import FILE --dry-run` | Validate bundle without writing (default) |
+| `session-bundle diff A.zip B.zip` | Cookie domain + storage/IDB diff |
+| `session-bundle mlx-pull --profile-id UUID -o bundle.zip` | Export MLX profile cookies → bundle (`[mlx]`) |
+| `session-bundle mlx-push --profile-id UUID --bundle FILE` | Import bundle cookies to MLX (`[mlx]`) |
+| `session-bundle mlx-push ... --dry-run` | Validate bundle; no MLX API calls |
+
+## API
+
+```python
+from session_bundle_kit import export_playwright_context, validate_bundle, diff_bundles
+
+export_playwright_context("state.json", "bundle.zip")
+report = validate_bundle("bundle.zip")
+diff = diff_bundles("old.zip", "new.zip")
+```
+
+Restore to Playwright:
+
+```python
+from session_bundle_kit.bundle import SessionBundle
+
+bundle = SessionBundle.read_zip("bundle.zip")
+context = await browser.new_context(storage_state=bundle.to_playwright_storage_state())
+```
+
+## MLX pull / push (`[mlx]` extra)
+
+Round-trip **cookies** between MLX profiles and neutral **session-bundle-v1** zips. Storage/IDB in bundles from Playwright export are manifest-only on push; MLX Launcher APIs move cookies only.
+
+**Pull** (profile → zip):
+
+1. `GET api.multilogin.com/profile/unlock?profile_ids=UUID`
+2. `POST launcher.mlx.yt:45001/api/v1/cookies/export`
+
+**Push** (zip → profile):
+
+1. Validate bundle (`--dry-run` stops here)
+2. `GET api.multilogin.com/profile/unlock?profile_ids=UUID`
+3. `POST launcher.mlx.yt:45001/api/v1/cookies/import`
+
+```bash
+export MLX_TOKEN="..."
+
+# Export MLX profile session to portable bundle
+session-bundle mlx-pull --profile-id PROFILE_UUID -o bundle.zip
+
+# Validate before import
+session-bundle mlx-push --profile-id PROFILE_UUID --bundle bundle.zip --dry-run
+
+# Import cookies into target profile
+session-bundle mlx-push --profile-id PROFILE_UUID --bundle bundle.zip
+```
+
+Peer pattern for Launcher lifecycle: see `cdp-connect-kit` MLX integration docs.
+
+## When login sessions break after profile switch (playbook)
+
+Sites re-challenge when cookies land on a **new fingerprint or IP**. Use bundles to move **stored** credentials deliberately — not as a bypass.
+
+| Symptom | Likely cause | Next step |
+|---------|--------------|-----------|
+| Import ok, still logged out | Domain/subdomain mismatch, expired cookies | `session-bundle diff` old vs new; fix with [cookie-jar-bridge](https://pypi.org/project/cookie-jar-bridge/) |
+| Step-up / CAPTCHA after restore | IP or fingerprint drift | Match proxy lane; probe with [playwright-cdp-probe](https://pypi.org/project/playwright-cdp-probe/) |
+| MLX push succeeds, site fails | Cookies only — no `localStorage` on target | Restore storage via Playwright `storage_state` on same profile |
+| Migration metadata only | `antidetect-importer` left `_cookies` sidecar | `mlx-pull` source → edit → `mlx-push --dry-run` → push |
+
+**Session migration pipeline:**
+
+```bash
+session-bundle export --playwright-context state.json -o bundle.zip
+session-bundle import bundle.zip --dry-run
+session-bundle mlx-push --profile-id TARGET_UUID --bundle bundle.zip --dry-run
+export MLX_TOKEN=...
+session-bundle mlx-push --profile-id TARGET_UUID --bundle bundle.zip
+cdp-probe mlx --profile-id TARGET_UUID --url https://your-app.example  # verify session + exposure
+```
+
+Treat bundle zips as **secrets** — same sensitivity as password files.
+
+## When Chrome `user-data-dir` fails in 2026
+
+Starting with **Chrome 136** (March 2025), Google changed how remote debugging works on the default profile. Per the [Chrome Developers blog](https://developer.chrome.com/blog/remote-debugging-port):
+
+- `--remote-debugging-port` and `--remote-debugging-pipe` are **ignored** when targeting Chrome's **default** user data directory.
+- You must pass a **custom** `--user-data-dir` pointing to a non-default profile path for CDP to bind.
+- The change targets cookie theft via remote debugging after [App-Bound Encryption](https://developer.chrome.com/blog/app-bound-encryption); Chrome for Testing still supports the older automation workflow.
+
+**Practical impact:** copying your daily `Default` profile and launching with `--remote-debugging-port` no longer works on stock Chrome 136+. Session-bundle-kit sidesteps this by exporting **Playwright `storage_state.json`** (cookies + origin storage) into portable zips — restore via `new_context(storage_state=...)` on antidetect or isolated profiles instead of attaching CDP to your real Chrome profile.
+
+Enterprise admins can still control remote debugging via the [Allow remote debugging](https://support.google.com/chrome/a/answer/2657289) Chrome policy on managed devices.
+
+## Limitations
+
+- **No live IDB export** — IndexedDB section is metadata manifest only.
+- **sessionStorage** preserved in bundle format but Playwright native export may omit it; include in custom state JSON if needed.
+- **mlx-push** imports cookies only; storage must be restored via Playwright or profile sync separately.
+- **Secrets** — bundles contain session secrets; treat zip files as credentials. Import warns on likely plaintext passwords in web storage.
+
+## Production
+
+Export sessions to portable zips, validate with `mlx-push --dry-run`, then import cookies into MLX profiles after `antidetect-importer` migration or failed login on a new profile.
+
+**Partner note (affiliate):** When restoring sessions into **isolated Multilogin X** profiles (not shared Chrome `user-data-dir`), Launcher cookie import pairs with profile-level proxy and fingerprint. Eligible new browser purchases may accept code **`SAAS50`** at [multilogin.com](https://multilogin.com/?ref=SAAS50) — verify terms before checkout. Export/diff/validate work without MLX. Full disclosure: [docs/AFFILIATE.md](docs/AFFILIATE.md). Coupon details only via `session-bundle --show-deal` (never printed by default).
+
+**FAQ:** [docs/FAQ.md](docs/FAQ.md) — Playwright storage_state export, Chrome 136 CDP, MLX cookie import.
+
+
+## Related tools (on PyPI)
+
+| Package | CLI | Role |
+|---------|-----|------|
+| [playwright-cdp-probe](https://pypi.org/project/playwright-cdp-probe/) | `cdp-probe` | CDP / WebDriver exposure score |
+| [cookie-jar-bridge](https://pypi.org/project/cookie-jar-bridge/) | `cookie-bridge` | Netscape ↔ Playwright cookies |
+| [proxy-lane-checker](https://pypi.org/project/proxy-lane-checker/) | `proxy-lane` | Proxy TCP / HTTP / geo / DNSBL |
+| [fingerprint-coherence](https://pypi.org/project/fingerprint-coherence/) | `fp-coherence` | UA / screen / timezone lint |
+
+**Toolkit pipeline:** `proxy-lane check` → `fp-coherence audit` → automate → `cdp-probe run` → `cookie-bridge validate`
+
+## License
+
+MIT
+
+---
+
+**Production antidetect:** [Multilogin X](https://multilogin.com/?ref=SAAS50) · Code `SAAS50` (-50% browser) · `MIN50` (-50% cloud phone)  
+More scripts: [@Multilogin_Scripts_Bot](https://t.me/Multilogin_Scripts_Bot) · [Coupons](https://anti-detect.github.io/)

session_bundle_kit-0.3.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+session_bundle_kit/__init__.py,sha256=7Ohl5YiaV7ZKvYg-Fn8eD7jpvp73B8jfs5MVmNRdJ2c,652
+session_bundle_kit/bundle.py,sha256=AQMO-YDvsIiN0D7zWZsueK-rTIB65QpAy--zvh1e4iM,4489
+session_bundle_kit/cli.py,sha256=JkZxU3JhTeG5MnDmvgmRmjMTC8obaE7KX6CXAk_bFUg,6225
+session_bundle_kit/deal.py,sha256=H4CiOBsqh4U88YbtOPJctPMa4l7POqBCLvFLByDEHKQ,830
+session_bundle_kit/diff.py,sha256=GuSUoOXX_zMUdCjTHhqlMFybMC1HCU2r5tP7ciRioi0,4975
+session_bundle_kit/export.py,sha256=oEa44APpZtc-Vm3gIHxE9eXSzwBrDTQjMWlj8G9qjP8,994
+session_bundle_kit/import_bundle.py,sha256=93BB2zU0iomPUwphVAzOblp53nTbXHtEm4zp7ookMCs,3972
+session_bundle_kit/mlx.py,sha256=tC63fRqZyFwaR1JeubPncRzLUMPPXlbBHrR_lOkhBWI,9462
+session_bundle_kit/models.py,sha256=8AfKOx_YHU6AcrpzNeTsAck9Rp5dp46kbnX_tO8BWHs,3506
+session_bundle_kit/security.py,sha256=_6R2f1WTwbRKFQLdhH__bIj--Gt5qOf-3rtXCZ4qoeU,1337
+session_bundle_kit-0.3.1.dist-info/METADATA,sha256=rCGL3-Qln7zSBiVMha_CPkysO8l2wBd3ch-b35WtCrA,11364
+session_bundle_kit-0.3.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+session_bundle_kit-0.3.1.dist-info/entry_points.txt,sha256=sX9LBSfqC__eOyTBpJbdIhxxI5E_HnfbX3JN_sS6TPQ,63
+session_bundle_kit-0.3.1.dist-info/licenses/LICENSE,sha256=vVN3xzHbJKXlwLBCl91WK95OLPEtmqu3AlnSpz3UJx0,1088
+session_bundle_kit-0.3.1.dist-info/RECORD,,

session_bundle_kit-0.3.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

session_bundle_kit-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+session-bundle = session_bundle_kit.cli:main

session_bundle_kit-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 session-bundle-kit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.