toolost-uploader 0.1.0__py3-none-any.whl

toolost_uploader/__init__.py

@@ -0,0 +1,3 @@
+"""Toolost uploader: manifest validation, browser setup, readiness check, and Playwright draft automation."""
+
+__version__ = "0.1.0"

toolost_uploader/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

toolost_uploader/approval.py

@@ -0,0 +1,116 @@
+"""Gate sintetis offline; bukan pembuktian identitas akun atau izin executor nyata."""
+
+import uuid
+
+from .journal import _checkpoint, _save
+from .storage import StorageError, _digest, _read, _require
+
+
+BINDING_KEYS = {"version", "profile", "account", "authority", "record_sha256"}
+APPROVAL_KEYS = {"version", "profile", "account", "draft", "run_id", "checkpoint_sha256",
+                 "plan_sha256", "approval_id", "state", "authority", "record_sha256"}
+
+
+def _identity(account, draft):
+    _require(account == "synthetic-account" and draft == "synthetic-draft", "identity_review_required")
+
+
+def _read_record(session, release_id, suffix, keys):
+    session._check(release_id)
+    try:
+        record = _read(session.directory, release_id + suffix)
+    except FileNotFoundError:
+        raise StorageError("approval_record_missing") from None
+    _require(isinstance(record, dict) and set(record) == keys, "invalid_approval_record")
+    _require(type(record["version"]) is int and record["version"] == 1
+             and record["profile"] == session.alias and record["authority"] == "synthetic-offline",
+             "invalid_approval_record")
+    _require(record["record_sha256"] == _digest({k: v for k, v in record.items() if k != "record_sha256"}),
+             "approval_hash_mismatch")
+    return record
+
+
+def _absent(session, name):
+    try:
+        _read(session.directory, name)
+    except FileNotFoundError:
+        return
+    raise StorageError("approval_record_exists")
+
+
+def _plan(plan):
+    _require(isinstance(plan, dict) and set(plan) == {"operations", "desired_sha256"}, "invalid_draft_plan")
+    operations = plan["operations"]
+    _require(isinstance(operations, list) and bool(operations)
+             and all(op in ("fake.upload", "fake.edit", "fake.save") for op in operations)
+             and len(operations) == len(set(operations)), "invalid_draft_plan")
+    digest = plan["desired_sha256"]
+    _require(isinstance(digest, str) and len(digest) == 64
+             and all(c in "0123456789abcdef" for c in digest), "invalid_draft_plan")
+    return _digest(plan)
+
+
+def bind(session, *, account, reviewed):
+    session._check("binding")
+    _require(reviewed is True, "binding_review_required")
+    _identity(account, "synthetic-draft")
+    name = "_offline-binding.json"
+    _absent(session, name)
+    return _save(session, name, dict(version=1, profile=session.alias, account=account,
+                                    authority="synthetic-offline"))
+
+
+def _binding(session, release_id, account):
+    # Binding per profile memakai inode privat dalam directory yang sudah terkunci.
+    try:
+        record = _read(session.directory, "_offline-binding.json")
+    except FileNotFoundError:
+        raise StorageError("binding_review_required") from None
+    _require(isinstance(record, dict) and set(record) == BINDING_KEYS, "invalid_approval_record")
+    _require(type(record["version"]) is int and record["version"] == 1
+             and record["profile"] == session.alias and record["authority"] == "synthetic-offline"
+             and record["account"] == account == "synthetic-account", "binding_mismatch")
+    _require(record["record_sha256"] == _digest({k: v for k, v in record.items() if k != "record_sha256"}),
+             "approval_hash_mismatch")
+
+
+def approve(session, release_id, *, run_id, expected_revision, account, draft, plan, approved):
+    checkpoint = _checkpoint(session, release_id, run_id)
+    _identity(account, draft)
+    _binding(session, release_id, account)
+    _require(approved is True, "confirmation_required")
+    _require(type(expected_revision) is int and checkpoint["revision"] == expected_revision, "revision_conflict")
+    plan_hash = _plan(plan)
+    name = release_id + ".approval.json"
+    _absent(session, name)
+    return _save(session, name, dict(version=1, profile=session.alias, account=account, draft=draft,
+                                    run_id=run_id, checkpoint_sha256=checkpoint["record_sha256"],
+                                    plan_sha256=plan_hash, approval_id=uuid.uuid4().hex,
+                                    state="approved", authority="synthetic-offline"))
+
+
+def verify(session, release_id, *, run_id, approval_id, account, draft, plan, consumed=False):
+    checkpoint = _checkpoint(session, release_id, run_id)
+    _identity(account, draft)
+    _binding(session, release_id, account)
+    record = _read_record(session, release_id, ".approval.json", APPROVAL_KEYS)
+    token = record["approval_id"]
+    _require(isinstance(token, str) and len(token) == 32
+             and all(c in "0123456789abcdef" for c in token)
+             and record["state"] in ("approved", "consumed"), "invalid_approval_record")
+    _require(type(consumed) is bool, "invalid_approval_record")
+    _require(record["state"] == ("consumed" if consumed else "approved"),
+             "approval_not_consumed" if consumed else "approval_consumed")
+    _require(record["approval_id"] == approval_id and record["run_id"] == run_id,
+             "approval_mismatch")
+    _require(record["account"] == account and record["draft"] == draft
+             and record["checkpoint_sha256"] == checkpoint["record_sha256"]
+             and record["plan_sha256"] == _plan(plan), "approval_stale")
+    return record
+
+
+def consume(session, release_id, *, run_id, approval_id, account, draft, plan):
+    record = verify(session, release_id, run_id=run_id, approval_id=approval_id,
+                    account=account, draft=draft, plan=plan)
+    record["state"] = "consumed"
+    return _save(session, release_id + ".approval.json", record)

