twinerd-browser-vault 0.1.0__tar.gz

twinerd_browser_vault-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: twinerd-browser-vault
+Version: 0.1.0
+Summary: Browser profile snapshots, session cookie migration, and credential vault for Chrome, Chromium, and Firefox
+Author-email: Tomasz Sapletta <info@softreck.com>
+License: Proprietary
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# twinerd-browser-vault
+
+Browser profile snapshots, session cookie migration, and credential vault management for Chrome, Chromium, and Firefox.
+
+## Features
+
+- **Profile Discovery & Inspection**: Locates and analyzes profile state and size for Firefox, Chromium, Google Chrome, Brave, Edge, Opera, and Vivaldi.
+- **Session Continuity (Cookie Sync)**: Migrates authenticated session cookies from Firefox (`cookies.sqlite`) into Chromium/Chrome SQLite `Cookies` table (mapping 1601-epoch timestamps).
+- **Profile Snapshotting & Restore**: Clean backups omitting ephemeral caches, temporary locks, and GPU cache files.
+- **Credential & Password Extraction**: Extracts credentials from isolated Firefox profiles (`logins.json` and external decrypt tools) with host and provider matching.
+- **Zero Mandatory External Dependencies**: Built with Python 3.10+ standard library (`sqlite3`, `pathlib`, `shutil`, `urllib.parse`).
+
+## Installation
+
+```bash
+pip install -e /path/to/twinerd-browser-vault
+```
+
+## CLI Usage
+
+```bash
+# Detect browser profiles on current system
+twinerd-browser-vault detect
+
+# Inspect a profile directory
+twinerd-browser-vault inspect firefox ~/.mozilla/firefox/default
+
+# Snapshot profile omitting cache
+twinerd-browser-vault snapshot chrome --account dev --dest ~/snapshots/
+
+# Migrate session cookies from Firefox to Chromium for an account
+twinerd-browser-vault sync-cookies --home /home/worker1 --provider anthropic
+```
+
+## Python API
+
+```python
+from twinerd_browser_vault import (
+    detect_available_profiles,
+    sync_firefox_cookies_to_chromium,
+    create_profile_snapshot,
+)
+
+# Sync cookies
+result = sync_firefox_cookies_to_chromium(
+    home=Path("/home/worker1"),
+    provider="chatgpt",
+    only_missing=True,
+)
+```

twinerd_browser_vault-0.1.0/README.md

@@ -0,0 +1,50 @@
+# twinerd-browser-vault
+
+Browser profile snapshots, session cookie migration, and credential vault management for Chrome, Chromium, and Firefox.
+
+## Features
+
+- **Profile Discovery & Inspection**: Locates and analyzes profile state and size for Firefox, Chromium, Google Chrome, Brave, Edge, Opera, and Vivaldi.
+- **Session Continuity (Cookie Sync)**: Migrates authenticated session cookies from Firefox (`cookies.sqlite`) into Chromium/Chrome SQLite `Cookies` table (mapping 1601-epoch timestamps).
+- **Profile Snapshotting & Restore**: Clean backups omitting ephemeral caches, temporary locks, and GPU cache files.
+- **Credential & Password Extraction**: Extracts credentials from isolated Firefox profiles (`logins.json` and external decrypt tools) with host and provider matching.
+- **Zero Mandatory External Dependencies**: Built with Python 3.10+ standard library (`sqlite3`, `pathlib`, `shutil`, `urllib.parse`).
+
+## Installation
+
+```bash
+pip install -e /path/to/twinerd-browser-vault
+```
+
+## CLI Usage
+
+```bash
+# Detect browser profiles on current system
+twinerd-browser-vault detect
+
+# Inspect a profile directory
+twinerd-browser-vault inspect firefox ~/.mozilla/firefox/default
+
+# Snapshot profile omitting cache
+twinerd-browser-vault snapshot chrome --account dev --dest ~/snapshots/
+
+# Migrate session cookies from Firefox to Chromium for an account
+twinerd-browser-vault sync-cookies --home /home/worker1 --provider anthropic
+```
+
+## Python API
+
+```python
+from twinerd_browser_vault import (
+    detect_available_profiles,
+    sync_firefox_cookies_to_chromium,
+    create_profile_snapshot,
+)
+
+# Sync cookies
+result = sync_firefox_cookies_to_chromium(
+    home=Path("/home/worker1"),
+    provider="chatgpt",
+    only_missing=True,
+)
+```

twinerd_browser_vault-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "twinerd-browser-vault"
+version = "0.1.0"
+description = "Browser profile snapshots, session cookie migration, and credential vault for Chrome, Chromium, and Firefox"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Proprietary" }
+authors = [
+    { name = "Tomasz Sapletta", email = "info@softreck.com" }
+]
+dependencies = []
+
+[project.scripts]
+twinerd-browser-vault = "twinerd_browser_vault.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

twinerd_browser_vault-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault/__init__.py

