toolframe-backup 0.1.0__py3-none-any.whl

toolframe_backup/plugin.py

@@ -0,0 +1,220 @@
+"""Scoped Backup catalog, Dashboard and read-only MCP declarations."""
+
+from __future__ import annotations
+
+from toolframe_sdk import (
+    AuthorizationSpec,
+    MethodSpec,
+    PluginDefinition,
+    Resource,
+    ScopeSpec,
+    ServiceSpec,
+)
+
+SERVICE_NAME = "backup.catalog"
+_ID = {"type": "string", "pattern": "^[0-9a-f]{32}$"}
+_HASH = {"type": "string", "pattern": "^[0-9a-f]{64}$"}
+_SUMMARY_PROPERTIES = {
+    "id": _ID,
+    "created_at": {"type": "string"},
+    "application_id": {"type": "string"},
+    "application_name": {"type": "string"},
+    "composition_revision": {"type": ["string", "null"]},
+    "file_count": {"type": "integer", "minimum": 0},
+    "total_bytes": {"type": "integer", "minimum": 0},
+    "archive_sha256": _HASH,
+    "verified": {"const": True},
+    "last_verified_at": {"type": "string"},
+}
+SUMMARY_SCHEMA = {
+    "type": "object",
+    "properties": _SUMMARY_PROPERTIES,
+    "required": list(_SUMMARY_PROPERTIES),
+    "additionalProperties": False,
+}
+
+
+def _input(properties: dict, required: tuple[str, ...] = ()) -> dict:
+    return {
+        "type": "object",
+        "properties": properties,
+        "required": list(required),
+        "additionalProperties": False,
+    }
+
+
+LIST_INPUT = _input(
+    {"limit": {"type": "integer", "minimum": 1, "maximum": 100, "default": 50}}
+)
+_LIST_PROPERTIES = {
+    "backups": {"type": "array", "items": SUMMARY_SCHEMA, "maxItems": 100},
+    "count": {"type": "integer", "minimum": 0, "maximum": 100},
+    "verified_count": {"type": "integer", "minimum": 0, "maximum": 1000},
+    "rejected_count": {"type": "integer", "minimum": 0, "maximum": 1000},
+    "rejected": {
+        "type": "array",
+        "maxItems": 100,
+        "items": {
+            "type": "object",
+            "properties": {"id": _ID, "error_code": {"type": "string"}},
+            "required": ["id", "error_code"],
+            "additionalProperties": False,
+        },
+    },
+    "limit": {"type": "integer", "minimum": 1, "maximum": 100},
+    "destination": {"type": "string"},
+    "destination_kind": {"const": "local"},
+    "retention_keep": {"type": "integer", "minimum": 1, "maximum": 1000},
+    "status": {"enum": ["ready", "destination_missing"]},
+    "guidance": {"type": "string"},
+}
+LIST_OUTPUT = {
+    "type": "object",
+    "properties": _LIST_PROPERTIES,
+    "required": list(_LIST_PROPERTIES),
+    "additionalProperties": False,
+}
+_PREVIEW_PROPERTIES = {
+    "plan_token": _HASH,
+    "expires_at": {"type": "string"},
+    "retention_keep": {"type": "integer", "minimum": 1, "maximum": 1000},
+    "eligible_count": {"type": "integer", "minimum": 0, "maximum": 1000},
+    "delete_count": {"type": "integer", "minimum": 0, "maximum": 100},
+    "delete": {"type": "array", "items": SUMMARY_SCHEMA, "maxItems": 100},
+    "remaining_count": {"type": "integer", "minimum": 0, "maximum": 1000},
+    "max_delete": {"type": "integer", "minimum": 1, "maximum": 100},
+    "preserved_rejected_count": {"type": "integer", "minimum": 0, "maximum": 1000},
+}
+PREVIEW_OUTPUT = {
+    "type": "object",
+    "properties": _PREVIEW_PROPERTIES,
+    "required": list(_PREVIEW_PROPERTIES),
+    "additionalProperties": False,
+}
+
+plugin = PluginDefinition(
+    id="backup",
+    factory="toolframe_backup.service:BackupPlugin",
+    authorization=AuthorizationSpec(
+        scopes={
+            "backup.read": ScopeSpec(title="Read the local Backup catalog"),
+        }
+    ),
+    config_schema={
+        "type": "object",
+        "properties": {
+            "destination": {
+                "type": "string",
+                "minLength": 1,
+                "description": "Operator-configured absolute local directory with mode 0700.",
+            },
+            "retention_keep": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 1000,
+                "default": 10,
+            },
+        },
+        "required": ["destination"],
+        "additionalProperties": False,
+    },
+    services={
+        SERVICE_NAME: ServiceSpec(
+            methods={
+                "list_backups": MethodSpec(
+                    audience="business",
+                    required_scopes=("backup.read",),
+                    description="List verified local recovery archives for this application. This does not snapshot a running application.",
+                    input_schema=LIST_INPUT,
+                    output_schema=LIST_OUTPUT,
+                    read_only=True,
+                ),
+                "verify_backup": MethodSpec(
+                    audience="system",
+                    required_scopes=("system.plugins.manage",),
+                    description="Recheck one configured archive's structure and checksums; hashes are not authentication signatures.",
+                    input_schema=_input({"backup_id": _ID}, ("backup_id",)),
+                    output_schema=SUMMARY_SCHEMA,
+                    read_only=True,
+                ),
+                "retention_preview": MethodSpec(
+                    audience="system",
+                    required_scopes=("system.plugins.manage",),
+                    description="Preview bounded deletion of this application's oldest verified archives without removing them.",
+                    input_schema=_input(
+                        {
+                            "max_delete": {
+                                "type": "integer",
+                                "minimum": 1,
+                                "maximum": 100,
+                                "default": 100,
+                            }
+                        }
+                    ),
+                    output_schema=PREVIEW_OUTPUT,
+                    read_only=True,
+                ),
+                "apply_retention": MethodSpec(
+                    audience="system",
+                    required_scopes=("system.plugins.manage",),
+                    description="Apply an unexpired unchanged retention preview after re-verification; unknown files are preserved.",
+                    input_schema=_input({"plan_token": _HASH}, ("plan_token",)),
+                    output_schema={
+                        "type": "object",
+                        "properties": {
+                            "deleted_ids": {
+                                "type": "array",
+                                "items": _ID,
+                                "maxItems": 100,
+                            },
+                            "deleted_count": {
+                                "type": "integer",
+                                "minimum": 0,
+                                "maximum": 100,
+                            },
+                        },
+                        "required": ["deleted_ids", "deleted_count"],
+                        "additionalProperties": False,
+                    },
+                ),
+            }
+        )
+    },
+    resources=(
+        Resource(
+            id="main",
+            kind="dashboard.page",
+            title="Backups",
+            required_scopes=("backup.read",),
+            data={"entrypoint": "toolframe_backup.page:render", "order": 40},
+        ),
+        Resource(
+            id="list_backups",
+            kind="mcp.tool",
+            title="List backups",
+            required_scopes=("backup.read",),
+            data={
+                "service": SERVICE_NAME,
+                "method": "list_backups",
+                "description": "Read the verified recovery archive catalog. Creating or restoring backups requires the stopped-application operator CLI.",
+                "input_schema": LIST_INPUT,
+                "output_schema": LIST_OUTPUT,
+            },
+        ),
+        Resource(
+            id="usage",
+            kind="llms.document",
+            title="Backup catalog and recovery workflow",
+            data={"package": "toolframe_backup", "path": "docs/usage.md"},
+        ),
+    ),
+)
+
+__all__ = [
+    "LIST_INPUT",
+    "LIST_OUTPUT",
+    "PREVIEW_OUTPUT",
+    "SERVICE_NAME",
+    "SUMMARY_SCHEMA",
+    "plugin",
+]