toolost_uploader/browser.py

@@ -0,0 +1,253 @@
+"""Pengelolaan proses Google Chrome, profil lokal, dan koneksi CDP."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import shutil
+import socket
+import subprocess
+import sys
+import time
+from urllib.error import URLError
+from urllib.parse import urlsplit
+import urllib.request
+
+DEFAULT_CDP_PORT = 9437
+DEFAULT_CDP_ENDPOINT = f"http://127.0.0.1:{DEFAULT_CDP_PORT}"
+DEFAULT_PORTAL_URL = "https://toolost.com/user-portal/releases/manage/1"
+DEFAULT_LOGIN_URL = "https://toolost.com/login"
+
+
+def find_chrome_binary(custom_path: str | Path | None = None) -> Path | None:
+    """Temukan lokasi executable Google Chrome."""
+    if custom_path:
+        p = Path(custom_path).expanduser().resolve()
+        if p.is_file() and os.access(p, os.X_OK):
+            return p
+        return None
+
+    env_path = os.environ.get("CHROME_BIN")
+    if env_path:
+        p = Path(env_path).expanduser().resolve()
+        if p.is_file() and os.access(p, os.X_OK):
+            return p
+
+    if sys.platform == "darwin":
+        mac_default = Path("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome")
+        if mac_default.is_file() and os.access(mac_default, os.X_OK):
+            return mac_default
+
+    for name in ("google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "chrome"):
+        found = shutil.which(name)
+        if found:
+            p = Path(found).resolve()
+            if p.is_file() and os.access(p, os.X_OK):
+                return p
+
+    return None
+
+
+def resolve_profile_dir(alias: str | None = None, root: Path | None = None) -> Path:
+    """Tentukan direktori profil browser terisolasi."""
+    if root is not None:
+        base = root
+    else:
+        # Cek jika berjalan di repository workspace lokal dengan direktori .local
+        repo_local = Path(__file__).resolve().parents[1] / ".local"
+        if repo_local.is_dir():
+            if not alias or alias == "default":
+                return repo_local / "chrome-profile"
+            return repo_local / "profiles" / alias
+
+        # Fallback ke direktori konfigurasi user standar
+        data_home = os.environ.get("XDG_DATA_HOME")
+        if data_home:
+            base = Path(data_home) / "toolost-uploader" / "chrome-profiles"
+        elif sys.platform == "darwin":
+            base = Path.home() / "Library" / "Application Support" / "toolost-uploader" / "chrome-profiles"
+        else:
+            base = Path.home() / ".local" / "share" / "toolost-uploader" / "chrome-profiles"
+
+    target = base / (alias or "default")
+    target.mkdir(parents=True, mode=0o700, exist_ok=True)
+    return target
+
+
+def check_and_clean_stale_lock(profile_dir: Path) -> tuple[bool, str]:
+    """Periksa apakah profil sedang digunakan; bersihkan stale lock bila PID sudah mati."""
+    lock = profile_dir / "SingletonLock"
+    if not lock.exists() and not lock.is_symlink():
+        return False, "Profil bebas (tidak ada lock)."
+
+    if not lock.is_symlink():
+        return True, "Profil memiliki non-symlink lock."
+
+    try:
+        owner = os.readlink(lock)
+    except OSError:
+        return True, "Tidak dapat membaca symlink lock."
+
+    host, separator, pid_str = owner.rpartition("-")
+    if not separator or not pid_str.isdigit():
+        return True, f"Format lock tidak dikenal: {owner}"
+
+    # Hanya bersihkan jika hostname cocok dengan host saat ini
+    if host != socket.gethostname():
+        return True, f"Lock dimiliki oleh host lain: {host}"
+
+    pid = int(pid_str)
+    try:
+        os.kill(pid, 0)
+        return True, f"Profil sedang aktif digunakan oleh proses PID {pid}."
+    except ProcessLookupError:
+        # Proses sudah mati; aman untuk membersihkan stale locks
+        try:
+            lock.unlink(missing_ok=True)
+            (profile_dir / "SingletonCookie").unlink(missing_ok=True)
+            (profile_dir / "SingletonSocket").unlink(missing_ok=True)
+            return False, f"Stale lock dari PID {pid} yang sudah mati berhasil dibersihkan."
+        except OSError as e:
+            return True, f"Gagal menghapus stale lock: {e}"
+    except PermissionError:
+        return True, f"Proses PID {pid} masih berjalan (izin terbatas)."
+
+
+def is_cdp_available(endpoint: str = DEFAULT_CDP_ENDPOINT, timeout: float = 1.0) -> bool:
+    """Periksa apakah endpoint CDP browser loopback aktif dan merespons."""
+    url = f"{endpoint.rstrip('/')}/json/version"
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "toolost-readiness-check"})
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            if resp.status == 200:
+                data = json.loads(resp.read().decode("utf-8"))
+                return isinstance(data, dict) and "Browser" in data
+    except (URLError, OSError, ValueError, TimeoutError):
+        pass
+    return False
+
+
+def launch_chrome(
+    profile_dir: Path,
+    *,
+    mode: str = "cdp",
+    port: int = DEFAULT_CDP_PORT,
+    chrome_path: str | Path | None = None,
+    url: str | None = None,
+) -> subprocess.Popen:
+    """Jalankan proses Google Chrome dalam mode setup manual atau background CDP."""
+    chrome_bin = find_chrome_binary(chrome_path)
+    if not chrome_bin:
+        raise FileNotFoundError("Google Chrome executable tidak ditemukan di sistem.")
+
+    check_and_clean_stale_lock(profile_dir)
+
+    target_url = url or (DEFAULT_LOGIN_URL if mode == "setup" else DEFAULT_PORTAL_URL)
+    args = [
+        str(chrome_bin),
+        f"--user-data-dir={profile_dir}",
+        "--no-first-run",
+        "--no-default-browser-check",
+    ]
+
+    if mode == "cdp":
+        args.extend([
+            "--remote-debugging-address=127.0.0.1",
+            f"--remote-debugging-port={port}",
+        ])
+        # Background process mandiri
+        proc = subprocess.Popen(
+            [*args, target_url],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        return proc
+
+    # Setup mode: interaktif di depan pengguna
+    return subprocess.Popen([*args, target_url])
+
+
+def ensure_cdp_ready(
+    endpoint: str = DEFAULT_CDP_ENDPOINT,
+    profile_dir: Path | None = None,
+    timeout: float = 12.0,
+    log=None,
+    chrome_path: str | Path | None = None,
+) -> bool:
+    """Pastikan browser CDP aktif; luncurkan otomatis jika belum menyala."""
+    if is_cdp_available(endpoint):
+        return True
+
+    u = urlsplit(endpoint)
+    port = u.port or DEFAULT_CDP_PORT
+    pdir = profile_dir or resolve_profile_dir()
+
+    if log:
+        log(f"Browser CDP di port {port} belum aktif; melakukan auto-bootup Chrome...")
+
+    launch_chrome(pdir, mode="cdp", port=port, chrome_path=chrome_path)
+
+    start_time = time.monotonic()
+    while time.monotonic() - start_time < timeout:
+        if is_cdp_available(endpoint):
+            if log:
+                log(f"Browser CDP di port {port} berhasil aktif dan siap.")
+            return True
+        time.sleep(0.3)
+
+    return False
+
+
+def check_auth_identity(endpoint: str = DEFAULT_CDP_ENDPOINT, timeout: float = 15.0) -> dict:
+    """Periksa status autentikasi aktif pada browser CDP Too Lost dengan mengamati navigasi portal."""
+    try:
+        from playwright.sync_api import sync_playwright
+        with sync_playwright() as p:
+            browser = p.chromium.connect_over_cdp(endpoint)
+            try:
+                context = browser.contexts[0] if browser.contexts else browser.new_context()
+                pages = [pg for pg in context.pages if not pg.is_closed() and "toolost.com" in pg.url]
+                page = pages[0] if pages else context.new_page()
+
+                user_ids = []
+                http_statuses = []
+
+                def on_response(r):
+                    u = urlsplit(r.url)
+                    if u.scheme == "https" and u.netloc in ("toolost.com", "www.toolost.com") and u.path == "/api/auth/me":
+                        http_statuses.append(r.status)
+                        if r.status == 200:
+                            try:
+                                d = r.json()
+                                uid = d.get("user", {}).get("id") or d.get("id")
+                                if uid is not None:
+                                    user_ids.append(str(uid))
+                            except Exception:
+                                pass
+
+                page.on("response", on_response)
+                try:
+                    page.goto(DEFAULT_PORTAL_URL, wait_until="domcontentloaded", timeout=timeout * 1000)
+                    start_wait = time.monotonic()
+                    while time.monotonic() - start_wait < 6.0:
+                        if user_ids or any(s in (401, 403) for s in http_statuses):
+                            break
+                        page.wait_for_timeout(250)
+                finally:
+                    page.remove_listener("response", on_response)
+
+                u = urlsplit(page.url)
+                if any(x in u.path.lower() for x in ("login", "signin", "auth")):
+                    return {"status": "unauthorized", "http_code": 401}
+
+                if user_ids:
+                    return {"status": "authenticated", "account_id": user_ids[0]}
+                if 401 in http_statuses:
+                    return {"status": "unauthorized", "http_code": 401}
+                return {"status": "unknown", "http_statuses": http_statuses}
+            finally:
+                browser.close()
+    except Exception as e:
+        return {"status": "error", "message": type(e).__name__}