@@ -0,0 +1,59 @@
+"""twinerd_browser_vault — Browser profile snapshots, session cookie migration, and credential vault."""
+
+from __future__ import annotations
+
+from twinerd_browser_vault.models import (
+    PasswordRecord,
+    CookieRecord,
+    ProfileMetadata,
+)
+from twinerd_browser_vault.profiles import (
+    detect_available_profiles,
+    get_profile_size,
+    format_size,
+    inspect_profile,
+    create_profile_snapshot,
+    restore_profile_snapshot,
+)
+from twinerd_browser_vault.cookies import (
+    sync_firefox_cookies_to_chromium,
+    read_firefox_cookies,
+    write_chromium_cookies,
+    find_firefox_cookies_db,
+    find_chromium_cookies_db,
+    DEFAULT_SYNC_HOST_MARKERS,
+    PROVIDER_COOKIE_HOST_MARKERS,
+)
+from twinerd_browser_vault.passwords import (
+    extract_login_hosts,
+    load_isolated_firefox_profiles,
+    read_firefox_logins_json,
+    decrypt_firefox_logins,
+    FALLBACK_HOSTS,
+)
+
+__all__ = [
+    "PasswordRecord",
+    "CookieRecord",
+    "ProfileMetadata",
+    "detect_available_profiles",
+    "get_profile_size",
+    "format_size",
+    "inspect_profile",
+    "create_profile_snapshot",
+    "restore_profile_snapshot",
+    "sync_firefox_cookies_to_chromium",
+    "read_firefox_cookies",
+    "write_chromium_cookies",
+    "find_firefox_cookies_db",
+    "find_chromium_cookies_db",
+    "DEFAULT_SYNC_HOST_MARKERS",
+    "PROVIDER_COOKIE_HOST_MARKERS",
+    "extract_login_hosts",
+    "load_isolated_firefox_profiles",
+    "read_firefox_logins_json",
+    "decrypt_firefox_logins",
+    "FALLBACK_HOSTS",
+]
+
+__version__ = "0.1.0"

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault/cli.py

