claude-backup 0.1.9__py3-none-any.whl

claude_backup/__init__.py

@@ -0,0 +1,1039 @@
+"""Unofficial, unsanctioned tool to backup Claude.ai chats to local files."""
+
+# pyright: reportAny=false, reportExplicitAny=false
+# pyright: reportImplicitOverride=false, reportUnusedCallResult=false
+# pyright: reportPrivateUsage=false, reportIncompatibleVariableOverride=false
+
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
+from asyncio import Task
+from collections import defaultdict
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Iterable,
+    Iterator,
+)
+from contextlib import aclosing, suppress
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from types import TracebackType
+from typing import Any, ClassVar, TypeAlias, TypeVar, cast, final
+from uuid import UUID
+import asyncio
+import json
+import os
+import shutil
+import sys
+
+from fake_useragent import UserAgent
+from platformdirs import user_data_dir
+from aiohttp import (
+    ClientResponseError,
+    ClientSession,
+    ClientTimeout,
+    CookieJar,
+    TCPConnector,
+)
+from yarl import URL
+import browser_cookie3  # pyright: ignore[reportMissingTypeStubs]
+
+__version__ = "0.1.9"
+
+__all__ = (
+    "__version__",
+    "main",
+    "get_session_key",
+    "Client",
+    "Store",
+    "Syncer",
+    "APIObject",
+    "Immutable",
+    "Nameable",
+    "Timestamped",
+    "Loadable",
+    "Account",
+    "Membership",
+    "Organization",
+    "Chats",
+    "ChatsEntry",
+    "Chat",
+    "Json",
+    "JsonD",
+)
+
+Json: TypeAlias = dict[str, "Json"] | list["Json"] | str | int | float | bool | None
+JsonD: TypeAlias = dict[str, Json]
+
+T = TypeVar("T")
+T_APIObject = TypeVar("T_APIObject", bound="APIObject")
+
+
+@dataclass(slots=True)
+class Client:
+    session_key: str
+    retries: int = 10
+    min_retry_delay: float = 1.0
+    max_retry_delay: float = 60.0
+    session: ClientSession = field(init=False)
+
+    def __post_init__(self):
+        headers = {"User-Agent": UserAgent().chrome}
+
+        jar = CookieJar()
+        jar.update_cookies({"sessionKey": self.session_key}, URL("https://claude.ai/"))
+
+        self.session = ClientSession(
+            headers=headers,
+            cookie_jar=jar,
+            connector=TCPConnector(limit=0),
+            timeout=ClientTimeout(total=None),
+        )
+
+    async def __aenter__(self):
+        await self.session.__aenter__()
+
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        return await self.session.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def _refresh(self, path: str) -> Json:
+        # i have never seen a 429 or in fact a 4xx error of any kind from this
+        # api, nor ratelimit headers or fields on the returned stuff (i've seen
+        # 403 Forbidden from cloudflare, in front of claude.ai, but only behind
+        # vpn i.e. totally blocked, and even then no ratelimit headers), so we
+        # will have to cross our fingers and hope our rate and conn limiting is
+        # enough not to break anything...
+        async with self.session.get(
+            f"https://claude.ai/api/{path}",
+            allow_redirects=False,  # csrf defense for very silly threat model
+        ) as r:
+            # explicitly check r.status instead of using r.raise_for_status
+            # because we want to raise for r.status >= 300 not just >= 400
+            if r.status in range(200, 300):
+                return cast(Json, await r.json())
+
+            raise ClientResponseError(
+                r.request_info,
+                r.history,
+                status=r.status,
+                message=r.reason or "",
+                headers=r.headers,
+            )
+
+    async def refresh(self, path: str) -> Json:
+        retry_delay = self.min_retry_delay
+        for retry in range(self.retries - 1):
+            try:
+                return await self._refresh(path)
+            except Exception as e:
+                print(
+                    f"Error fetching {path} (try {retry+1} of {self.retries}, "
+                    + f"waiting {round(retry_delay)}s): {e}",
+                    file=sys.stderr,
+                )
+                await asyncio.sleep(retry_delay)
+                retry_delay = min(retry_delay * 2, self.max_retry_delay)
+
+        return await self._refresh(path)
+
+
+@dataclass(slots=True)
+class Store:
+    def _wipe(self) -> None:
+        for entry in self.store_dir.iterdir():
+            if entry.is_dir():
+                shutil.rmtree(entry)
+            else:
+                entry.unlink()
+
+    def _set_chat_mtimes(self) -> None:
+        if account := Account.load(None, self):  # pyright: ignore[reportArgumentType]
+            for membership in account.memberships():
+                org = membership.organization()
+                if chats := org.chat_list():
+                    for entry in chats.cached_entries():
+                        if chat := entry.load_chat():
+                            self.save(chat.store_path(), chat.get_data(), chat.get_mtime())
+
+    MIGRATIONS: ClassVar[
+        defaultdict[str | None, tuple[str, Callable[["Store"], None]]]
+    ] = defaultdict(
+        # migrate from unknown versions by not migrating anything/starting over
+        lambda: (__version__, Store._wipe),
+        {
+            "0.1.7": ("0.1.8", lambda _: None),  # if format unchanged, migrate whole store
+            "0.1.8": ("0.1.9", _set_chat_mtimes),
+        },
+    )
+
+    store_dir: Path
+    ignore_cache: bool = False
+
+    def __post_init__(self):
+        if not self.store_dir.exists():
+            self.store_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
+            (self.store_dir / "version").write_text(f"{__version__}\n")
+            return
+
+        try:
+            version = (self.store_dir / "version").read_text().strip()
+        except FileNotFoundError:
+            (self.store_dir / "version").write_text(f"{__version__}\n")
+            return
+
+        while version != __version__:
+            version, migrate_step = self.MIGRATIONS[version]
+            migrate_step(self)
+            (self.store_dir / "version").write_text(f"{version}\n")
+
+    def save(
+        self, path: Path, data: Json, mtime: datetime | float | None = None
+    ) -> None:
+        cache_file = self.store_dir / path.with_suffix(".json")
+        cache_file.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+
+        with NamedTemporaryFile(
+            "w",
+            prefix=f"{cache_file.name}-",
+            dir=cache_file.parent,
+        ) as f:
+            json.dump(
+                data, f, ensure_ascii=False, check_circular=False, separators=(",", ":")
+            )
+            f.flush()
+            Path(f.name).rename(cache_file)
+
+        if mtime:
+            mtime = mtime.timestamp() if isinstance(mtime, datetime) else mtime
+            os.utime(cache_file, (mtime, mtime))
+
+    def load(self, path: Path) -> Json | None:
+        if self.ignore_cache:
+            return None
+
+        cache_file = self.store_dir / path.with_suffix(".json")
+        with suppress(FileNotFoundError, NotADirectoryError), cache_file.open() as f:
+            return cast(Json, json.load(f))
+
+    def delete(self, path: Path) -> None:
+        file = self.store_dir / path.with_suffix(".json")
+        with suppress(FileNotFoundError):
+            file.unlink()
+
+        parent = file.parent
+        while parent != self.store_dir and parent.exists():
+            try:
+                parent.rmdir()
+                parent = parent.parent
+            except OSError:
+                break
+
+
+class APIObject:
+    _client: Client  # pyright: ignore[reportUninitializedInstanceVariable]
+    _store: Store  # pyright: ignore[reportUninitializedInstanceVariable]
+    _data: Json  # pyright: ignore[reportUninitializedInstanceVariable]
+
+    @property
+    def client(self) -> Client:
+        return self._client
+
+    @property
+    def store(self) -> Store:
+        return self._store
+
+    def get_data(self) -> Json:
+        return self._data
+
+    def get_mtime(self) -> datetime | float | None:
+        return None
+
+    def set_data(self: T_APIObject, data: Json) -> T_APIObject:
+        self._data = data
+        return self
+
+    def api_path(self) -> str:
+        raise NotImplementedError
+
+    def store_path(self) -> Path:
+        raise NotImplementedError
+
+    @classmethod
+    def _load(
+        cls: type[T_APIObject],
+        *args: Any,
+        store_path: Path | None = None,
+    ) -> T_APIObject | None:
+        obj = cls(*args)
+        if data := obj.store.load(store_path or obj.store_path()):
+            return obj.set_data(data)
+        else:
+            return None
+
+    @classmethod
+    async def _fetch(
+        cls: type[T_APIObject],
+        *args: Any,
+        api_path: str | None = None,
+    ) -> T_APIObject:
+        obj = cls(*args)
+        data = await obj.client.refresh(api_path or obj.api_path())
+        return obj.set_data(data).save()
+
+    async def refresh(self: T_APIObject) -> T_APIObject:
+        return self.set_data(await self.client.refresh(self.api_path())).save()
+
+    def save(self: T_APIObject) -> T_APIObject:
+        self.store.save(self.store_path(), self.get_data(), self.get_mtime())
+        return self
+
+    def delete_cached(self) -> None:
+        self.store.delete(self.store_path())
+
+
+class Immutable(APIObject):
+    def __hash__(self) -> int:
+        return hash(
+            json.dumps(
+                self._data,
+                ensure_ascii=False,
+                sort_keys=True,
+                check_circular=False,
+                separators=(",", ":"),
+            )
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if type(self) is type(other):
+            assert isinstance(other, APIObject)  # appease pyright
+            return self._data == other._data
+        else:
+            return NotImplemented
+
+
+class Nameable(APIObject):
+    _data: JsonD
+
+    FILENAME_XLAT: ClassVar[dict[int, int]] = {
+        ord(c): ord("_") for c in '<>:"|?*/\\ \t\n\r'
+    }
+
+    @property
+    def uuid(self) -> str:
+        return str(UUID(cast(str, self._data["uuid"])))
+
+    @property
+    def name(self) -> str | None:
+        # api seems to use {"name": ""} to mean {"name": null}
+        return cast(str, self._data.get("name")) or None
+
+    def slug(self) -> str:
+        if self.name:
+            return f"{self.name.translate(self.FILENAME_XLAT)}-{self.uuid}"
+        return self.uuid
+
+    def __str__(self) -> str:
+        if self.name:
+            return f"{self.name} ({self.uuid})"
+        return self.uuid
+
+
+class Timestamped(APIObject):
+    _data: JsonD
+
+    @property
+    def created_at(self) -> datetime | None:
+        try:
+            return datetime.fromisoformat(cast(str, self._data["created_at"]))
+        except (KeyError, TypeError, ValueError):
+            return None
+
+    @property
+    def updated_at(self) -> datetime | None:
+        try:
+            return datetime.fromisoformat(cast(str, self._data["updated_at"]))
+        except (KeyError, TypeError, ValueError):
+            return None
+
+    def get_mtime(self) -> datetime | float | None:
+        return self.updated_at
+
+
+T_Loadable = TypeVar("T_Loadable", bound="Loadable")
+
+
+class Loadable(APIObject):
+    @classmethod
+    def load(cls: type[T_Loadable], client: Client, store: Store) -> T_Loadable | None:
+        return cls._load(client, store)
+
+    @classmethod
+    async def fetch(cls: type[T_Loadable], client: Client, store: Store) -> T_Loadable:
+        return await cls._fetch(client, store)
+
+
+@final
+class Chat(Timestamped, Nameable):
+    __slots__ = (
+        "chat_list",
+        "_data",
+    )
+
+    chat_list: "Chats"
+    _data: JsonD
+
+    def __init__(
+        self,
+        chat_list: "Chats",
+    ):
+        self.chat_list = chat_list
+
+    @property
+    def client(self) -> Client:
+        return self.chat_list.client
+
+    @property
+    def store(self) -> Store:
+        return self.chat_list.store
+
+    def api_path(self) -> str:
+        return (
+            f"{self.chat_list.api_path()}/{self.uuid}"
+            + "?tree=True&rendering_mode=messages&render_all_tools=true"
+        )
+
+    def store_path(self) -> Path:
+        return self.chat_list.store_path() / self.slug()
+
+
+@final
+class ChatsEntry(Timestamped, Nameable, Immutable):
+    __slots__ = (
+        "chat_list",
+        "_data",
+    )
+
+    chat_list: "Chats"
+    _data: JsonD
+
+    def __init__(
+        self,
+        chat_list: "Chats",
+    ):
+        self.chat_list = chat_list
+
+    @property
+    def client(self) -> Client:
+        return self.chat_list.client
+
+    @property
+    def store(self) -> Store:
+        return self.chat_list.store
+
+    def chat_api_path(self) -> str:
+        return (
+            f"{self.chat_list.api_path()}/{self.uuid}"
+            + "?tree=True&rendering_mode=messages&render_all_tools=true"
+        )
+
+    def chat_store_path(self) -> Path:
+        return self.chat_list.store_path() / self.slug()
+
+    def load_chat(self) -> Chat | None:
+        return Chat._load(self.chat_list, store_path=self.chat_store_path())
+
+    async def fetch_chat(self) -> Chat:
+        return await Chat._fetch(self.chat_list, api_path=self.chat_api_path())
+
+
+@final
+class Chats(APIObject):
+    __slots__ = ("organization", "unseen", "_data")
+
+    organization: "Organization"
+    _data: dict[str, ChatsEntry]
+    unseen: int
+
+    def __init__(self, organization: "Organization"):
+        self.organization = organization
+        self.unseen = 0
+        self._data = {}
+
+    @property
+    def client(self) -> Client:
+        return self.organization.client
+
+    @property
+    def store(self) -> Store:
+        return self.organization.store
+
+    def api_path(self) -> str:
+        return f"{self.organization.api_path()}/chat_conversations"
+
+    def store_path(self) -> Path:
+        return self.organization.store_path() / "chat_conversations"
+
+    def set_data(self, data: Json) -> "Chats":
+        # convert list (reverse chronological from API) to dict (forward chronological)
+        entries = (ChatsEntry(self).set_data(raw) for raw in reversed(cast(list[JsonD], data)))
+        self._data = {entry.uuid: entry for entry in entries}
+        return self
+
+    @classmethod
+    def _load(
+        cls,
+        *args: Any,
+        store_path: Path | None = None,
+    ) -> "Chats | None":
+        obj = cls(*args)
+        if data := obj.store.load(store_path or obj.store_path()):
+            return obj.set_data(data)
+        else:
+            return None
+
+    def get_data(self) -> Json:
+        # convert dict (forward chronological) back to list (reverse chronological)
+        return [entry._data for entry in reversed(self._data.values())]
+
+    def entry(self, uuid: str) -> ChatsEntry | None:
+        return self._data.get(uuid)
+
+    def cached_entries(self) -> Iterator[ChatsEntry]:
+        # yield in reverse chronological order (newest first)
+        yield from reversed(self._data.values())
+
+    async def new_entries(
+        self, page_size: int = 20, save: bool = True
+    ) -> AsyncGenerator[ChatsEntry, None]:
+        # if no data/first fetch, fetch all entries---they're all new
+        if not self._data:
+            self.set_data(await self.client.refresh(self.api_path()))
+
+            for entry in self.cached_entries():
+                yield entry
+
+            if save:
+                self.save()
+            return
+
+        # "sliding window" sync (chat_conversations is recently-modified-first)
+        new: dict[str, ChatsEntry] = {}
+
+        offset = 0
+        limit = self.unseen + 1 if self.unseen else page_size
+        self.unseen = 0
+
+        assert limit
+
+        while True:
+            page = cast(
+                list[JsonD],
+                await self.client.refresh(
+                    f"{self.api_path()}?limit={limit}&offset={offset}"
+                ),
+            )
+
+            done = False
+            for raw in page:
+                entry = ChatsEntry(self).set_data(raw)
+                uuid = entry.uuid
+
+                if new_entry := new.get(uuid):
+                    # this api doesn't have cursors or snapshots or anything :(
+                    # so if an entry's created or updated *between our fetching
+                    # one page and the next*, there's a *new* most recent entry
+                    # which bumps all the others down and causes the last entry
+                    # of the prior page also to be the first entry of the next:
+                    #
+                    # page 1 sees [A B]:  [A B] C D E
+                    # entry D is updated: D A B C E
+                    # page 2 sees [B C]:  D A [B C] E
+                    #
+                    # of course this can happen multiple times, and in fact the
+                    # number of times it happens is the count of new entries we
+                    # would expect at offsets 0 through N on our next fetch! so
+                    # update self.unseen as a hint to the next new_entries call
+                    # that there are likely exactly self.unseen new or changed.
+                    self.unseen += 1
+
+                    # ...but if the above hypothesis is wrong for some perverse
+                    # reason like all the chats up until now being rewritten in
+                    # a specific order behind our backs, still yield the entry:
+                    #
+                    # page 1 sees [A B]:  [A B] C D E
+                    # B, D, & A updated:  A' D' B' C E
+                    # page 2 sees [B' C]: A' D' [B' C] E
+                    #
+                    # so in case the cartesian daemon of claude chats is out to
+                    # get us, we need to yield B' even if we wouldn't yield B.
+                    if entry.updated_at == new_entry.updated_at:
+                        continue
+                elif (stored := self._data.get(uuid)) and entry.updated_at == stored.updated_at:
+                    # entry was in a chronological list of ones we already had,
+                    # so we must also have all entries before it, so we're done
+                    done = True
+                    break
+
+                new[uuid] = entry
+                yield entry
+
+            # we *ought* to break from this loop by seeing something from prior
+            # refreshes, but just in case e.g. all seen entries were deleted on
+            # claude.ai (or more likely moved/counted in self.unseen)... we are
+            # also definitely done if they ran out of items for this page
+            if done or len(page) < limit:
+                break
+
+            # if not, double it and give it to the next person
+            offset += limit
+            limit *= 2
+
+        # dicts preserve order, but because there is no dict.prepend(), we need
+        # self._data to be in "forward-chronological" order so newly discovered
+        # chats belong at the "end" w/r/t iteration order. thus we insert items
+        # from necessarily reverse-chronological new in reverse so self._data's
+        # still entirely in chronological order. this may be a bit galaxy brain
+        self._data.update(reversed(new.items()))
+        if save:
+            self.save()
+
+    async def refresh(self) -> "Chats":
+        async for _ in self.new_entries():
+            pass
+
+        return self
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+
+@final
+class Organization(Nameable, Loadable):
+    __slots__ = (
+        "_client",
+        "_store",
+        "_data",
+    )
+
+    _client: Client
+    _store: Store
+    _data: JsonD
+
+    def __init__(self, client: Client, store: Store):
+        self._client = client
+        self._store = store
+
+    def api_path(self) -> str:
+        return f"organizations/{self.uuid}"
+
+    def store_path(self) -> Path:
+        return Path("organizations") / self.slug()
+
+    @property
+    def capabilities(self) -> list[str]:
+        return cast(list[str], self._data["capabilities"])
+
+    def chat_list(self) -> Chats:
+        return Chats._load(self) or Chats(self)
+
+
+@final
+class Membership(Immutable):
+    __slots__ = (
+        "account",
+        "_data",
+    )
+
+    account: "Account"
+    _data: JsonD
+
+    def __init__(self, account: "Account"):
+        self.account = account
+
+    @property
+    def client(self) -> Client:
+        return self.account.client
+
+    @property
+    def store(self) -> Store:
+        return self.account.store
+
+    def organization(self) -> Organization:
+        return Organization(self.client, self.store).set_data(
+            cast(JsonD, self._data["organization"])
+        )
+
+
+@final
+class Account(Nameable, Loadable):
+    __slots__ = (
+        "_client",
+        "_store",
+        "_data",
+    )
+
+    _client: Client
+    _store: Store
+    _data: JsonD
+
+    def __init__(self, client: Client, store: Store):
+        self._client = client
+        self._store = store
+
+    def api_path(self) -> str:
+        return "account"
+
+    def store_path(self) -> Path:
+        return Path("account")
+
+    def memberships(self) -> Iterator[Membership]:
+        for membership in cast(list[JsonD], self._data["memberships"]):
+            yield Membership(self).set_data(membership)
+
+    def organization(self, uuid: str) -> Organization | None:
+        for membership in self.memberships():
+            organization = membership.organization()
+            if organization.uuid == uuid:
+                return organization
+
+        return None
+
+
+def truncate(s: str, max_len: int) -> str:
+    if len(s) > max_len:
+        return s[: max_len - 1] + "…"
+    return s
+
+
+async def aroundrobin(*iterators: AsyncGenerator[T, None]) -> AsyncGenerator[T, None]:
+    try:
+        done = False
+        while not done:
+            done = True
+            for it in iterators:
+                with suppress(StopAsyncIteration):
+                    yield await anext(it)
+                    done = False
+    finally:
+        for it in iterators:
+            with suppress(BaseException):
+                await it.aclose()
+
+
+@dataclass(slots=True)
+class Syncer:
+    client: Client
+    store: Store
+    connections: int = 6
+    success_delay: float = 0.25
+    tty: bool = field(default_factory=sys.stdout.isatty)
+
+    async def _as_completed(
+        self, awaitables: AsyncIterator[Awaitable[T]]
+    ) -> AsyncGenerator[Task[T], None]:
+        pending: set[Task[T]] = set()
+
+        try:
+            for _ in range(self.connections):
+                try:
+                    awaitable = await anext(awaitables)
+                    pending.add(asyncio.ensure_future(awaitable))
+                except StopAsyncIteration:
+                    break
+
+            while pending:
+                done, pending = await asyncio.wait(
+                    pending, return_when=asyncio.FIRST_COMPLETED
+                )
+
+                for task in done:
+                    yield task
+
+                    await asyncio.sleep(self.success_delay)
+
+                    try:
+                        awaitable = await anext(awaitables)
+                        pending.add(asyncio.ensure_future(awaitable))
+                    except StopAsyncIteration:
+                        pass
+        except BaseException:
+            for task in pending:
+                task.cancel()
+            for task in pending:
+                with suppress(BaseException):
+                    await task
+            raise
+        finally:
+            if isinstance(awaitables, AsyncGenerator):
+                await awaitables.aclose()
+
+    def as_completed(
+        self, awaitables: Iterable[Awaitable[T]] | AsyncIterator[Awaitable[T]]
+    ) -> AsyncGenerator[Task[T], None]:
+        async def asyncify(
+            iterable: Iterable[Awaitable[T]],
+        ) -> AsyncGenerator[Awaitable[T], None]:
+            for item in iterable:
+                yield item
+
+        if isinstance(awaitables, AsyncIterator):
+            return self._as_completed(awaitables)
+        else:
+            return self._as_completed(asyncify(awaitables))
+
+    async def gather(self, *awaitables: Awaitable[T]) -> list[T]:
+        tasks_list = [asyncio.ensure_future(a) for a in awaitables]
+
+        async with aclosing(self.as_completed(tasks_list)) as gen:
+            async for task in gen:
+                await task
+
+        return [task.result() for task in tasks_list]
+
+    async def get_organizations(self) -> AsyncGenerator[Organization]:
+        old_account = Account.load(self.client, self.store)
+        account = await Account.fetch(self.client, self.store)
+
+        for membership in account.memberships():
+            organization = membership.organization()
+
+            if (
+                old_account
+                and (old_organization := old_account.organization(organization.uuid))
+                and old_organization.store_path() != organization.store_path()
+            ):
+                print(
+                    f"Renaming organization {old_organization} to {organization.name or organization.uuid}",
+                    file=sys.stderr,
+                )
+                old_dir = self.store.store_dir / old_organization.store_path()
+                new_dir = self.store.store_dir / organization.store_path()
+                with suppress(FileNotFoundError):
+                    old_dir.rename(new_dir)
+
+            if "chat" not in organization.capabilities:
+                print(
+                    f'Skipping organization {organization} without "chat" capability',
+                    file=sys.stderr,
+                )
+                continue
+
+            print(f"Fetching chats for organization {organization}", file=sys.stderr)
+            yield organization
+
+    def print_entry(self, entry: ChatsEntry) -> None:
+        name = entry.name or ""
+        if self.tty:
+            try:
+                width = os.get_terminal_size().columns
+            except OSError:
+                width = 80
+            name = truncate(name, width - 36 - 4)
+        print(f"{entry.uuid}\t{name}")
+
+    @staticmethod
+    def fetch_new_chat(entry: ChatsEntry) -> Task[Chat]:
+        # we must get old_entry *now* and not in the async function below since
+        # Chats.new_entries might finish and save the new entry over old_entry!
+        old_entry = entry.chat_list.entry(entry.uuid)
+        old_chat = old_entry.load_chat() if old_entry else None
+
+        async def _fetch_new_chat() -> Chat:
+            chat = await entry.fetch_chat()
+
+            if old_chat and old_chat.store_path() != chat.store_path():
+                old_chat.delete_cached()
+
+            return chat
+
+        return asyncio.create_task(_fetch_new_chat())
+
+    async def new_chat_fetches(self) -> AsyncGenerator[Task[Chat], None]:
+        needs_refresh: list[tuple[Chats, list[Task[Chat]], Task[None]]] = [
+            (organization.chat_list(), [], asyncio.create_task(asyncio.sleep(0)))
+            async for organization in self.get_organizations()
+        ]
+
+        try:
+            while needs_refresh:
+                async with aclosing(
+                    aroundrobin(
+                        *(
+                            (
+                                (entry, fetches)
+                                async for entry in chats.new_entries(save=False)
+                            )
+                            for chats, fetches, _ in needs_refresh
+                        )
+                    )
+                ) as items:
+                    async for entry, fetches in items:
+                        fetch = self.fetch_new_chat(entry)
+                        fetches.append(fetch)
+                        self.print_entry(entry)
+                        yield fetch
+
+                for _, _, old_save in needs_refresh:
+                    if old_save:
+                        old_save.cancel()
+
+                async def save_after_fetches(
+                    chats: Chats, fetches: list[Task[Chat]]
+                ) -> None:
+                    for fetch in fetches:
+                        await fetch
+
+                    chats.save()
+
+                needs_refresh = [
+                    (
+                        chats,
+                        [],
+                        asyncio.create_task(save_after_fetches(chats, fetches)),
+                    )
+                    for chats, fetches, _ in needs_refresh
+                    if chats.unseen
+                ]
+
+            for _, _, save in needs_refresh:
+                await save
+        except BaseException:
+            for _, _, save in needs_refresh:
+                save.cancel()
+
+                with suppress(BaseException):
+                    await save
+
+            raise
+
+    async def sync_all(self) -> None:
+        async with aclosing(self.as_completed(self.new_chat_fetches())) as tasks:
+            async for task in tasks:
+                await task
+
+
+@dataclass(slots=True)
+class DefaultPath:
+    path: str
+
+    def __str__(self):
+        try:
+            return f"~/{Path(self.path).relative_to(Path.home())}"
+        except ValueError:
+            return self.path
+
+
+def get_session_key() -> str:
+    try:
+        for cookie in browser_cookie3.load(domain_name=".claude.ai"):
+            if cookie.name == "sessionKey" and cookie.value:
+                return cookie.value
+        raise RuntimeError("sessionKey cookie not found in browser")
+    except Exception as e:
+        raise RuntimeError(
+            "Failed to load browser cookies. "
+            + "Set CLAUDE_SESSION_KEY to your claude.ai sessionKey cookie."
+        ) from e
+
+
+async def _main() -> None:
+    def default(cls: type[Any], key: str) -> Any:
+        return cls.__dataclass_fields__[key].default
+
+    parser = ArgumentParser(
+        description="Backup Claude.ai chats",
+        formatter_class=ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "backup_dir",
+        nargs="?",
+        default=DefaultPath(user_data_dir("claude-backup")),
+        help="Directory to save backups",
+    )
+    parser.add_argument(
+        "-c",
+        "--connections",
+        type=int,
+        default=default(Syncer, "connections"),
+        help="Maximum concurrent connections",
+    )
+    parser.add_argument(
+        "-d",
+        "--success-delay",
+        type=float,
+        metavar="DELAY",
+        default=default(Syncer, "success_delay"),
+        help="Delay after successful request in seconds",
+    )
+    parser.add_argument(
+        "-r",
+        "--retries",
+        type=int,
+        default=default(Client, "retries"),
+        help="Number of retries for API requests",
+    )
+    parser.add_argument(
+        "--min-retry-delay",
+        type=float,
+        metavar="DELAY",
+        default=default(Client, "min_retry_delay"),
+        help="Minimum retry delay in seconds",
+    )
+    parser.add_argument(
+        "--max-retry-delay",
+        type=float,
+        metavar="DELAY",
+        default=default(Client, "max_retry_delay"),
+        help="Maximum retry delay in seconds",
+    )
+    parser.add_argument(
+        "--ignore-cache",
+        action="store_true",
+        help="Ignore local cache and re-fetch everything from API",
+    )
+
+    args = parser.parse_args()
+    if isinstance(args.backup_dir, DefaultPath):
+        args.backup_dir = args.backup_dir.path
+
+    store = Store(store_dir=Path(args.backup_dir), ignore_cache=args.ignore_cache)
+
+    session_key = os.environ.get("CLAUDE_SESSION_KEY") or get_session_key()
+    async with Client(
+        session_key=session_key,
+        retries=args.retries,
+        min_retry_delay=args.min_retry_delay,
+        max_retry_delay=args.max_retry_delay,
+    ) as client:
+        syncer = Syncer(
+            client=client,
+            store=store,
+            connections=args.connections,
+            success_delay=args.success_delay,
+        )
+        await syncer.sync_all()
+
+
+def main() -> None:
+    with suppress(KeyboardInterrupt):
+        asyncio.run(_main())
+
+
+if __name__ == "__main__":
+    main()

claude_backup/__main__.py

@@ -0,0 +1,4 @@
+from claude_backup import main
+
+if __name__ == "__main__":
+    main()

claude_backup-0.1.9.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: claude-backup
+Version: 0.1.9
+Summary: Unofficial, unsanctioned tool to backup Claude.ai chats to local files.
+Keywords: claude,backup,ai,chat,export,archive
+Author-email: Ultrathinkers Anonymous <ultrathink@twilligon.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-Expression: CC0-1.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+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
+Classifier: Topic :: System :: Archiving :: Backup
+Classifier: Topic :: Utilities
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: browser-cookie3
+Requires-Dist: fake-useragent
+Requires-Dist: platformdirs
+Requires-Dist: yarl
+Project-URL: Repository, https://github.com/twilligon/claude-backup
+
+# `claude-backup`
+
+Unofficial, unsanctioned tool to backup [Claude.ai](https://claude.ai) chats to local files.
+
+    uvx claude-backup
+
+## Features
+
+`claude-backup` creates a full local copy of all (text) content of all branches of all chats accessible to your [Claude.ai](https://claude.ai) account. If you are a member of multiple "organizations", it fetches chats from all of them. We preserve all metadata on chats and their provenance, including that of their parent organization and user. We automatically rename our local copies of chats and organizations to match their current names on `claude.ai`.
+
+We use an incremental sync algorithm to fetch only chats created or updated since the last backup. The fetch is done in parallel, with a typical user agent and polite rate and connection limits such that it's less traffic than manually scrolling through your chats and opening each in a new browser tab. I of course can't guarantee Big Claude won't be after you if you run this unofficial tool, but empirically they don't seem to mind.
+
+Chats are stored as their original API JSON with nice `find`able names and `grep`able contents:
+
+    $ CLAUDE_SESSION_KEY="$(wl-paste)" uvx claude-backup
+    Skipping organization twilligon (c8eaca6b-eddb-4bbc-9fe3-637a0574565f) without "chat" capability
+    Fetching chats for organization claude@twilligon.com's Organization (9e9a56fc-6d1c-4d62-a96d-0cff3a473cf0)
+    30ceebd6-afcc-4796-bb77-631069cd0696    Cadre versus posse comparison
+    d15ac7d6-f167-43d3-afac-fcfaaafb64ec    GraphQL database backends and data sources
+    3e553492-89a8-45e8-b51a-b2faf9dfde64    Japanese sword quality despite poor iron sources
+    040343e8-db5a-4031-a21a-be237a6c661a    Balisong pin and screw maintenance
+    08217feb-c912-40c2-9d14-f89784d61ab5    Fixing dry falafel centers
+    d41bf95e-8da1-47b3-af89-aecacd7770a6    Sleep Token's artistic merits
+    b10e02dd-479b-4714-9d99-264d6ef4ba75    Annual human steel consumption
+    608f7e3d-fbcc-4891-bf67-ebc9f15c7a01    Calling payphones from mobile devices
+    c56ad0c5-feae-4dae-bafc-784d1f46de29    Postfix security assessment
+    4553fae5-61a6-40fc-b95c-36c53e706614    App store review power dynamics for major companies
+    0b7f4ae8-ef57-4cac-8d47-7e4c5b0e5564    Exercise timing and sleep quality
+    6e5385c4-6ad4-4d46-ac20-dda2105a3bea    Scented neural networks with odor emissions
+    $ # ...and so on... time passes... then later:
+    $ CLAUDE_SESSION_KEY="$(wl-paste)" uvx claude-backup
+    Skipping organization twilligon (c8eaca6b-eddb-4bbc-9fe3-637a0574565f) without "chat" capability
+    Fetching chats for organization claude@twilligon.com's Organization (9e9a56fc-6d1c-4d62-a96d-0cff3a473cf0)
+    4ddbcc12-5cd8-4611-813a-befdedeb4b16    Smithsonian funding and government ownership
+    $ tree ~/.local/share/claude-backup | head -n15
+    ~/.local/share/claude-backup
+    ├── account.json
+    ├── organizations
+    │   └── claude@twilligon.com's_Organization-9e9a56fc-6d1c-4d62-a96d-0cff3a473cf0
+    │       ├── chat_conversations
+    │       │   ├── Free_Indirect_Discourse_Analysis-48d70be1-f23d-4757-9bcf-9d9d9711a3f6.json
+    │       │   ├── Fetty_Wap_name_origin-dc45880a-8c60-4366-b610-e4fe6bb9a65c.json
+    │       │   ├── Ryzen_Motherboard_PS_2_Port_Hunt-012583f0-83cc-4c18-8f8b-312c8cb856ac.json
+    │       │   ├── Tailscale_versus_wireguard_comparison-24ed7155-8d9e-410f-bf7c-cd3fb6cb4379.json
+    │       │   ├── Credit_card_companies_in_Europe-67ad5f75-80ba-4754-bc6c-7d21e98f948c.json
+    │       │   ├── OpenGL_and_Vulkan_Package_Compatibility-63859641-5ffe-459b-99b0-4759acdc8235.json
+    │       │   ├── Government_tech_capabilities_and_bureaucracy-1c0743f0-a124-456b-888f-d08c5b83923b.json
+    │       │   ├── Reverse_Engineering_Minified_JavaScript-8cf7cab1-9576-45d7-929a-ea34997b0061.json
+    │       │   ├── Wire_and_String_Mysteries-9ac747b7-f36e-4e86-9f24-377ab16fb5ec.json
+    │       │   ├── US_Senate_parliamentarian's_role_and_power-5fa34eb3-ac74-4683-8850-c90761e5f3d8.json
+    $ rg -0l falafel ~/.local/share/claude-backup/organizations/*/chat_conversations | xargs -0n1 basename
+    Fixing_dry_falafel_centers-08217feb-c912-40c2-9d14-f89784d61ab5.json
+    Best_falafel_restaurants_in_San_Francisco-76aa159a-e41a-4935-a2e5-d53465041e13.json
+    Rainy_day_food_delivery_dilemma-db4992e8-c69c-4085-a571-9a22dfff68da.json
+    Pita_Chip_Conversation_Search-059dca9c-bac3-4cd5-b405-34ddbbdd5fa8.json
+    $ rg -0l falafel ~/.local/share/claude-backup/organizations/*/chat_conversations | xargs -0 jq -r '"https://claude.ai/chat/\(.uuid)"'
+    https://claude.ai/chat/08217feb-c912-40c2-9d14-f89784d61ab5
+    https://claude.ai/chat/76aa159a-e41a-4935-a2e5-d53465041e13
+    https://claude.ai/chat/db4992e8-c69c-4085-a571-9a22dfff68da
+    https://claude.ai/chat/059dca9c-bac3-4cd5-b405-34ddbbdd5fa8
+
+## Limitations
+
+This read-only tool is the product of reverse-engineering Claude.ai's internal API (for Good, not Evil---please don't ban me Anthropic 🙏) so I can't make any guarantees `claude-backup` will continue to work. That said, we make very few assumptions about the API schema, and everything works as of 2025-10-31. I'll likely update this best-effort when things break. Barring that, PRs welcome ;)
+
+For reliable and comprehensive backups even through minor API changes, we save raw JSON responses from the API instead of normalizing them to some fixed schema. This should be a bit more resilient than forcing everything into some internal data model that could diverge from that of Claude.ai, but it means we don't download resources referenced by API objects other than what's necessary to list and fetch chat text. In practice, this preserves all textual message content and text/markdown attachments, but not images, PDFs, container uploads, "advanced research" reports, etc.
+
+As a backup tool, we **retain deleted chats** (and old branches of extant chats) by default. To delete local copies, manually delete the corresponding `.json` from `backup_dir` or start from scratch by deleting `backup_dir` or running `claude-backup --ignore-cache`.
+
+By default, `claude-backup` attempts to authenticate to `claude.ai` by extracting a session cookie from your browser. If this doesn't work (and frankly if this does work you should be sandboxing things better!) you must manually do the same. For Chrome et al., to https://claude.ai in your browser, open **Developer tools** with F12 or Ctrl+Shift+I, navigate to the **Application** tab (it may be hidden under **⋮** > **More tools** > **Application**), and copy the value of the `sessionKey` cookie. (Firefox should be [similar](https://firefox-source-docs.mozilla.org/devtools-user/storage_inspector/index.html).) Then set the `CLAUDE_SESSION_KEY` environment variable to this cookie when running `claude-backup`:
+
+    $ CLAUDE_SESSION_KEY="sk-ant-sid01-..." claude-backup
+
+As this tool demonstrates **anyone with this cookie is authenticated as you on `claude.ai`** so be careful and never give this to anyone or anything you do not trust! It might even be worth keeping out of `history` by loading it straight from your clipboard with e.g. `CLAUDE_SESSION_KEY="$(wl-paste)"`, though the exact command varies by platform. I'm sure Claude knows which you should use ;)
+
+As of recently(?) `claude.ai` is behind Cloudflare, and this no longer works great without VPNs. I swore to myself I was off the scrape-things-that-don't-want-to-be-scraped grind, so I recommend running `claude-backup` from a non-sus IP, bumping `--success-delay`, and lowering `--connections`. Any further workarounds are left as an exercise to the reader...
+
+## Install
+
+The blazing fast and memory safe way:
+
+    $ uvx claude-backup  # installed on demand
+
+The traditional way:
+
+    $ pip install claude-backup
+    $ claude-backup
+
+The bleeding-edge way:
+
+    $ git clone https://github.com/twilligon/claude-backup
+    $ cd claude-backup
+    $ python3 -m venv venv; . venv/bin/activate  # you probably want a venv
+    $ pip install -e .
+    $ claude-backup
+
+## Usage
+
+    $ claude-backup --help
+    usage: claude-backup [-h] [-v] [-c CONNECTIONS] [-d DELAY] [-r RETRIES]
+                         [--min-retry-delay DELAY] [--max-retry-delay DELAY]
+                         [--ignore-cache]
+                         [backup_dir]
+
+    Backup Claude.ai chats
+
+    positional arguments:
+      backup_dir            Directory to save backups (default:
+                            ~/.local/share/claude-backup)
+
+    options:
+      -h, --help            show this help message and exit
+      -v, --version         show program's version number and exit
+      -c, --connections CONNECTIONS
+                            Maximum concurrent connections (default: 6)
+      -d, --success-delay DELAY
+                            Delay after successful request in seconds (default:
+                            0.25)
+      -r, --retries RETRIES
+                            Number of retries for API requests (default: 10)
+      --min-retry-delay DELAY
+                            Minimum retry delay in seconds (default: 1.0)
+      --max-retry-delay DELAY
+                            Maximum retry delay in seconds (default: 60.0)
+      --ignore-cache        Ignore local cache and re-fetch everything from API
+                            (default: False)
+
+## License
+
+`claude-backup` is dedicated to the public domain where possible via CC0-1.0.
+
+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.
+

claude_backup-0.1.9.dist-info/RECORD

@@ -0,0 +1,7 @@
+claude_backup/__init__.py,sha256=MxtkapWnGhHrZ-tVu1JcCwoxrSFM27WS9e4wuutfKag,32040
+claude_backup/__main__.py,sha256=Fe20UD3aUiVzAXRjBrN-KNCrD7ZoX2BfTZbLymLPCMQ,70
+claude_backup-0.1.9.dist-info/entry_points.txt,sha256=j0WwAOxft9FrMp3E_A99dU5mxfPLS036JdRekd9_xm0,52
+claude_backup-0.1.9.dist-info/licenses/LICENSE,sha256=ogEPNDSH0_dhiv_lT3ifVIdgIzHAqNA_SemnxUfPBJk,7048
+claude_backup-0.1.9.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+claude_backup-0.1.9.dist-info/METADATA,sha256=uXlv_HWCLkUEdWzINcs4h_rzoMk4Z29Aca8OV66th0o,11049
+claude_backup-0.1.9.dist-info/RECORD,,

claude_backup-0.1.9.dist-info/WHEEL

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

claude_backup-0.1.9.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+claude-backup=claude_backup:main
+

claude_backup-0.1.9.dist-info/licenses/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.