cookiesync-cli 0.1.0__py3-none-any.whl

cookiesync/service.py

@@ -0,0 +1,214 @@
+"""Manage the two macOS LaunchAgents that drive cookiesync: a long-lived watch daemon and a periodic reconcile tick.
+
+Mirrors reposync's service layer. Plist generation is a pure function so tests assert
+the exact XML; the launchctl boundary is an injected :class:`Launcher` so tests never
+bootstrap real agents. Three sharp edges are deliberate and must survive any cleanup:
+
+* ``EnvironmentVariables.PATH`` prepends ``/opt/homebrew/bin`` — launchd strips the
+  Homebrew prefixes where ``reposync`` and the browsers live, so the daemon would fail
+  to resolve them otherwise.
+* the program path is **not** symlink-resolved (it points at the stable installed
+  ``cookiesync`` entrypoint), so a ``uv`` or ``brew`` upgrade that relinks the binary
+  never strands the agent at a deleted versioned path.
+* ``LimitLoadToSessionType`` is ``Aqua`` (the GUI session), required for the keychain
+  and Touch-ID access the consent layer needs.
+"""
+
+from __future__ import annotations
+
+import os
+import plistlib
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, NewType, Protocol
+
+import anyio
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+Label = NewType("Label", str)
+
+WATCH_LABEL = Label("com.github.yasyf.cookiesync.watch")
+RECONCILE_LABEL = Label("com.github.yasyf.cookiesync.reconcile")
+
+LAUNCH_AGENTS = Path("Library/LaunchAgents")
+
+DAEMON_PATH = "/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin"
+
+SESSION_TYPE = "Aqua"
+
+RECONCILE_INTERVAL = 900
+
+ALREADY_LOADED = "service already loaded"
+NOT_LOADED = "Could not find specified service"
+
+
+class ServiceError(Exception):
+    """A ``launchctl`` invocation failed for a reason other than an already-loaded or not-loaded agent."""
+
+
+@dataclass(frozen=True, slots=True)
+class AgentSpec:
+    """One LaunchAgent: its label, the ``cookiesync`` subcommand it runs, and the launchd keys unique to it.
+
+    The watch daemon carries ``KeepAlive``; the reconcile tick carries ``StartInterval``.
+    Everything common — the PATH override, the Aqua session limit, ``RunAtLoad`` — lives
+    in :func:`render` so the two agents can never diverge on it.
+    """
+
+    label: Label
+    command: str
+    extra: tuple[tuple[str, object], ...]
+
+    def render(self) -> bytes:
+        return plistlib.dumps(
+            {
+                "Label": self.label,
+                "ProgramArguments": [program_path(), self.command],
+                "EnvironmentVariables": {"PATH": DAEMON_PATH},
+                "RunAtLoad": True,
+                "LimitLoadToSessionType": SESSION_TYPE,
+                "ProcessType": "Background",
+                "StandardOutPath": str(log_path(self.label)),
+                "StandardErrorPath": str(log_path(self.label)),
+            }
+            | dict(self.extra),
+            sort_keys=True,
+        )
+
+
+RECONCILE_AGENT = AgentSpec(RECONCILE_LABEL, "reconcile", (("StartInterval", RECONCILE_INTERVAL),))
+WATCH_AGENT = AgentSpec(WATCH_LABEL, "watch", (("KeepAlive", True),))
+AGENTS: tuple[AgentSpec, ...] = (RECONCILE_AGENT, WATCH_AGENT)
+
+
+class Launcher(Protocol):
+    """The ``launchctl`` boundary: bootstraps and boots out LaunchAgents.
+
+    Tests inject a fake so install/uninstall never touch the real launchd domain.
+    """
+
+    async def bootstrap(self, plist: Path) -> None:
+        """Load the agent described by ``plist`` into this user's GUI launchd domain."""
+        ...
+
+    async def bootout(self, label: Label) -> None:
+        """Remove the agent ``label`` from this user's GUI launchd domain."""
+        ...
+
+
+@dataclass(frozen=True, slots=True)
+class LaunchctlLauncher:
+    """The production :class:`Launcher`: shells out to ``launchctl bootstrap``/``bootout``.
+
+    Both verbs target the caller's ``gui/<uid>`` domain. An "already loaded" bootstrap
+    and a "not loaded" bootout are tolerated so install and uninstall are idempotent;
+    any other non-zero exit raises :class:`ServiceError`.
+    """
+
+    async def bootstrap(self, plist: Path) -> None:
+        await run_launchctl("bootstrap", gui_domain(), str(plist), tolerate=ALREADY_LOADED)
+
+    async def bootout(self, label: Label) -> None:
+        await run_launchctl("bootout", f"{gui_domain()}/{label}", tolerate=NOT_LOADED)
+
+
+def gui_domain() -> str:
+    return f"gui/{os.getuid()}"
+
+
+def launch_agents_dir() -> Path:
+    return Path.home() / LAUNCH_AGENTS
+
+
+def log_path(label: Label) -> Path:
+    return Path.home() / "Library" / "Logs" / f"{label}.log"
+
+
+def plist_path(label: Label) -> Path:
+    """The on-disk ``~/Library/LaunchAgents/<label>.plist`` path for ``label``."""
+    return launch_agents_dir() / f"{label}.plist"
+
+
+def program_path() -> str:
+    """The stable ``cookiesync`` entrypoint, deliberately NOT symlink-resolved.
+
+    Resolving the symlink would bake a versioned ``uv``/Homebrew path into the plist
+    that the next upgrade purges; pointing at the installed entrypoint keeps the agent
+    valid across upgrades.
+    """
+    return shutil.which("cookiesync") or os.environ["COOKIESYNC_BIN"]
+
+
+async def write_plist(label: Label, program_args: Sequence[str]) -> Path:
+    """Render the agent for ``label`` running ``program_args`` and write it to its plist path.
+
+    Args:
+        label: The LaunchAgent label, which selects its launchd-key profile.
+        program_args: The ``cookiesync`` subcommand the agent runs, e.g. ``["watch"]``.
+
+    Returns:
+        The ``~/Library/LaunchAgents/<label>.plist`` path the plist was written to.
+    """
+    await anyio.Path(launch_agents_dir()).mkdir(parents=True, exist_ok=True)
+    await (path := anyio.Path(plist_path(label))).write_bytes(agent_for(label, program_args).render())
+    return Path(path)
+
+
+def agent_for(label: Label, program_args: Sequence[str]) -> AgentSpec:
+    match next(agent for agent in AGENTS if agent.label == label):
+        case agent if [agent.command] == list(program_args):
+            return agent
+        case agent:
+            raise ServiceError(f"{label} runs {agent.command!r}, not {list(program_args)!r}")
+
+
+async def run_launchctl(*args: str, tolerate: str) -> None:
+    result = await anyio.run_process(["launchctl", *args], check=False)
+    match result.returncode:
+        case 0:
+            return
+        case _ if tolerate in result.stderr.decode():
+            return
+        case code:
+            raise ServiceError(f"launchctl {args[0]}: exit {code}: {result.stderr.decode().strip()}")
+
+
+async def install(launcher: Launcher, *, tick_only: bool = False) -> None:
+    """Write and bootstrap the reconcile tick, and unless ``tick_only`` the watch daemon.
+
+    Each agent is booted out before bootstrap so a re-install picks up plist changes,
+    tolerating the not-loaded case on a first install.
+
+    Args:
+        launcher: The launchctl boundary that loads the agents.
+        tick_only: Install only the periodic reconcile tick, skipping the watch daemon.
+    """
+    await bootstrap_agent(launcher, RECONCILE_AGENT)
+    if tick_only:
+        return
+    await bootstrap_agent(launcher, WATCH_AGENT)
+
+
+async def uninstall(launcher: Launcher) -> None:
+    """Boot out both LaunchAgents and remove their plist files; a missing file is not an error.
+
+    Args:
+        launcher: The launchctl boundary that boots out the agents.
+    """
+    async with anyio.create_task_group() as tg:
+        for agent in AGENTS:
+            tg.start_soon(remove_agent, launcher, agent.label)
+
+
+async def bootstrap_agent(launcher: Launcher, agent: AgentSpec) -> None:
+    path = await write_plist(agent.label, [agent.command])
+    await launcher.bootout(agent.label)
+    await launcher.bootstrap(path)
+
+
+async def remove_agent(launcher: Launcher, label: Label) -> None:
+    await launcher.bootout(label)
+    await anyio.Path(plist_path(label)).unlink(missing_ok=True)