@@ -0,0 +1,131 @@
+"""twinerd_browser_vault.cli — Command-line interface for twinerd-browser-vault."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Sequence
+
+from twinerd_browser_vault.profiles import (
+    detect_available_profiles,
+    inspect_profile,
+    create_profile_snapshot,
+    restore_profile_snapshot,
+)
+from twinerd_browser_vault.cookies import (
+    sync_firefox_cookies_to_chromium,
+    read_firefox_cookies,
+    find_firefox_cookies_db,
+    DEFAULT_SYNC_HOST_MARKERS,
+)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="twinerd-browser-vault",
+        description="Browser profile snapshotting, session cookie migration, and credential vault for Twinerd",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # detect
+    p_detect = sub.add_parser("detect", help="Detect installed browser profiles on system or account home")
+    p_detect.add_argument("--home", type=Path, default=None, help="Custom home directory")
+
+    # inspect
+    p_inspect = sub.add_parser("inspect", help="Inspect size and database state of a profile directory")
+    p_inspect.add_argument("browser", help="Browser type (firefox, chromium, chrome, etc.)")
+    p_inspect.add_argument("path", type=Path, help="Profile directory path")
+
+    # snapshot
+    p_snap = sub.add_parser("snapshot", help="Create a clean snapshot of a browser profile")
+    p_snap.add_argument("browser", help="Browser type (firefox, chromium, chrome)")
+    p_snap.add_argument("--account", default="default", help="Account ID / tag")
+    p_snap.add_argument("--dest", type=Path, required=True, help="Destination directory for snapshots")
+    p_snap.add_argument("--home", type=Path, default=None, help="Custom home directory")
+
+    # restore
+    p_restore = sub.add_parser("restore", help="Restore a profile snapshot to a target directory")
+    p_restore.add_argument("snapshot", type=Path, help="Snapshot directory path")
+    p_restore.add_argument("target", type=Path, help="Target profile directory")
+    p_restore.add_argument("--no-backup", action="store_true", help="Do not backup existing target directory")
+
+    # sync-cookies
+    p_sync = sub.add_parser("sync-cookies", help="Migrate session cookies from Firefox to Chromium/Chrome")
+    p_sync.add_argument("--home", type=Path, required=True, help="Account home directory containing .mozilla and .config")
+    p_sync.add_argument("--provider", default=None, help="Specific LLM provider (chatgpt, anthropic, google, etc.)")
+    p_sync.add_argument("--all-hosts", action="store_true", help="Sync all matching common LLM hosts")
+    p_sync.add_argument("--force-overwrite", action="store_true", help="Overwrite existing cookies instead of only missing")
+
+    # list-cookies
+    p_list_c = sub.add_parser("list-cookies", help="List available session cookies from Firefox profile")
+    p_list_c.add_argument("--home", type=Path, required=True, help="Account home directory")
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "detect":
+        profiles = detect_available_profiles(home=args.home)
+        print(f"Detected {len(profiles)} browser profile(s):")
+        for b, p in profiles.items():
+            meta = inspect_profile(b, p)
+            print(f"  • {b.ljust(10)}: {p} ({meta.size_human})")
+        return 0
+
+    if args.command == "inspect":
+        meta = inspect_profile(args.browser, args.path)
+        print(f"Browser: {meta.browser}")
+        print(f"Path: {meta.path}")
+        print(f"Size: {meta.size_human} ({meta.size_bytes} bytes)")
+        print(f"Cookies DB: {meta.cookie_db or 'None'}")
+        print(f"Logins DB:  {meta.login_db or 'None'}")
+        return 0
+
+    if args.command == "snapshot":
+        res = create_profile_snapshot(args.browser, args.account, args.dest, home=args.home)
+        if res:
+            print(f"Snapshot created successfully: {res}")
+            return 0
+        else:
+            print("Failed to create profile snapshot.", file=sys.stderr)
+            return 1
+
+    if args.command == "restore":
+        ok = restore_profile_snapshot(args.snapshot, args.target, backup_existing=not args.no_backup)
+        if ok:
+            print(f"Snapshot restored successfully to: {args.target}")
+            return 0
+        else:
+            print("Failed to restore profile snapshot.", file=sys.stderr)
+            return 1
+
+    if args.command == "sync-cookies":
+        res = sync_firefox_cookies_to_chromium(
+            home=args.home,
+            provider=args.provider,
+            only_missing=not args.force_overwrite,
+        )
+        print(json.dumps(res, indent=2))
+        return 0 if res.get("status") == "ok" else 1
+
+    if args.command == "list-cookies":
+        ff_db = find_firefox_cookies_db(args.home)
+        if not ff_db:
+            print(f"No Firefox cookies.sqlite found in {args.home}", file=sys.stderr)
+            return 1
+        cookies = read_firefox_cookies(ff_db, host_filter=DEFAULT_SYNC_HOST_MARKERS)
+        print(f"Found {len(cookies)} matching session cookies:")
+        for c in cookies:
+            print(f"  [{c.host}] {c.name} (secure={c.is_secure}, httponly={c.is_httponly})")
+        return 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault/cookies.py

@@ -0,0 +1,274 @@
+"""twinerd_browser_vault.cookies — Session cookie migration and sync across Firefox and Chromium/Chrome."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sqlite3
+import tempfile
+from pathlib import Path
+from typing import Any, Sequence, Optional
+
+from twinerd_browser_vault.models import CookieRecord
+
+# Chromium expires_utc: microseconds since 1601-01-01 UTC.
+CHROME_EPOCH_OFFSET_S = 11644473600
+
+DEFAULT_SYNC_HOST_MARKERS = (
+    "openai.com",
+    "chatgpt.com",
+    "anthropic.com",
+    "claude.ai",
+    "google.com",
+    "google.pl",
+    "accounts.google.com",
+    "x.ai",
+    "deepseek.com",
+    "github.com",
+    "openrouter.ai",
+    "mistral.ai",
+)
+
+PROVIDER_COOKIE_HOST_MARKERS: dict[str, tuple[str, ...]] = {
+    "chatgpt": ("chatgpt.com", "openai.com", "auth0.openai.com"),
+    "anthropic": ("anthropic.com", "claude.ai"),
+    "google": ("google.com", "google.pl", "accounts.google.com", "gemini.google.com"),
+    "xai": ("x.ai", "console.x.ai"),
+    "deepseek": ("deepseek.com", "platform.deepseek.com"),
+    "github-copilot": ("github.com", "api.github.com"),
+    "openrouter": ("openrouter.ai", "openrouter.com"),
+    "mistral": ("mistral.ai", "console.mistral.ai"),
+}
+
+
+def chrome_expires(unix_expiry: int) -> int:
+    """Converts a Unix epoch second timestamp into Chrome 1601 epoch microsecond timestamp."""
+    if unix_expiry <= 0:
+        return 0
+    return int((unix_expiry + CHROME_EPOCH_OFFSET_S) * 1_000_000)
+
+
+def host_matches(host: str, markers: Sequence[str]) -> bool:
+    """Checks if a host matches any of the given host markers."""
+    lowered = host.lstrip(".").lower()
+    return any(marker.lower() in lowered or lowered.endswith(marker.lower()) for marker in markers)
+
+
+def markers_for_provider(provider: str | None) -> tuple[str, ...]:
+    if not provider:
+        return DEFAULT_SYNC_HOST_MARKERS
+    return PROVIDER_COOKIE_HOST_MARKERS.get(provider.lower(), DEFAULT_SYNC_HOST_MARKERS)
+
+
+def find_firefox_cookies_db(home: Path) -> Path | None:
+    firefox = home / ".mozilla" / "firefox"
+    if not firefox.is_dir():
+        return None
+    best: tuple[int, Path] | None = None
+    for cookies in firefox.glob("*/cookies.sqlite"):
+        try:
+            size = cookies.stat().st_size
+        except OSError:
+            continue
+        if best is None or size > best[0]:
+            best = (size, cookies)
+    return best[1] if best else None
+
+
+def find_chromium_cookies_db(home: Path) -> Path:
+    chromium = home / ".config" / "chromium" / "Default" / "Cookies"
+    chrome = home / ".config" / "google-chrome" / "Default" / "Cookies"
+    if chromium.is_file() or (home / ".config" / "chromium" / "Default").is_dir():
+        return chromium
+    if chrome.is_file() or (home / ".config" / "google-chrome" / "Default").is_dir():
+        return chrome
+    return chromium
+
+
+def ensure_chromium_cookies_db(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.is_file():
+        return
+    con = sqlite3.connect(str(path))
+    con.execute(
+        """
+        CREATE TABLE IF NOT EXISTS cookies (
+            creation_utc INTEGER NOT NULL,
+            host_key TEXT NOT NULL,
+            top_frame_site_key TEXT NOT NULL DEFAULT '',
+            name TEXT NOT NULL,
+            value TEXT NOT NULL,
+            encrypted_value BLOB NOT NULL DEFAULT X'',
+            path TEXT NOT NULL,
+            expires_utc INTEGER NOT NULL,
+            is_secure INTEGER NOT NULL,
+            is_httponly INTEGER NOT NULL,
+            last_access_utc INTEGER NOT NULL,
+            has_expires INTEGER NOT NULL DEFAULT 1,
+            is_persistent INTEGER NOT NULL DEFAULT 1,
+            priority INTEGER NOT NULL DEFAULT 1,
+            samesite INTEGER NOT NULL DEFAULT -1,
+            source_scheme INTEGER NOT NULL DEFAULT 0,
+            source_port INTEGER NOT NULL DEFAULT -1,
+            last_update_utc INTEGER NOT NULL DEFAULT 0,
+            source_type INTEGER NOT NULL DEFAULT 0,
+            has_cross_site_ancestor INTEGER NOT NULL DEFAULT 0
+        )
+        """
+    )
+    con.execute(
+        "CREATE UNIQUE INDEX IF NOT EXISTS cookies_unique_index "
+        "ON cookies(host_key, top_frame_site_key, name, path, source_scheme, source_port)"
+    )
+    con.commit()
+    con.close()
+
+
+def read_firefox_cookies(
+    db_path: Path,
+    host_filter: Optional[Sequence[str]] = None,
+) -> list[CookieRecord]:
+    """Reads cookies from Firefox cookies.sqlite, using a temporary snapshot to avoid SQLite locking."""
+    if not db_path.is_file():
+        return []
+
+    cookies: list[CookieRecord] = []
+    with tempfile.TemporaryDirectory() as td:
+        snap = Path(td) / "cookies.sqlite"
+        shutil.copy2(db_path, snap)
+        con = sqlite3.connect(str(snap))
+        try:
+            cur = con.cursor()
+            cur.execute(
+                """
+                SELECT name, value, host, path, expiry, isSecure, isHttpOnly, sameSite
+                FROM moz_cookies
+                """
+            )
+            for row in cur.fetchall():
+                name, val, host, path, exp, sec, http_only, ss = row
+                if host_filter and not host_matches(host, host_filter):
+                    continue
+                cookies.append(
+                    CookieRecord(
+                        name=name,
+                        value=val,
+                        host=host,
+                        path=path,
+                        expiry=exp or 0,
+                        is_secure=bool(sec),
+                        is_httponly=bool(http_only),
+                        samesite=int(ss) if ss is not None else -1,
+                    )
+                )
+        finally:
+            con.close()
+    return cookies
+
+
+def write_chromium_cookies(
+    db_path: Path,
+    cookies: list[CookieRecord],
+    only_missing: bool = True,
+) -> tuple[int, int]:
+    """Writes cookies into Chromium SQLite Cookies table.
+
+    Returns:
+        (inserted_count, skipped_count)
+    """
+    ensure_chromium_cookies_db(db_path)
+    con = sqlite3.connect(str(db_path))
+    inserted = 0
+    skipped = 0
+    try:
+        cur = con.cursor()
+        for c in cookies:
+            if only_missing:
+                cur.execute(
+                    "SELECT 1 FROM cookies WHERE host_key = ? AND name = ? AND path = ? LIMIT 1",
+                    (c.host, c.name, c.path),
+                )
+                if cur.fetchone():
+                    skipped += 1
+                    continue
+
+            now_chrome = chrome_expires(int(db_path.stat().st_mtime if db_path.exists() else 0))
+            exp_chrome = chrome_expires(c.expiry)
+
+            cur.execute(
+                """
+                INSERT OR REPLACE INTO cookies (
+                    creation_utc, host_key, top_frame_site_key, name, value, encrypted_value,
+                    path, expires_utc, is_secure, is_httponly, last_access_utc,
+                    has_expires, is_persistent, priority, samesite, source_scheme, source_port,
+                    last_update_utc, source_type, has_cross_site_ancestor
+                ) VALUES (
+                    ?, ?, '', ?, ?, X'',
+                    ?, ?, ?, ?, ?,
+                    1, 1, 1, ?, 2, 443,
+                    ?, 0, 0
+                )
+                """,
+                (
+                    now_chrome,
+                    c.host,
+                    c.name,
+                    c.value,
+                    c.path,
+                    exp_chrome,
+                    1 if c.is_secure else 0,
+                    1 if c.is_httponly else 0,
+                    now_chrome,
+                    c.samesite,
+                    now_chrome,
+                ),
+            )
+            inserted += 1
+        con.commit()
+    finally:
+        con.close()
+
+    return inserted, skipped
+
+
+def sync_firefox_cookies_to_chromium(
+    home: Path,
+    provider: Optional[str] = None,
+    host_markers: Optional[Sequence[str]] = None,
+    only_missing: bool = True,
+) -> dict[str, Any]:
+    """Synchronizes Firefox session cookies into Chromium/Chrome."""
+    ff_db = find_firefox_cookies_db(home)
+    if not ff_db:
+        return {
+            "status": "skipped",
+            "reason": "no_firefox_profile",
+            "inserted": 0,
+            "skipped_existing": 0,
+            "hosts": [],
+        }
+
+    chrom_db = find_chromium_cookies_db(home)
+    markers = host_markers or markers_for_provider(provider)
+
+    cookies = read_firefox_cookies(ff_db, host_filter=markers)
+    matched_hosts = sorted(list({c.host.lstrip(".") for c in cookies}))
+
+    if not cookies:
+        return {
+            "status": "ok",
+            "inserted": 0,
+            "skipped_existing": 0,
+            "hosts": [],
+            "reason": "no_matching_cookies",
+        }
+
+    inserted, skipped = write_chromium_cookies(chrom_db, cookies, only_missing=only_missing)
+
+    return {
+        "status": "ok",
+        "inserted": inserted,
+        "skipped_existing": skipped,
+        "hosts": matched_hosts,
+        "provider": provider,
+    }

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault/models.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class PasswordRecord:
+    """Represents a credential record extracted from a browser password manager."""
+    provider: str
+    host: str
+    username: str
+    password: str
+    profile: Path
+
+    def to_dict(self) -> dict[str, Any]:
+        d = asdict(self)
+        d["profile"] = str(self.profile)
+        return d
+
+
+@dataclass(frozen=True)
+class CookieRecord:
+    """Represents a browser session cookie."""
+    name: str
+    value: str
+    host: str
+    path: str
+    expiry: int
+    is_secure: bool
+    is_httponly: bool
+    samesite: int = -1
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class ProfileMetadata:
+    """Metadata regarding a browser profile on disk."""
+    browser: str
+    path: Path
+    size_bytes: int
+    size_human: str
+    cookie_db: Path | None = None
+    login_db: Path | None = None

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault/passwords.py

@@ -0,0 +1,166 @@
+"""twinerd_browser_vault.passwords — Credential extraction and parsing from browser password stores."""
+
+from __future__ import annotations
+
+import configparser
+import json
+import logging
+import os
+import re
+import shlex
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Sequence, Optional
+from urllib.parse import urlparse
+
+from twinerd_browser_vault.models import PasswordRecord
+
+log = logging.getLogger(__name__)
+
+DECRYPT_TIMEOUT_SECONDS = 20
+
+FALLBACK_HOSTS: dict[str, tuple[str, ...]] = {
+    "chatgpt": ("chatgpt.com", "openai.com", "platform.openai.com"),
+    "anthropic": ("anthropic.com", "claude.ai", "console.anthropic.com"),
+    "google": ("accounts.google.com", "gemini.google.com"),
+    "github-copilot": ("github.com", "github.com/login"),
+    "azure-openai": ("portal.azure.com", "azure.com"),
+    "openrouter": ("openrouter.ai", "openrouter.com"),
+    "xai": ("x.ai", "console.x.ai"),
+    "deepseek": ("deepseek.com", "platform.deepseek.com"),
+    "mistral": ("mistral.ai", "console.mistral.ai"),
+    "groq": ("groq.com", "console.groq.com"),
+    "cohere": ("cohere.com", "dashboard.cohere.com"),
+}
+
+
+def url_host(value: str) -> str:
+    """Extracts hostname from an URL or hostname string."""
+    candidate = value.strip()
+    if not candidate:
+        return ""
+    if "://" not in candidate:
+        candidate = f"https://{candidate}"
+    try:
+        return (urlparse(candidate).hostname or "").lower()
+    except ValueError:
+        return ""
+
+
+def extract_login_hosts(login: dict[str, Any]) -> list[str]:
+    """Extracts all potential hostnames from a login record dictionary."""
+    hosts: list[str] = []
+    for key in ("hostname", "formSubmitURL", "formSubmitUrl", "httpRealm", "origin", "url", "URL"):
+        host = url_host(str(login.get(key, "") or ""))
+        if host and host not in hosts:
+            hosts.append(host)
+    return hosts
+
+
+def is_inside(root: Path, candidate: Path) -> bool:
+    try:
+        candidate.relative_to(root)
+    except ValueError:
+        return False
+    return True
+
+
+def load_isolated_firefox_profiles(home: Path) -> list[Path]:
+    """Return only profiles contained within the account's Firefox directory."""
+    firefox_root = (home / ".mozilla" / "firefox").resolve()
+    if not firefox_root.is_dir():
+        return []
+
+    def accepted(candidate: Path) -> Path | None:
+        resolved = candidate.expanduser().resolve()
+        return resolved if resolved.is_dir() and is_inside(firefox_root, resolved) else None
+
+    profiles_ini = firefox_root / "profiles.ini"
+    if not profiles_ini.is_file():
+        return sorted(
+            profile
+            for item in firefox_root.iterdir()
+            if item.is_dir() and not item.name.endswith(".ini")
+            if (profile := accepted(item)) is not None
+        )
+
+    parser = configparser.ConfigParser(interpolation=None)
+    parser.optionxform = str
+    parser.read(profiles_ini, encoding="utf-8")
+    profiles: list[Path] = []
+    for section in parser.sections():
+        if not section.startswith("Profile") or not parser.has_option(section, "Path"):
+            continue
+        configured = parser.get(section, "Path", fallback="").strip()
+        if not configured:
+            continue
+        relative = parser.getboolean(section, "IsRelative", fallback=True)
+        candidate = firefox_root / configured if relative else Path(configured)
+        profile = accepted(candidate)
+        if profile is not None and profile not in profiles:
+            profiles.append(profile)
+    return profiles
+
+
+def read_firefox_logins_json(profile_path: Path) -> list[dict[str, Any]]:
+    """Reads raw encrypted login records from logins.json if present."""
+    logins_file = profile_path / "logins.json"
+    if not logins_file.is_file():
+        return []
+    try:
+        data = json.loads(logins_file.read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            return data.get("logins", [])
+    except Exception as e:
+        log.warning(f"Error reading logins.json in {profile_path}: {e}")
+    return []
+
+
+def decrypt_firefox_logins(
+    profile_path: Path,
+    decrypt_tool: Optional[str] = None,
+    provider: Optional[str] = None,
+) -> list[PasswordRecord]:
+    """Decrypts Firefox logins using an available external tool (like firefox-decrypt / firefox_decrypt)."""
+    tool = decrypt_tool or shutil.which("firefox-decrypt") or shutil.which("firefox_decrypt")
+    if not tool or not Path(tool).is_file():
+        return []
+
+    cmd = [tool, "-f", "json", str(profile_path)]
+    try:
+        res = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=DECRYPT_TIMEOUT_SECONDS,
+        )
+        if res.returncode != 0:
+            return []
+
+        data = json.loads(res.stdout)
+        records_raw = data.get("logins", data) if isinstance(data, dict) else data
+        if not isinstance(records_raw, list):
+            return []
+
+        records: list[PasswordRecord] = []
+        for item in records_raw:
+            if not isinstance(item, dict):
+                continue
+            h = url_host(str(item.get("hostname", item.get("host", item.get("url", ""))) or ""))
+            u = str(item.get("username", item.get("user", item.get("login", ""))) or "").strip()
+            p = str(item.get("password", item.get("passwd", item.get("pass", ""))) or "").strip()
+            if h and u and p:
+                records.append(
+                    PasswordRecord(
+                        provider=provider or "custom",
+                        host=h,
+                        username=u,
+                        password=p,
+                        profile=profile_path,
+                    )
+                )
+        return records
+    except Exception as e:
+        log.warning(f"Failed decrypting profile {profile_path}: {e}")
+        return []

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault/profiles.py

@@ -0,0 +1,204 @@
+"""twinerd_browser_vault.profiles — Browser profile discovery, size calculation, and snapshots."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from twinerd_browser_vault.models import ProfileMetadata
+
+log = logging.getLogger(__name__)
+
+# Standard browser profile locations on Linux
+BROWSER_PROFILE_PATHS = {
+    "firefox": {
+        "config": Path(".mozilla") / "firefox",
+        "cache": Path(".cache") / "mozilla" / "firefox",
+    },
+    "chromium": {
+        "config": Path(".config") / "chromium",
+        "cache": Path(".cache") / "chromium",
+    },
+    "chrome": {
+        "config": Path(".config") / "google-chrome",
+        "cache": Path(".cache") / "google-chrome",
+    },
+    "brave": {
+        "config": Path(".config") / "BraveSoftware" / "Brave-Browser",
+        "cache": Path(".cache") / "BraveSoftware" / "Brave-Browser",
+    },
+    "edge": {
+        "config": Path(".config") / "microsoft-edge",
+        "cache": Path(".cache") / "microsoft-edge",
+    },
+    "opera": {
+        "config": Path(".config") / "opera",
+        "cache": Path(".cache") / "opera",
+    },
+    "vivaldi": {
+        "config": Path(".config") / "vivaldi",
+        "cache": Path(".cache") / "vivaldi",
+    },
+}
+
+CONTAINER_PROFILE_PATHS = {
+    "firefox": "/home/browser/.mozilla/firefox",
+    "chromium": "/home/browser/.config/chromium",
+    "chrome": "/home/browser/.config/google-chrome",
+}
+
+
+def detect_available_profiles(home: Optional[Path] = None) -> dict[str, Path]:
+    """Detect available browser profiles on the given or host home system.
+
+    Returns:
+        Dictionary mapping browser name to profile config path.
+    """
+    base_home = home or Path.home()
+    available = {}
+    for browser_name, paths in BROWSER_PROFILE_PATHS.items():
+        cfg_path = base_home / paths["config"]
+        if cfg_path.exists():
+            available[browser_name] = cfg_path
+    return available
+
+
+def get_profile_size(profile_path: Path) -> int:
+    """Get total size of a browser profile in bytes."""
+    if not profile_path.exists():
+        return 0
+
+    total = 0
+    for item in profile_path.rglob("*"):
+        try:
+            if item.is_file(follow_symlinks=False):
+                total += item.stat().st_size
+        except (OSError, PermissionError):
+            pass
+    return total
+
+
+def format_size(size_bytes: int) -> str:
+    """Format bytes to human-readable size."""
+    size_flt = float(size_bytes)
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size_flt < 1024:
+            return f"{size_flt:.1f} {unit}"
+        size_flt /= 1024.0
+    return f"{size_flt:.1f} TB"
+
+
+def inspect_profile(browser: str, profile_path: Path) -> ProfileMetadata:
+    """Inspects a browser profile directory, calculating size and locating key databases."""
+    size_b = get_profile_size(profile_path)
+    cookie_db = None
+    login_db = None
+
+    if browser == "firefox":
+        for cand in profile_path.glob("*/cookies.sqlite"):
+            cookie_db = cand
+            break
+        for cand in profile_path.glob("*/logins.json"):
+            login_db = cand
+            break
+    else:
+        for cand in [
+            profile_path / "Default" / "Cookies",
+            profile_path / "Cookies",
+        ]:
+            if cand.is_file():
+                cookie_db = cand
+                break
+        for cand in [
+            profile_path / "Default" / "Login Data",
+            profile_path / "Login Data",
+        ]:
+            if cand.is_file():
+                login_db = cand
+                break
+
+    return ProfileMetadata(
+        browser=browser,
+        path=profile_path,
+        size_bytes=size_b,
+        size_human=format_size(size_b),
+        cookie_db=cookie_db,
+        login_db=login_db,
+    )
+
+
+def create_profile_snapshot(
+    browser: str,
+    account_id: str,
+    snapshot_dir: Path,
+    home: Optional[Path] = None,
+) -> Optional[Path]:
+    """Create a snapshot of a browser profile for an account."""
+    base_home = home or Path.home()
+    if browser not in BROWSER_PROFILE_PATHS:
+        log.warning(f"Unknown browser: {browser}")
+        return None
+
+    source_path = base_home / BROWSER_PROFILE_PATHS[browser]["config"]
+    if not source_path.exists():
+        log.warning(f"Browser profile not found: {browser} ({source_path})")
+        return None
+
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    dest_path = snapshot_dir / f"{account_id}-{browser}-{timestamp}"
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        shutil.copytree(
+            source_path,
+            dest_path,
+            symlinks=False,
+            ignore=shutil.ignore_patterns(
+                "Cache",
+                "cache",
+                "GPUCache",
+                "Code Cache",
+                "*.tmp",
+                "*lock*",
+                ".parentlock",
+            ),
+        )
+        log.info(f"Snapshot created: {dest_path}")
+        return dest_path
+    except Exception as e:
+        log.error(f"Failed to create snapshot: {e}")
+        if dest_path.exists():
+            shutil.rmtree(dest_path, ignore_errors=True)
+        return None
+
+
+def restore_profile_snapshot(
+    snapshot_path: Path,
+    target_dir: Path,
+    backup_existing: bool = True,
+) -> bool:
+    """Restore a profile snapshot to a target directory."""
+    if not snapshot_path.exists() or not snapshot_path.is_dir():
+        log.error(f"Snapshot path does not exist: {snapshot_path}")
+        return False
+
+    if target_dir.exists() and backup_existing:
+        backup_path = target_dir.with_name(f"{target_dir.name}-backup-{int(datetime.now().timestamp())}")
+        try:
+            shutil.move(str(target_dir), str(backup_path))
+            log.info(f"Existing profile backed up to: {backup_path}")
+        except Exception as e:
+            log.error(f"Failed to backup existing profile: {e}")
+            return False
+
+    try:
+        shutil.copytree(snapshot_path, target_dir)
+        log.info(f"Snapshot restored to: {target_dir}")
+        return True
+    except Exception as e:
+        log.error(f"Failed to restore snapshot: {e}")
+        return False

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: twinerd-browser-vault
+Version: 0.1.0
+Summary: Browser profile snapshots, session cookie migration, and credential vault for Chrome, Chromium, and Firefox
+Author-email: Tomasz Sapletta <info@softreck.com>
+License: Proprietary
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# twinerd-browser-vault
+
+Browser profile snapshots, session cookie migration, and credential vault management for Chrome, Chromium, and Firefox.
+
+## Features
+
+- **Profile Discovery & Inspection**: Locates and analyzes profile state and size for Firefox, Chromium, Google Chrome, Brave, Edge, Opera, and Vivaldi.
+- **Session Continuity (Cookie Sync)**: Migrates authenticated session cookies from Firefox (`cookies.sqlite`) into Chromium/Chrome SQLite `Cookies` table (mapping 1601-epoch timestamps).
+- **Profile Snapshotting & Restore**: Clean backups omitting ephemeral caches, temporary locks, and GPU cache files.
+- **Credential & Password Extraction**: Extracts credentials from isolated Firefox profiles (`logins.json` and external decrypt tools) with host and provider matching.
+- **Zero Mandatory External Dependencies**: Built with Python 3.10+ standard library (`sqlite3`, `pathlib`, `shutil`, `urllib.parse`).
+
+## Installation
+
+```bash
+pip install -e /path/to/twinerd-browser-vault
+```
+
+## CLI Usage
+
+```bash
+# Detect browser profiles on current system
+twinerd-browser-vault detect
+
+# Inspect a profile directory
+twinerd-browser-vault inspect firefox ~/.mozilla/firefox/default
+
+# Snapshot profile omitting cache
+twinerd-browser-vault snapshot chrome --account dev --dest ~/snapshots/
+
+# Migrate session cookies from Firefox to Chromium for an account
+twinerd-browser-vault sync-cookies --home /home/worker1 --provider anthropic
+```
+
+## Python API
+
+```python
+from twinerd_browser_vault import (
+    detect_available_profiles,
+    sync_firefox_cookies_to_chromium,
+    create_profile_snapshot,
+)
+
+# Sync cookies
+result = sync_firefox_cookies_to_chromium(
+    home=Path("/home/worker1"),
+    provider="chatgpt",
+    only_missing=True,
+)
+```

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+src/twinerd_browser_vault/__init__.py
+src/twinerd_browser_vault/cli.py
+src/twinerd_browser_vault/cookies.py
+src/twinerd_browser_vault/models.py
+src/twinerd_browser_vault/passwords.py
+src/twinerd_browser_vault/profiles.py
+src/twinerd_browser_vault.egg-info/PKG-INFO
+src/twinerd_browser_vault.egg-info/SOURCES.txt
+src/twinerd_browser_vault.egg-info/dependency_links.txt
+src/twinerd_browser_vault.egg-info/entry_points.txt
+src/twinerd_browser_vault.egg-info/top_level.txt
+tests/test_cookies.py
+tests/test_passwords.py
+tests/test_profiles.py

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+twinerd-browser-vault = twinerd_browser_vault.cli:main

twinerd_browser_vault-0.1.0/src/twinerd_browser_vault.egg-info/top_level.txt

@@ -0,0 +1 @@
+twinerd_browser_vault

twinerd_browser_vault-0.1.0/tests/test_cookies.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from twinerd_browser_vault.cookies import (
+    sync_firefox_cookies_to_chromium,
+    read_firefox_cookies,
+    write_chromium_cookies,
+    chrome_expires,
+    host_matches,
+)
+from twinerd_browser_vault.models import CookieRecord
+
+
+def _create_mock_ff_cookies(home: Path) -> Path:
+    profile = home / ".mozilla" / "firefox" / "abcd.default"
+    profile.mkdir(parents=True)
+    db = profile / "cookies.sqlite"
+    con = sqlite3.connect(str(db))
+    con.execute(
+        """
+        CREATE TABLE moz_cookies (
+            id INTEGER PRIMARY KEY,
+            name TEXT,
+            value TEXT,
+            host TEXT,
+            path TEXT,
+            expiry INTEGER,
+            isSecure INTEGER,
+            isHttpOnly INTEGER,
+            sameSite INTEGER
+        )
+        """
+    )
+    con.execute(
+        "INSERT INTO moz_cookies (name, value, host, path, expiry, isSecure, isHttpOnly, sameSite) "
+        "VALUES (?, ?, ?, ?, ?, 1, 1, 0)",
+        ("sessionKey", "secret-claude-session", ".claude.ai", "/", 2000000000),
+    )
+    con.execute(
+        "INSERT INTO moz_cookies (name, value, host, path, expiry, isSecure, isHttpOnly, sameSite) "
+        "VALUES (?, ?, ?, ?, ?, 1, 1, 0)",
+        ("other", "ignore-me", ".example.com", "/", 2000000000),
+    )
+    con.commit()
+    con.close()
+    return db
+
+
+def test_host_matches():
+    assert host_matches(".claude.ai", ["claude.ai"])
+    assert host_matches("subdomain.openai.com", ["openai.com"])
+    assert not host_matches("evil-phishing.com", ["openai.com"])
+
+
+def test_chrome_expires():
+    assert chrome_expires(0) == 0
+    # Unix timestamp > 0 should convert to 1601 epoch
+    exp = chrome_expires(1700000000)
+    assert exp > 1700000000 * 1_000_000
+
+
+def test_read_and_write_cookies(tmp_path: Path):
+    home = tmp_path / "acct"
+    home.mkdir()
+    ff_db = _create_mock_ff_cookies(home)
+
+    cookies = read_firefox_cookies(ff_db, host_filter=["claude.ai"])
+    assert len(cookies) == 1
+    assert cookies[0].name == "sessionKey"
+    assert cookies[0].value == "secret-claude-session"
+
+    chrom_db = home / ".config" / "chromium" / "Default" / "Cookies"
+    inserted, skipped = write_chromium_cookies(chrom_db, cookies, only_missing=True)
+    assert inserted == 1
+    assert skipped == 0
+
+    # Second write with only_missing=True should skip
+    inserted2, skipped2 = write_chromium_cookies(chrom_db, cookies, only_missing=True)
+    assert inserted2 == 0
+    assert skipped2 == 1
+
+
+def test_sync_firefox_cookies_to_chromium_flow(tmp_path: Path):
+    home = tmp_path / "acct"
+    home.mkdir()
+    _create_mock_ff_cookies(home)
+
+    res = sync_firefox_cookies_to_chromium(home, provider="anthropic", only_missing=True)
+    assert res["status"] == "ok"
+    assert res["inserted"] == 1
+    assert res["skipped_existing"] == 0
+    assert "claude.ai" in res["hosts"]
+    assert "example.com" not in res["hosts"]
+
+    # Verify directly in SQLite
+    chrome_db = home / ".config" / "chromium" / "Default" / "Cookies"
+    assert chrome_db.is_file()
+    con = sqlite3.connect(str(chrome_db))
+    row = con.execute("SELECT name, value, host_key FROM cookies WHERE host_key LIKE '%claude%'").fetchone()
+    con.close()
+    assert row is not None
+    assert row[0] == "sessionKey"
+    assert row[1] == "secret-claude-session"
+
+    # Idempotent second sync
+    res2 = sync_firefox_cookies_to_chromium(home, provider="anthropic", only_missing=True)
+    assert res2["inserted"] == 0
+    assert res2["skipped_existing"] == 1

twinerd_browser_vault-0.1.0/tests/test_passwords.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from twinerd_browser_vault.passwords import (
+    url_host,
+    extract_login_hosts,
+    load_isolated_firefox_profiles,
+    read_firefox_logins_json,
+    decrypt_firefox_logins,
+)
+from twinerd_browser_vault.models import PasswordRecord
+
+
+def test_url_host():
+    assert url_host("https://chatgpt.com/auth/login") == "chatgpt.com"
+    assert url_host("api.anthropic.com") == "api.anthropic.com"
+    assert url_host("https://admin:secret@host.example.com:8443/test") == "host.example.com"
+
+
+def test_extract_login_hosts():
+    login = {
+        "hostname": "https://accounts.google.com/signin",
+        "formSubmitURL": "https://accounts.google.com/CheckCookie",
+        "httpRealm": None,
+    }
+    hosts = extract_login_hosts(login)
+    assert hosts == ["accounts.google.com"]
+
+
+def test_load_isolated_firefox_profiles(tmp_path: Path):
+    home = tmp_path / "home"
+    ff = home / ".mozilla" / "firefox"
+    ff.mkdir(parents=True)
+
+    prof1 = ff / "random.default"
+    prof1.mkdir()
+    prof2 = ff / "random.dev-edition"
+    prof2.mkdir()
+
+    profiles = load_isolated_firefox_profiles(home)
+    assert len(profiles) == 2
+    assert prof1.resolve() in profiles
+    assert prof2.resolve() in profiles
+
+
+def test_decrypt_firefox_logins_with_mock_tool(tmp_path: Path):
+    prof = tmp_path / "prof"
+    prof.mkdir()
+
+    # Create dummy decrypt tool
+    tool = tmp_path / "mock-decrypt"
+    payload = json.dumps([
+        {
+            "hostname": "https://chatgpt.com",
+            "username": "user@example.com",
+            "password": "secret-password",
+        }
+    ])
+    tool.write_text(f"#!/bin/sh\nprintf '%s\\n' '{payload}'\n", encoding="utf-8")
+    tool.chmod(0o755)
+
+    records = decrypt_firefox_logins(prof, decrypt_tool=str(tool), provider="chatgpt")
+    assert len(records) == 1
+    assert records[0].provider == "chatgpt"
+    assert records[0].host == "chatgpt.com"
+    assert records[0].username == "user@example.com"
+    assert records[0].password == "secret-password"

twinerd_browser_vault-0.1.0/tests/test_profiles.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from twinerd_browser_vault.profiles import (
+    detect_available_profiles,
+    get_profile_size,
+    format_size,
+    inspect_profile,
+    create_profile_snapshot,
+    restore_profile_snapshot,
+)
+
+
+def test_format_size():
+    assert format_size(500) == "500.0 B"
+    assert format_size(2048) == "2.0 KB"
+    assert format_size(1048576 * 5) == "5.0 MB"
+
+
+def test_profile_snapshot_and_restore(tmp_path: Path):
+    home = tmp_path / "home"
+    chrome_profile = home / ".config" / "google-chrome" / "Default"
+    chrome_profile.mkdir(parents=True)
+    (chrome_profile / "Preferences").write_text('{"test": true}', encoding="utf-8")
+    (chrome_profile / "History").write_text("dummy-history", encoding="utf-8")
+
+    # Detect
+    detected = detect_available_profiles(home=home)
+    assert "chrome" in detected
+    assert detected["chrome"] == home / ".config" / "google-chrome"
+
+    # Size
+    size = get_profile_size(detected["chrome"])
+    assert size > 0
+
+    # Inspect
+    meta = inspect_profile("chrome", detected["chrome"])
+    assert meta.browser == "chrome"
+    assert meta.size_bytes == size
+
+    # Snapshot
+    snapshots_dir = tmp_path / "snapshots"
+    snap = create_profile_snapshot("chrome", "acc1", snapshots_dir, home=home)
+    assert snap is not None
+    assert snap.is_dir()
+    assert (snap / "Default" / "Preferences").is_file()
+
+    # Restore to another directory
+    target = tmp_path / "restored" / ".config" / "google-chrome"
+    target.parent.mkdir(parents=True)
+    ok = restore_profile_snapshot(snap, target)
+    assert ok is True
+    assert (target / "Default" / "Preferences").is_file()