toolframe_backup/service.py

@@ -0,0 +1,105 @@
+"""Public SDK runtime facade for a local recovery archive catalog."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from toolframe_sdk import Plugin, PluginError
+
+from .archive import BackupError
+from .catalog import BackupCatalog
+
+SERVICE_NAME = "backup.catalog"
+_PARAMETERS = {
+    "list_backups": {"limit"},
+    "verify_backup": {"backup_id"},
+    "retention_preview": {"max_delete"},
+    "apply_retention": {"plan_token"},
+}
+
+
+class BackupPlugin(Plugin):
+    """Inspect archives only; application snapshots belong to the stopped CLI."""
+
+    def __init__(self, context):
+        super().__init__(context)
+        self.catalog: BackupCatalog | None = None
+
+    async def activate(self):
+        try:
+            self.catalog = await asyncio.to_thread(
+                BackupCatalog,
+                self.context.config.get("destination"),
+                retention_keep=self.context.config.get("retention_keep", 10),
+            )
+        except BackupError as error:
+            raise PluginError(error.code, error.message) from None
+
+    def _catalog(self) -> BackupCatalog:
+        if self.catalog is None:
+            raise PluginError(
+                "backup_not_ready", "Backup catalog has not been activated."
+            )
+        return self.catalog
+
+    def _application_id(self) -> str | None:
+        value = self.context.call_info.get("application_id")
+        return value if isinstance(value, str) and value else None
+
+    async def _run(self, function, *args, **kwargs):
+        try:
+            return await asyncio.to_thread(function, *args, **kwargs)
+        except BackupError as error:
+            raise PluginError(error.code, error.message) from None
+
+    async def list_backups(self, limit: int = 50) -> dict[str, Any]:
+        return await self._run(
+            self._catalog().list_backups,
+            limit,
+            application_id=self._application_id(),
+        )
+
+    async def verify_backup(self, backup_id: str) -> dict[str, Any]:
+        return await self._run(
+            self._catalog().verify,
+            backup_id,
+            application_id=self._application_id(),
+        )
+
+    async def retention_preview(self, max_delete: int = 100) -> dict[str, Any]:
+        return await self._run(
+            self._catalog().retention_preview,
+            max_delete,
+            application_id=self._application_id(),
+        )
+
+    async def apply_retention(self, plan_token: str) -> dict[str, Any]:
+        return await self._run(
+            self._catalog().apply_retention,
+            plan_token,
+            application_id=self._application_id(),
+        )
+
+    async def health(self):
+        if self.catalog is None:
+            return {"runtime": "not_ready", "business": "not_ready"}
+        await self._run(self.catalog._directory)
+        return {"runtime": "ready", "business": "ready"}
+
+    async def invoke(self, service: str, method: str, params: dict) -> Any:
+        if service != SERVICE_NAME or method not in _PARAMETERS:
+            raise PluginError("method_not_found", "Unknown Backup service method.")
+        if not isinstance(params, dict) or set(params) - _PARAMETERS[method]:
+            raise PluginError(
+                "backup_validation", "Backup method received unsupported parameters."
+            )
+        required = {"verify_backup": "backup_id", "apply_retention": "plan_token"}.get(
+            method
+        )
+        if required is not None and required not in params:
+            raise PluginError("backup_validation", f"{required} is required.")
+        return await getattr(self, method)(**params)
+
+
+__all__ = ["SERVICE_NAME", "BackupPlugin"]

toolframe_backup/zipguard.py

@@ -0,0 +1,178 @@
+"""Bound a ZIP central directory before the standard library allocates its index.
+
+Record layouts follow PKWARE APPNOTE sections 4.3.12 and 4.3.14–4.3.16:
+https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+This is the recovery archive's single-disk profile, not a general ZIP parser.
+Payload names, member types and checksums remain the archive verifier's job.
+"""
+
+from __future__ import annotations
+
+import os
+import struct
+from typing import BinaryIO
+
+_ERROR = "ZIP directory is invalid or exceeds supported bounds."
+_EOCD = struct.Struct("<4s4H2LH")
+_LOCATOR = struct.Struct("<4sLQL")
+_ZIP64 = struct.Struct("<4sQ2H2L4Q")
+_CENTRAL = struct.Struct("<4s6H3I5H2I")
+_TAIL_BYTES = _EOCD.size + 65535
+_ZIP64_BYTES = 1024
+_NAME_BYTES = 4096
+_SHORT_MAX = 0xFFFF
+_LONG_MAX = 0xFFFFFFFF
+
+
+def _reject() -> None:
+    raise ValueError(_ERROR)
+
+
+def _read_at(stream: BinaryIO, offset: int, size: int) -> bytes:
+    if offset < 0:
+        _reject()
+    stream.seek(offset)
+    value = stream.read(size)
+    if len(value) != size:
+        _reject()
+    return value
+
+
+def _directory(stream: BinaryIO, end: tuple, end_offset: int) -> tuple[int, int, int]:
+    _, disk, directory_disk, disk_count, count, size, offset, _ = end
+    requires_zip64 = (
+        disk == _SHORT_MAX
+        or directory_disk == _SHORT_MAX
+        or disk_count == _SHORT_MAX
+        or count == _SHORT_MAX
+        or size == _LONG_MAX
+        or offset == _LONG_MAX
+    )
+    locator_offset = end_offset - _LOCATOR.size
+    locator = (
+        _read_at(stream, locator_offset, _LOCATOR.size) if locator_offset >= 0 else b""
+    )
+    if not locator.startswith(b"PK\x06\x07"):
+        if requires_zip64 or disk != 0 or directory_disk != 0 or disk_count != count:
+            _reject()
+        directory_end = end_offset
+    else:
+        _, locator_disk, record_offset, total_disks = _LOCATOR.unpack(locator)
+        if (
+            locator_disk != 0
+            or total_disks != 1
+            or record_offset + _ZIP64.size > locator_offset
+        ):
+            _reject()
+        record = _ZIP64.unpack(_read_at(stream, record_offset, _ZIP64.size))
+        (
+            signature,
+            record_size,
+            _,
+            _,
+            disk64,
+            directory_disk64,
+            disk_count64,
+            count64,
+            size64,
+            offset64,
+        ) = record
+        if (
+            signature != b"PK\x06\x06"
+            or record_size < _ZIP64.size - 12
+            or record_size + 12 > _ZIP64_BYTES
+            or record_offset + record_size + 12 != locator_offset
+            or disk64 != 0
+            or directory_disk64 != 0
+            or disk_count64 != count64
+        ):
+            _reject()
+        for classic, extended, sentinel in (
+            (disk, disk64, _SHORT_MAX),
+            (directory_disk, directory_disk64, _SHORT_MAX),
+            (disk_count, disk_count64, _SHORT_MAX),
+            (count, count64, _SHORT_MAX),
+            (size, size64, _LONG_MAX),
+            (offset, offset64, _LONG_MAX),
+        ):
+            if classic != sentinel and classic != extended:
+                _reject()
+        count, size, offset = count64, size64, offset64
+        directory_end = record_offset
+    if offset + size != directory_end:
+        _reject()
+    return offset, size, count
+
+
+def _check(stream: BinaryIO, max_members: int, max_directory_bytes: int) -> None:
+    stream.seek(0, os.SEEK_END)
+    file_size = stream.tell()
+    if file_size < _EOCD.size:
+        _reject()
+    tail_size = min(file_size, _TAIL_BYTES)
+    tail_offset = file_size - tail_size
+    tail = _read_at(stream, tail_offset, tail_size)
+    relative_end = tail.rfind(b"PK\x05\x06")
+    if relative_end < 0 or relative_end + _EOCD.size > tail_size:
+        _reject()
+    end = _EOCD.unpack_from(tail, relative_end)
+    if relative_end + _EOCD.size + end[-1] != tail_size:
+        _reject()
+    offset, size, count = _directory(stream, end, tail_offset + relative_end)
+    if (
+        count > max_members
+        or size > max_directory_bytes
+        or count * _CENTRAL.size > size
+    ):
+        _reject()
+    central_end = offset + size
+    position, actual = offset, 0
+    while position < central_end:
+        if (
+            position + _CENTRAL.size > central_end
+            or actual >= max_members
+            or actual >= count
+        ):
+            _reject()
+        header = _CENTRAL.unpack(_read_at(stream, position, _CENTRAL.size))
+        name_size, extra_size, comment_size, disk = header[10:14]
+        if header[0] != b"PK\x01\x02" or disk != 0 or not 1 <= name_size <= _NAME_BYTES:
+            _reject()
+        next_position = position + _CENTRAL.size + name_size + extra_size + comment_size
+        if next_position > central_end:
+            _reject()
+        position = next_position
+        actual += 1
+    if position != central_end or actual != count:
+        _reject()
+
+
+def check_zip_directory(
+    stream: BinaryIO, *, max_members: int, max_directory_bytes: int
+) -> None:
+    """Check directory bounds with fixed-size reads and preserve stream position.
+
+    ZIP64 records are supported; split archives, unrecognized directory records,
+    trailing data and inconsistent declarations are rejected. Every invalid
+    header or bound uses one fixed error string, without archive metadata.
+    """
+    if (
+        type(max_members) is not int
+        or type(max_directory_bytes) is not int
+        or max_members < 0
+        or max_directory_bytes < 0
+    ):
+        _reject()
+    try:
+        original = stream.tell()
+    except OSError, ValueError:
+        raise ValueError(_ERROR) from None
+    try:
+        _check(stream, max_members, max_directory_bytes)
+    except OSError, ValueError, struct.error, OverflowError:
+        raise ValueError(_ERROR) from None
+    finally:
+        try:
+            stream.seek(original)
+        except OSError, ValueError:
+            raise ValueError(_ERROR) from None

toolframe_backup-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.5
+Name: toolframe-backup
+Version: 0.1.0
+Summary: Stopped-application recovery archives and a local Backup catalog for Toolframe
+Project-URL: Homepage, https://github.com/toolframe/toolframe-backup
+Project-URL: Repository, https://github.com/toolframe/toolframe-backup
+Project-URL: Documentation, https://github.com/toolframe/toolframe-backup#readme
+Project-URL: Issues, https://github.com/toolframe/toolframe-backup/issues
+Author-email: byfb <62798989+byfb@users.noreply.github.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.14
+Requires-Dist: packaging>=25
+Requires-Dist: tomlkit<1,>=0.13
+Requires-Dist: toolframe-sdk==0.3.0
+Provides-Extra: operator
+Requires-Dist: toolframe-core<0.7,>=0.6; extra == 'operator'
+Provides-Extra: ui
+Requires-Dist: streamlit==1.61.0; extra == 'ui'
+Description-Content-Type: text/markdown
+
+# Toolframe Backup
+
+Toolframe Backup creates recovery archives of cleanly stopped Toolframe applications
+and provides a Dashboard and read-only MCP catalog for a configured local backup
+directory. Its standalone CLI can verify or restore archives even when the source
+application cannot start. The ordinary plugin never snapshots a running application.
+
+## Quick start
+
+Use Python 3.14 or newer. Archive creation
+requires a Core release providing `toolframe_core.maintenance.stopped_application`.
+Restoring recorded environments also requires its public `application_lock` helper.
+Install the operator extra from PyPI:
+
+```sh
+uv venv --python 3.14
+uv pip install 'toolframe-backup[operator]==0.1.0'
+# Stop the application's host and workers cleanly before creating the archive.
+.venv/bin/toolframe-backup create --home ./app --directory ./backups
+.venv/bin/toolframe-backup list --directory ./backups
+.venv/bin/toolframe-backup verify ./backups/backup-<id>.zip
+.venv/bin/toolframe-backup restore ./backups/backup-<id>.zip --destination ./recovered-app
+# Optional local-only reconstruction (requires every exact-hash dependency locally):
+.venv/bin/toolframe-backup restore ./backups/backup-<id>.zip --destination ./offline-recovered-app --offline --wheelhouse ./wheelhouse
+```
+
+The CLI prints nonsecret JSON summaries; errors use exit code 2 and interruption
+uses 130. New backup directories and restored directories have mode 0700. Archive
+files and restored payload files have mode 0600; uv sets reconstructed environment
+file modes. Existing backup directories must already have
+mode 0700. Restore requires a new destination with an existing parent directory;
+it never replaces an existing home, including an empty directory.
+Supported restore paths include spaces and Unicode. Paths containing quotes,
+backslashes or control characters are rejected before staging.
+File URI wheel locators encode spaces, Unicode and URI delimiters such as `#`, `?`
+and `%`; direct wheel paths retain their filesystem spelling.
+
+To install the catalog in an existing application, declare the plugin and its
+required destination together in `app/toolframe.toml`. Core resolves the package
+from PyPI; replace the destination with your operator-owned absolute backup path:
+
+```toml
+[plugins.backup]
+source = "pypi:toolframe-backup==0.1.0"
+enabled = true
+
+[plugins.backup.config]
+destination = "/srv/toolframe-backups"
+retention_keep = 10
+```
+
+```sh
+toolframe-core --home ./app plan
+toolframe-core --home ./app apply --plan-id <plan-id-from-the-plan-output>
+```
+
+An installed Dashboard or MCP provider consumes the plugin's ordinary resources.
+Grant `backup.read` to catalog readers. Verification and retention actions require
+the built-in `system.plugins.manage` (Manage plugins) operator permission.
+See the [catalog guide](src/toolframe_backup/docs/usage.md) for its service methods,
+verification records and explicit retention workflow.
+
+## Support limits
+
+- Version 1 supports local in-home files and local SQLite stores accepted by Core's
+  stopped maintenance inventory. Live or uncertain workers, pending recovery,
+  external SQL and external attachments are rejected by Core. S3 and other remote
+  archive destinations are not implemented.
+- Archives are **unencrypted** and contain private keys, configuration and database
+  contents in their payloads. Store them in an operator-controlled local directory.
+  The public manifest contains identity, hashes, store ownership, retained-key
+  requirements and dependency prerequisites, without credential URLs or key bytes.
+- SHA-256 checks detect corruption. They are not signatures and do not authenticate
+  an archive against an attacker who can replace both payload and manifest.
+- Offline means the source host is stopped and the CLI needs no running application.
+  Restore reconstructs omitted backend/UI environments with uv from protected original
+  exact pylocks before reporting `ready: true`. It uses the final absolute directory
+  under Core's public application lock so console-script shebangs remain valid. Missing
+  dependency wheels require exact-hash wheels from a supplied wheelhouse or network;
+  an air-gapped restart is not guaranteed. uv performs locked dependency acquisition;
+  the CLI has no independent downloader. `--offline` forbids network acquisition and
+  `--wheelhouse` supplies local candidate wheels. Recovery requires the original Python
+  implementation, OS and machine architecture. A recorded two-component Python
+  version requires the same major/minor; a recorded three-component version requires
+  the exact patch too. The complete operator interpreter is checked against
+  Requires-Python, environment markers and wheel tags before publication. Reconstruction
+  requires compatible exact-hash wheels and supports at most 100 distinct environments;
+  source builds are disabled. Subprocess output is suppressed to protect credentials.
+  A failed reconstruction removes only the new destination created by that restore.
+- A recovered clone retains the application ID and composition. Do not concurrently
+  run it with another copy using the same external identity. External state is outside
+  the supported recovery scope.
+- Atomic restoration is supported on macOS and Linux. Default limits are 10,000
+  files, 512 MiB per payload file, 2 GiB total payload, 4 MiB manifest, 3 GiB archive,
+  16 MiB protected environment payload and a maximum decompression ratio of 200.
+  ZIP central-directory size/count are checked before indexing. The catalog scans at
+  most 1,000 archives.
+
+See the [archive architecture](docs/architecture.md) and
+[offline recovery decision](docs/adr/0001-stopped-recovery-and-directory-catalog.md).
+
+## Development
+
+Place the immutable matching Toolframe wheel set, including SDK, Core and their
+prerequisites, in `build/wheelhouse/` before syncing. The Core wheel must provide the public
+maintenance helpers used above. This library omits a committed `uv.lock` and
+sibling source pins; development resolves dependencies from supplied or published
+wheels.
+
+```sh
+uv sync --no-sources --find-links ./build/wheelhouse --extra operator --extra ui --group dev
+uv run --no-sync pytest
+uv run --no-sync ruff check .
+uv run --no-sync ruff format --check .
+uv build
+```
+
+Package tests cover archive boundaries with mocked Core inventories and guards, and
+include real offline uv reconstruction of local environments in temporary homes.
+Verify stopped-state eligibility, the actual Core lock and restored application,
+Dashboard and client flows separately through an installed application. Package tests
+do not establish remote-store or air-gap support.
+
+Licensed under [Apache-2.0](LICENSE).
+
+For release validation and Trusted Publisher setup, see [releasing](docs/releasing.md).

toolframe_backup-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+toolframe_backup/__init__.py,sha256=hrwz_zbpIDhpryFAChszK__fp1mxXaGG9djecoY8EJM,86
+toolframe_backup/archive.py,sha256=JdrqAlkdxkXPBJjf0DCjZOg84z7UCvSwgSXy4QKeA9k,34573
+toolframe_backup/catalog.py,sha256=mcPrFzAva5ZzZpmJ47UHNnBD005olIVfVvLBi23BeD4,19969
+toolframe_backup/cli.py,sha256=GnNAZavnjaxw-66ZJ9m7cNe-aLIhuRADKtUPlcGyOmI,2899
+toolframe_backup/environments.py,sha256=UzFFVzH_BbbSO5fF54tvrKSzPQWN2SNLvmGBp8MsBEA,18437
+toolframe_backup/page.py,sha256=BrGui6hEU-HKDvqzHQS49_1Br7eKHJTWDq6KdQ4pgQk,5867
+toolframe_backup/plugin.py,sha256=Y2vH512wHRNt83TaL0rMR3DPV8sdVhlZmuRaSVAtvig,7982
+toolframe_backup/service.py,sha256=mdfC2MguLPQJ_3bnr2rikSNVwhoBLJvBM5U3PAUBUjU,3660
+toolframe_backup/zipguard.py,sha256=RDeHfaGpChgm2x_ccd3emRBY_7vqfY9g9Zll1rNQ-ZQ,5953
+toolframe_backup/docs/usage.md,sha256=biQ6FjzQTvz4X9JxWz6Oeb1Z35-30PKPQwa7M_Z6zvE,5048
+toolframe_backup-0.1.0.dist-info/METADATA,sha256=lH0aH4HTESAsL3-CQK3MkfRItkOtgpoVto5OyZ2Ud4g,7665
+toolframe_backup-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+toolframe_backup-0.1.0.dist-info/entry_points.txt,sha256=0228ZdqwBLjQfriPzzCM-O5J4BUygRM3gSxqQzb29QM,124
+toolframe_backup-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+toolframe_backup-0.1.0.dist-info/licenses/NOTICE,sha256=-dYs0ndUSVr_LbH0NzVNGZsplU2xvVrlDOA4PmjiR84,104
+toolframe_backup-0.1.0.dist-info/RECORD,,

toolframe_backup-0.1.0.dist-info/WHEEL

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

toolframe_backup-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+toolframe-backup = toolframe_backup.cli:main
+
+[toolframe.plugins]
+backup = toolframe_backup.plugin:plugin