cookiesync/state.py

@@ -0,0 +1,173 @@
+"""Load and persist cookiesync's ``state.json``: the self target, tracked browser endpoints, and cadence settings.
+
+Mirrors reposync's on-disk model — Go-style duration strings (``"15m"``, ``"3s"``), an
+atomic temp-file-plus-rename save, and a read-modify-write :func:`update` serialized across
+processes by a filelock on :func:`cookiesync.paths.lock_path`. Hosts are *not* stored here;
+they are read live from reposync elsewhere.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Awaitable, Callable
+from contextlib import asynccontextmanager
+from dataclasses import asdict, dataclass, field
+from datetime import timedelta
+from inspect import isawaitable
+from tempfile import mkstemp
+from typing import TYPE_CHECKING, NewType
+
+import anyio
+from filelock import FileLock
+
+from cookiesync.paths import config_dir, lock_path, state_path
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+SshTarget = NewType("SshTarget", str)
+BrowserId = NewType("BrowserId", str)
+
+DURATION_UNITS: tuple[tuple[str, int], ...] = (("h", 3600), ("m", 60), ("s", 1))
+DURATION_SIZES: dict[str, int] = dict(DURATION_UNITS)
+
+
+def parse_duration(text: str) -> timedelta:
+    """Parse a Go-style duration string such as ``"15m"`` or ``"90s"`` into a :class:`~datetime.timedelta`."""
+    return timedelta(seconds=int(text[:-1]) * DURATION_SIZES[text[-1]])
+
+
+def format_duration(delta: timedelta) -> str:
+    """Render a :class:`~datetime.timedelta` as the most compact Go-style string, e.g. ``"15m"`` or ``"90s"``."""
+    return next(
+        f"{seconds // size}{unit}"
+        for unit, size in DURATION_UNITS
+        if (seconds := round(delta.total_seconds())) % size == 0
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class Settings:
+    """Cadence knobs read by the sync, watch, and reconcile loops; serialized as Go-style durations."""
+
+    interval: timedelta = timedelta(minutes=15)
+    idle_threshold: timedelta = timedelta(minutes=5)
+    watch_debounce: timedelta = timedelta(seconds=3)
+    op_timeout: timedelta = timedelta(minutes=2)
+    auth_ttl: timedelta = timedelta(minutes=5)
+
+    def to_json(self) -> dict[str, str]:
+        return {key: format_duration(value) for key, value in asdict(self).items()}
+
+    @classmethod
+    def from_json(cls, raw: dict[str, str]) -> Settings:
+        return cls(**{key: parse_duration(value) for key, value in raw.items()})
+
+
+@dataclass(frozen=True, slots=True)
+class BrowserEndpoint:
+    """One tracked browser profile on a host, keyed by its :attr:`id`.
+
+    Example:
+        >>> BrowserEndpoint(SshTarget("me@laptop"), BrowserId("arc"), "Default").id
+        'me@laptop:arc:Default'
+    """
+
+    host: SshTarget
+    browser: BrowserId
+    profile: str
+
+    @property
+    def id(self) -> str:
+        """The endpoint's stable identity, ``host:browser:profile``."""
+        return f"{self.host}:{self.browser}:{self.profile}"
+
+    def to_json(self) -> dict[str, str]:
+        return {"host": self.host, "browser": self.browser, "profile": self.profile}
+
+    @classmethod
+    def from_json(cls, raw: dict[str, str]) -> BrowserEndpoint:
+        return cls(SshTarget(raw["host"]), BrowserId(raw["browser"]), raw["profile"])
+
+
+@dataclass(frozen=True, slots=True)
+class State:
+    """The full on-disk cookiesync configuration for this host.
+
+    Example:
+        >>> await State(SshTarget("me@laptop")).save()
+    """
+
+    self_target: SshTarget
+    browsers: tuple[BrowserEndpoint, ...] = ()
+    settings: Settings = field(default_factory=Settings)
+
+    def to_json(self) -> dict[str, object]:
+        return {
+            "self_target": self.self_target,
+            "browsers": [endpoint.to_json() for endpoint in self.browsers],
+            "settings": self.settings.to_json(),
+        }
+
+    @classmethod
+    def from_json(cls, raw: dict[str, object]) -> State:
+        return cls(
+            SshTarget(raw["self_target"]),
+            tuple(BrowserEndpoint.from_json(endpoint) for endpoint in raw["browsers"]),
+            Settings.from_json(raw["settings"]),
+        )
+
+    async def save(self) -> State:
+        """Write this state to :func:`cookiesync.paths.state_path` atomically (temp file, then rename)."""
+        await write_json(self.to_json())
+        return self
+
+
+async def read_json() -> dict[str, object] | None:
+    return json.loads(await path.read_text()) if await (path := anyio.Path(state_path())).exists() else None
+
+
+async def write_json(payload: dict[str, object]) -> None:
+    await anyio.Path(config_dir()).mkdir(parents=True, exist_ok=True)
+    await (tmp := anyio.Path(await anyio.to_thread.run_sync(mktemp_path))).write_text(
+        json.dumps(payload, indent=2) + "\n"
+    )
+    os.replace(tmp, state_path())
+
+
+def mktemp_path() -> str:
+    handle, name = mkstemp(dir=config_dir(), prefix="state-", suffix=".tmp")
+    os.close(handle)
+    return name
+
+
+async def load() -> State:
+    """Read :func:`cookiesync.paths.state_path`, returning a default :class:`State` when the file is absent."""
+    match await read_json():
+        case None:
+            return State(default_self_target())
+        case raw:
+            return State.from_json(raw)
+
+
+async def update(fn: Callable[[State], State | Awaitable[State]]) -> State:
+    """Read-modify-write the state under the reconcile flock, then save and return the result."""
+    async with hold_lock():
+        result = fn(await load())
+        return await (await result if isawaitable(result) else result).save()
+
+
+@asynccontextmanager
+async def hold_lock() -> AsyncIterator[None]:
+    await anyio.Path(config_dir()).mkdir(parents=True, exist_ok=True)
+    lock = FileLock(lock_path())
+    await anyio.to_thread.run_sync(lock.acquire)
+    try:
+        yield
+    finally:
+        lock.release()
+
+
+def default_self_target() -> SshTarget:
+    return SshTarget(f"{os.environ['USER']}@{os.uname().nodename}")

cookiesync/transport.py

@@ -0,0 +1,108 @@
+"""Async SSH transport: run a remote command over ssh and fan out across hosts.
+
+Mirrors reposync's host transport — the same BatchMode/keepalive flag set and the
+``brew shellenv`` wrap, since a non-interactive ssh on macOS lacks brew (and thus
+brew-installed cookiesync) on ``PATH``.
+"""
+
+from __future__ import annotations
+
+import shlex
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import anyio
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable, Sequence
+
+    from cookiesync.state import SshTarget
+
+SSH_OPTS = (
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "ConnectTimeout=5",
+    "-o",
+    "ServerAliveInterval=5",
+    "-o",
+    "ServerAliveCountMax=3",
+)
+
+BREW_SHELLENV = "/opt/homebrew/bin/brew shellenv"
+
+MAX_CONCURRENT_HOSTS = 8
+
+
+class SshError(Exception):
+    """An ssh command exited non-zero, carrying the target and the remote stderr."""
+
+    def __init__(self, target: SshTarget, returncode: int, stderr: str) -> None:
+        self.target = target
+        self.returncode = returncode
+        self.stderr = stderr
+        super().__init__(f"ssh {target}: exit {returncode}: {stderr}")
+
+
+@dataclass(frozen=True, slots=True)
+class HostResult[T]:
+    """The outcome of running a fan-out function against one host.
+
+    ``ok`` is ``True`` and ``value`` holds the return when the function succeeded;
+    ``ok`` is ``False`` and ``value`` holds the raised exception when it failed.
+    """
+
+    target: SshTarget
+    ok: bool
+    value: T | BaseException
+
+
+def shell_quote(s: str) -> str:
+    """Quote ``s`` so it survives intact as one argument to a remote shell."""
+    return shlex.quote(s)
+
+
+async def ssh(target: SshTarget, remote_cmd: str, *, stdin: bytes | None = None) -> str:
+    """Run ``remote_cmd`` on ``target`` over ssh and return its stdout.
+
+    The remote command is wrapped to source brew's shellenv first. ``stdin``, when
+    given, is piped to the remote command's standard input.
+
+    Raises:
+        SshError: the ssh process exited non-zero; carries the target and stderr.
+    """
+    result = await anyio.run_process(
+        ["ssh", *SSH_OPTS, target, f'eval "$({BREW_SHELLENV})" && {remote_cmd}'],
+        input=stdin,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise SshError(target, result.returncode, result.stderr.decode().strip())
+    return result.stdout.decode()
+
+
+async def each_host[T](
+    targets: Sequence[SshTarget],
+    fn: Callable[[SshTarget], Awaitable[T]],
+    *,
+    limit: int = MAX_CONCURRENT_HOSTS,
+) -> list[HostResult[T]]:
+    """Run ``fn`` against every target concurrently, bounded by ``limit``.
+
+    Each target's outcome is captured into a ``HostResult`` so one failing host
+    never aborts the batch. Results come back in input order.
+    """
+    semaphore = anyio.Semaphore(limit)
+    collected: dict[int, HostResult[T]] = {}
+
+    async def run(index: int, target: SshTarget) -> None:
+        async with semaphore:
+            try:
+                collected[index] = HostResult(target, True, await fn(target))
+            except Exception as exc:  # noqa: BLE001 — per-host failures are collected, not swallowed
+                collected[index] = HostResult(target, False, exc)
+
+    async with anyio.create_task_group() as tg:
+        for index, target in enumerate(targets):
+            tg.start_soon(run, index, target)
+    return [collected[index] for index in range(len(targets))]

cookiesync_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: cookiesync-cli
+Version: 0.1.0
+Summary: Sync your browser cookies across machines.
+Keywords: 
+Author: Yasyf Mohamedali
+Author-email: Yasyf Mohamedali <yasyfm@gmail.com>
+License-Expression: PolyForm-Noncommercial-1.0.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: click>=8
+Requires-Dist: cryptography>=43
+Requires-Dist: filelock>=3.16
+Requires-Dist: loguru>=0.7
+Requires-Dist: watchfiles>=0.24
+Requires-Dist: anyio>=4 ; extra == 'dev'
+Requires-Dist: pytest>=8.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.8 ; extra == 'dev'
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/yasyf/cookiesync
+Project-URL: Repository, https://github.com/yasyf/cookiesync
+Project-URL: Issues, https://github.com/yasyf/cookiesync/issues
+Project-URL: Changelog, https://github.com/yasyf/cookiesync/blob/main/CHANGELOG.md
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# cookiesync
+
+![cookiesync banner](https://github.com/yasyf/cookiesync/raw/main/docs/assets/readme-banner.webp)
+
+[![PyPI](https://img.shields.io/pypi/v/cookiesync-cli.svg)](https://pypi.org/project/cookiesync-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/cookiesync-cli.svg)](https://pypi.org/project/cookiesync-cli/)
+[![License: PolyForm Noncommercial 1.0.0](https://img.shields.io/badge/License-PolyForm--Noncommercial--1.0.0-blue.svg)](https://github.com/yasyf/cookiesync/blob/main/LICENSE)
+
+Sync your browser cookies across machines.
+
+cookiesync copies the cookies your browser already holds on one machine and
+replays them on another, so the sites you're signed into follow you between
+laptops. It reuses your existing browser session instead of asking for
+passwords again, so logins, 2FA, and SSO state carry over without you
+re-authenticating anywhere.
+
+> **macOS only.** cookiesync keeps your browser's Safe Storage key behind a
+> Touch ID prompt and a Secure Enclave–bound daemon, so decrypted cookies never
+> land on disk. The key helper is a Developer-ID-signed, notarized `.app`.
+
+## Install
+
+cookiesync publishes on PyPI as `cookiesync-cli` and installs a `cookiesync`
+command. You'll reach for it often, so install it onto your PATH with
+[uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install cookiesync-cli
+cookiesync --help
+```
+
+To add it to a project instead:
+
+```bash
+uv add cookiesync-cli
+```
+
+## Quickstart
+
+```bash
+# Fetch the signed key helper and start the sync daemon (one time)
+cookiesync install
+
+# Confirm the helper is installed and Developer-ID signed
+cookiesync doctor
+
+# Track a browser to sync between this Mac and another host
+cookiesync browser add other-host chrome
+
+# Hand a logged-in session to a script without giving it a password
+cookiesync cookies https://example.com --browser chrome
+```
+
+Once a browser is tracked, the resident daemon watches its cookie store and
+converges it across your hosts. Run `cookiesync reconcile` to force a full pass.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `install` | Fetch the signed key helper, then install the LaunchAgents (watch daemon + reconcile tick). |
+| `uninstall` | Remove the cookiesync LaunchAgents. |
+| `doctor` | Check that the key helper is installed and Developer-ID signed. |
+| `browser add/ls/rm` | Track, list, and untrack the browser profiles cookiesync syncs across hosts. |
+| `watch` | Run the resident sync daemon: watch local stores and serve the RPC socket. |
+| `sync --browser <name>` | Converge one browser group across this host and its peers. |
+| `reconcile` | Run a full reconcile pass over every tracked browser group. |
+| `auth` | Release the Safe Storage key behind one Touch ID tap and cache it for a short window. |
+| `cookies <url>` | Stream a URL's cookies in the chosen format (Playwright by default). |
+| `self` | Print this host's SSH target, as reposync reports it. |
+| `rpc <method>` | Low-level RPC client for the resident daemon. |
+
+Run `cookiesync --help`, or `cookiesync <command> --help`, for the full reference.
+
+## What problems does this solve?
+
+- A fresh machine means signing into every account again. cookiesync moves your
+  live browser session over, so you land already logged in.
+- 2FA and SSO re-prompt whenever you switch laptops. Carrying the existing
+  cookies over keeps those sessions valid instead of restarting them.
+- Built-in browser sync is all-or-nothing and locked to one vendor. cookiesync
+  is browser-agnostic, and you pick which machines and which sites it touches.
+- Automation needs a logged-in session but should never hold a password. Hand a
+  CI job or an agent the cookies it needs instead of a credential it can leak.
+
+## License
+
+PolyForm Noncommercial 1.0.0 — see [LICENSE](https://github.com/yasyf/cookiesync/blob/main/LICENSE).

cookiesync_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+cookiesync/__init__.py,sha256=HIzld7Ntk31OHzXkxxXwkfhqjmGmtYLkEbb-eOvvTp0,85
+cookiesync/__main__.py,sha256=i43SB8UUcQlTQivUfDg070qDluA6jejDDit5Ot7DN0Y,107
+cookiesync/cli.py,sha256=pGuiErDGIYgovjOPOKxk5_QDhElKe5MaB-9GLPa2I5U,12803
+cookiesync/cookie/__init__.py,sha256=Z88UHD7508-2jj-8Y3EK4wqyyg4qljpUxOIfa0FF9LM,724
+cookiesync/cookie/backend.py,sha256=lh5mOKsT4081_JLQbzm0gVytzHLI8kT3sfcUkL6lLA4,3830
+cookiesync/cookie/browsers.py,sha256=grZsN9g25Gmc8E0mGvyo-v4n2MoCkBP_rPGCwnABxa8,1703
+cookiesync/cookie/consent.py,sha256=uwCjmegDOENWY1zpIGAZpsad3B1J0Xv6bjSb9-Ph4Xw,5981
+cookiesync/cookie/crypto.py,sha256=1W71mkOk8ezUcMwHbx64X2Bs1W0j2DxWZr-TqqMcJkQ,3431
+cookiesync/cookie/domains.py,sha256=fDLJv0YSu1VU_TdIRN9FCw7sKOhiobcFPugOdUCVZwc,1332
+cookiesync/cookie/getcookie.py,sha256=--qIgmXsavryL2MkmTZ78QZBOfRNRLmVAp42BPy_rF8,3938
+cookiesync/cookie/merge.py,sha256=_wh8EXcFGaTkpl-JIhLt-ge9CZU0F8dEb3LyTQIEyvQ,2704
+cookiesync/cookie/models.py,sha256=7CiYfnA-2X8x2No0Qb7IMV3wgEL6g45SQxuyY0prlv4,2607
+cookiesync/cookie/pipeline.py,sha256=wPKIeWvejunOAZq_ce-cIiLDas-aae9QS6NjZOWPNgY,3715
+cookiesync/cookie/serialize.py,sha256=In_eNP10_h5eRv5V1JOPWHGWnmk5SQ13c_wSHq8fdO8,4633
+cookiesync/cookie/stores.py,sha256=ei4AdwZ8fPc--fdbLCm0lSnH6B8mKrHn57p5pwbuLe8,8857
+cookiesync/daemon/__init__.py,sha256=wPxgMf_HCUANBYnp4hcri-gI2-HpKAwyVTqoLQim394,632
+cookiesync/daemon/backend_ssh.py,sha256=qDJgVKKy1UveVHtUaK2Xke4i5dXOva8CuwpowwNIeHU,2972
+cookiesync/daemon/cache.py,sha256=WAYcz_gL18IieGNxIRUTTQgM1yD_H7kbO44FTBUn490,4126
+cookiesync/daemon/engine.py,sha256=qfrwNVjHMPu9jpNz-VrPcDDp4-SaAmQw6WRP4lus_zM,8683
+cookiesync/daemon/rpc.py,sha256=IErhxA05fwZm6e1IR4dohUUlwMsohOXxkGHKIgqW3bs,6071
+cookiesync/daemon/server.py,sha256=UmKhl_2SiPtzIw32M4lCu5ejWY3uxugvzz5GdhR9r4s,18334
+cookiesync/daemon/session.py,sha256=oGLxLanMececgQjmm4L_Okx2JEDOElXzJskJyIIz1Ys,4275
+cookiesync/daemon/sync.py,sha256=mYdEZ-5GIbqgazSfzKNrFRRMxU1w-9U-FfL6x9r9jKk,10111
+cookiesync/daemon/wire.py,sha256=8HK0SQmc90yMonH1d55ze_EPeS5C132StusrhTdyAGw,2893
+cookiesync/helper.py,sha256=b2Uu0o5LAA2SG45y-06HuqH6BZKRddMArt5HT9PiEoA,4864
+cookiesync/paths.py,sha256=sWeSYrY9-pNhI6GRhZ9YBQNCZurKPkVUtkl28CtNBsY,3396
+cookiesync/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cookiesync/registry.py,sha256=wIR9IwAvFm5MHPRdGhoAHXg_JTzrB1fwO6JprtpqB1Y,2642
+cookiesync/service.py,sha256=rLhyMZU2aTsGJIPuehKHhqlVFlGkVjJK0p65To4X2rg,7831
+cookiesync/state.py,sha256=aEwSZSQvvLfOekYEa1xjC-tklAR51guV9hZ3mGVH3qw,5862
+cookiesync/transport.py,sha256=H0GQRBh4sCokWssONdnBMCaOwkTvvbQdDvXD0pcD0GE,3421
+cookiesync_cli-0.1.0.dist-info/licenses/LICENSE,sha256=WnXdIVx8s3iX4VERpwDy0Oys0X-DlqtDvn3vn_ELQC0,4646
+cookiesync_cli-0.1.0.dist-info/WHEEL,sha256=oBsDExVIEya4llboy9Ce1l6on8xt3GrtT29y6pYVypw,81
+cookiesync_cli-0.1.0.dist-info/entry_points.txt,sha256=82BP10z9tY2BZaPYYQzlS_SoycNmKFJojDZRDe8cARs,52
+cookiesync_cli-0.1.0.dist-info/METADATA,sha256=z1PqVLUtDejmuDI8hmcvfqAhuKkwDTKWJBmpHYS-39g,5010
+cookiesync_cli-0.1.0.dist-info/RECORD,,

cookiesync_cli-0.1.0.dist-info/WHEEL

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

cookiesync_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cookiesync = cookiesync.cli:main
+