dockerhub-api 0.1.0__py3-none-any.whl

dockerhub_api/mcp/mcp_repos.py

@@ -0,0 +1,58 @@
+"""MCP tool for Docker Hub repositories and tags.
+
+CONCEPT:HUB-1.4 — action-routed MCP surface.
+"""
+
+from typing import Any
+
+from fastmcp import Context, FastMCP
+from fastmcp.dependencies import Depends
+from pydantic import Field
+
+from dockerhub_api.mcp import get_hub_client, parse_params, redact_secrets, run_action
+
+
+def register_repos_tools(mcp: FastMCP):
+    @mcp.tool(tags={"repositories"})
+    async def hub_repos(
+        action: str = Field(
+            description=(
+                "Action to perform. Must be one of: 'list', 'create', 'get', "
+                "'check', 'list_tags', 'check_tags', 'get_tag', 'check_tag', "
+                "'set_immutable_tags', 'verify_immutable_tags', 'assign_group'"
+            )
+        ),
+        params_json: str = Field(
+            default="{}", description="JSON string of parameters to pass to the action."
+        ),
+        client=Depends(get_hub_client),
+        ctx: Context | None = Field(
+            default=None, description="MCP context for progress reporting"
+        ),
+    ) -> Any:
+        """Manage Docker Hub repositories: list/create/inspect repositories,
+        browse tags, configure and verify immutable tags, and grant teams
+        repository permissions. Repository creation is the primary release
+        provisioning path and is allowed by default.
+        """
+        if ctx:
+            await ctx.info("Executing tool...")
+        try:
+            kwargs = parse_params(params_json)
+        except Exception as e:
+            return {"error": f"Invalid params_json: {e}"}
+
+        handlers = {
+            "list": client.get_repositories,
+            "create": client.create_repository,
+            "get": client.get_repository,
+            "check": client.check_repository,
+            "list_tags": client.get_repository_tags,
+            "check_tags": client.check_repository_tags,
+            "get_tag": client.get_repository_tag,
+            "check_tag": client.check_repository_tag,
+            "set_immutable_tags": client.update_immutable_tags,
+            "verify_immutable_tags": client.verify_immutable_tags,
+            "assign_group": client.assign_repository_group,
+        }
+        return redact_secrets(run_action(handlers, action, kwargs))

dockerhub_api/mcp/mcp_scim.py

@@ -0,0 +1,56 @@
+"""MCP tool for Docker Hub SCIM 2.0 provisioning.
+
+CONCEPT:HUB-1.4 — action-routed MCP surface.
+CONCEPT:HUB-1.5 — SCIM provisioning.
+"""
+
+from typing import Any
+
+from fastmcp import Context, FastMCP
+from fastmcp.dependencies import Depends
+from pydantic import Field
+
+from dockerhub_api.mcp import get_hub_client, parse_params, redact_secrets, run_action
+
+
+def register_scim_tools(mcp: FastMCP):
+    @mcp.tool(tags={"scim"})
+    async def hub_scim(
+        action: str = Field(
+            description=(
+                "Action to perform. Must be one of: 'service_provider_config', "
+                "'resource_types', 'resource_type', 'schemas', 'schema', "
+                "'list_users', 'get_user', 'create_user', 'update_user'"
+            )
+        ),
+        params_json: str = Field(
+            default="{}", description="JSON string of parameters to pass to the action."
+        ),
+        client=Depends(get_hub_client),
+        ctx: Context | None = Field(
+            default=None, description="MCP context for progress reporting"
+        ),
+    ) -> Any:
+        """Docker Hub SCIM 2.0: service discovery (ServiceProviderConfig,
+        ResourceTypes, Schemas) and user provisioning (list with
+        startIndex/count/filter/sortBy/sortOrder, get, create, replace).
+        """
+        if ctx:
+            await ctx.info("Executing tool...")
+        try:
+            kwargs = parse_params(params_json)
+        except Exception as e:
+            return {"error": f"Invalid params_json: {e}"}
+
+        handlers = {
+            "service_provider_config": client.get_scim_service_provider_config,
+            "resource_types": client.get_scim_resource_types,
+            "resource_type": client.get_scim_resource_type,
+            "schemas": client.get_scim_schemas,
+            "schema": client.get_scim_schema,
+            "list_users": client.get_scim_users,
+            "get_user": client.get_scim_user,
+            "create_user": client.create_scim_user,
+            "update_user": client.replace_scim_user,
+        }
+        return redact_secrets(run_action(handlers, action, kwargs))

dockerhub_api/mcp/mcp_teams.py

@@ -0,0 +1,55 @@
+"""MCP tool for Docker Hub groups (teams) and their membership.
+
+CONCEPT:HUB-1.4 — action-routed MCP surface.
+"""
+
+from typing import Any
+
+from fastmcp import Context, FastMCP
+from fastmcp.dependencies import Depends
+from pydantic import Field
+
+from dockerhub_api.mcp import get_hub_client, parse_params, redact_secrets, run_action
+
+
+def register_teams_tools(mcp: FastMCP):
+    @mcp.tool(tags={"teams"})
+    async def hub_teams(
+        action: str = Field(
+            description=(
+                "Action to perform. Must be one of: 'list', 'create', 'get', "
+                "'update', 'patch', 'delete', 'list_members', 'add_member', "
+                "'remove_member'"
+            )
+        ),
+        params_json: str = Field(
+            default="{}", description="JSON string of parameters to pass to the action."
+        ),
+        client=Depends(get_hub_client),
+        ctx: Context | None = Field(
+            default=None, description="MCP context for progress reporting"
+        ),
+    ) -> Any:
+        """Manage Docker Hub organization groups (teams) and their members.
+        Group deletion and member removal require
+        DOCKERHUB_ALLOW_DESTRUCTIVE=True.
+        """
+        if ctx:
+            await ctx.info("Executing tool...")
+        try:
+            kwargs = parse_params(params_json)
+        except Exception as e:
+            return {"error": f"Invalid params_json: {e}"}
+
+        handlers = {
+            "list": client.get_groups,
+            "create": client.create_group,
+            "get": client.get_group,
+            "update": client.update_group,
+            "patch": client.patch_group,
+            "delete": client.delete_group,
+            "list_members": client.get_group_members,
+            "add_member": client.add_group_member,
+            "remove_member": client.remove_group_member,
+        }
+        return redact_secrets(run_action(handlers, action, kwargs))

dockerhub_api/mcp_config.json

@@ -0,0 +1,3 @@
+{
+  "mcpServers": {}
+}

dockerhub_api/mcp_server.py

@@ -0,0 +1,109 @@
+#!/usr/bin/python
+"""Docker Hub MCP server entry point.
+
+CONCEPT:HUB-1.4 — action-routed MCP surface. Registers the consolidated,
+togglable tool modules (hub_auth, hub_repos, hub_org, hub_teams, hub_audit,
+hub_scim, hub_admin) on an agent-utilities FastMCP server.
+"""
+
+import warnings
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+
+warnings.filterwarnings("ignore", message=".*urllib3.*or chardet.*")
+warnings.filterwarnings("ignore", message=".*urllib3.*or charset_normalizer.*")
+
+import logging
+import os
+import sys
+from typing import Any
+
+from agent_utilities.base_utilities import to_boolean
+from agent_utilities.mcp_utilities import create_mcp_server
+from dotenv import find_dotenv, load_dotenv
+from fastmcp.utilities.logging import get_logger
+
+from dockerhub_api.mcp import (
+    register_admin_tools,
+    register_audit_tools,
+    register_auth_tools,
+    register_org_tools,
+    register_repos_tools,
+    register_scim_tools,
+    register_teams_tools,
+)
+
+__version__ = "0.1.0"
+print(f"Docker Hub MCP v{__version__}", file=sys.stderr)
+
+logger = get_logger(name="mcp_server")
+logger.setLevel(logging.DEBUG)
+
+DEFAULT_DOCKERHUB_SSL_VERIFY = to_boolean(
+    string=os.getenv("DOCKERHUB_SSL_VERIFY", "True")
+)
+DEFAULT_DOCKERHUB_URL = os.getenv("DOCKERHUB_URL", "https://hub.docker.com")
+DEFAULT_DOCKERHUB_TOKEN = os.getenv("DOCKERHUB_TOKEN", None)
+
+#: (env toggle, register function) — every consolidated tool module.
+TOOL_REGISTRY = (
+    ("AUTHTOOL", register_auth_tools),
+    ("REPOSTOOL", register_repos_tools),
+    ("ORGTOOL", register_org_tools),
+    ("TEAMSTOOL", register_teams_tools),
+    ("AUDITTOOL", register_audit_tools),
+    ("SCIMTOOL", register_scim_tools),
+    ("ADMINTOOL", register_admin_tools),
+)
+
+
+def get_mcp_instance() -> tuple[Any, Any, Any, Any]:
+    """Initialize and return the Docker Hub MCP instance, args, and middlewares."""
+    load_dotenv(find_dotenv())
+    os.environ["FASTMCP_LOG_LEVEL"] = "ERROR"
+    os.environ["TERM"] = "dumb"
+    os.environ["NO_COLOR"] = "1"
+
+    args, mcp, middlewares = create_mcp_server(
+        name="DockerHub",
+        version=__version__,
+        instructions=(
+            "Docker Hub API MCP Server - Manage repositories, tags, access "
+            "tokens, organizations, teams, audit logs, and SCIM provisioning."
+        ),
+    )
+
+    registered_tags: list[str] = []
+    for toggle, register in TOOL_REGISTRY:
+        if to_boolean(string=os.getenv(toggle, "True")):
+            register(mcp)
+            registered_tags.append(toggle)
+
+    for mw in middlewares:
+        mcp.add_middleware(mw)
+
+    return mcp, args, middlewares, registered_tags
+
+
+def mcp_server() -> None:
+    mcp, args, middlewares, registered_tags = get_mcp_instance()
+    print(f"{'dockerhub-api'} MCP v{__version__}", file=sys.stderr)
+    print("\nStarting MCP Server", file=sys.stderr)
+    print(f"  Transport: {args.transport.upper()}", file=sys.stderr)
+    print(f"  Auth: {args.auth_type}", file=sys.stderr)
+    print(f"  Dynamic Tags Loaded: {len(set(registered_tags))}", file=sys.stderr)
+
+    if args.transport == "stdio":
+        mcp.run(transport="stdio")
+    elif args.transport == "streamable-http":
+        mcp.run(transport="streamable-http", host=args.host, port=args.port)
+    elif args.transport == "sse":
+        mcp.run(transport="sse", host=args.host, port=args.port)
+    else:
+        logger.error("Invalid transport", extra={"transport": args.transport})
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    mcp_server()

dockerhub_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: dockerhub-api
+Version: 0.1.0
+Summary: Docker Hub API + MCP Server + A2A Server
+Author-email: Audel Rouhi <knucklessg1@gmail.com>
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: <3.15,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agent-utilities>=0.47.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: mcp
+Requires-Dist: agent-utilities[mcp]>=0.47.0; extra == "mcp"
+Provides-Extra: agent
+Requires-Dist: agent-utilities[agent,logfire]>=0.47.0; extra == "agent"
+Provides-Extra: all
+Requires-Dist: dockerhub-api[agent,logfire,mcp]>=0.1.0; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest-xdist>=3.6.0; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# Dockerhub Api
+## CLI or API | MCP | Agent
+
+![PyPI - Version](https://img.shields.io/pypi/v/dockerhub-api)
+![MCP Server](https://badge.mcpx.dev?type=server 'MCP Server')
+![PyPI - Downloads](https://img.shields.io/pypi/dd/dockerhub-api)
+![GitHub Repo stars](https://img.shields.io/github/stars/Knuckles-Team/dockerhub-api)
+![PyPI - License](https://img.shields.io/pypi/l/dockerhub-api)
+![GitHub last commit (by committer)](https://img.shields.io/github/last-commit/Knuckles-Team/dockerhub-api)
+![GitHub issues](https://img.shields.io/github/issues/Knuckles-Team/dockerhub-api)
+![GitHub top language](https://img.shields.io/github/languages/top/Knuckles-Team/dockerhub-api)
+![GitHub repo size](https://img.shields.io/github/repo-size/Knuckles-Team/dockerhub-api)
+![PyPI - Wheel](https://img.shields.io/pypi/wheel/dockerhub-api)
+![PyPI - Implementation](https://img.shields.io/pypi/implementation/dockerhub-api)
+
+*Version: 0.1.0*
+
+> **Documentation** — Installation, deployment, usage across the API, CLI, and MCP
+> interfaces, the integrated A2A agent server, and guidance on the backing
+> Docker Hub platform are maintained in [docs/](docs/index.md).
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Key Features](#key-features)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Python API / CLI](#python-api--cli)
+  - [MCP](#mcp)
+  - [Agent (A2A)](#agent-a2a)
+- [Environment Variables](#environment-variables)
+- [Deployment](#deployment)
+- [Safety Model](#safety-model)
+- [Concepts](#concepts)
+- [License](#license)
+
+---
+
+## Overview
+
+**Dockerhub Api** is a production-grade Agent and Model Context Protocol (MCP) server
+that wraps the official **Docker Hub API v2** (`https://hub.docker.com`): repositories
+and tags, immutable tags, personal and organization access tokens, organization
+members/settings/invites, teams, audit logs, and SCIM 2.0 provisioning.
+
+---
+
+## Key Features
+
+- **Consolidated Action-Routed MCP Tools:** Seven togglable tool modules
+  (`hub_auth`, `hub_repos`, `hub_org`, `hub_teams`, `hub_audit`, `hub_scim`,
+  `hub_admin`) minimize token overhead in LLM contexts.
+- **JWT Auth Lifecycle:** Short-lived bearer minted from `POST /v2/auth/token`
+  (password, PAT `dckr_pat_*`, or org access token), cached and refreshed before
+  expiry, with one transparent re-mint on 401.
+- **Rate-Limit Telemetry:** `X-RateLimit-*` headers surfaced in every result;
+  HTTP 429 retried with bounded `Retry-After` backoff.
+- **Safety by Default:** Deletes and org-settings writes are gated behind
+  `DOCKERHUB_ALLOW_DESTRUCTIVE` (default `False`); secrets are redacted from tool
+  results (plaintext tokens appear exactly once — on creation). Repository creation
+  stays enabled: it is the primary release-provisioning use case.
+- **Integrated Graph Agent:** Built-in Pydantic AI agent (`dockerhub-agent`) with
+  A2A and AG-UI web interfaces.
+- **Native Telemetry & Tracing:** Out-of-the-box OpenTelemetry exports and Langfuse
+  tracing via agent-utilities.
+
+---
+
+## Installation
+
+```bash
+pip install dockerhub-api            # API client only
+pip install "dockerhub-api[mcp]"     # + MCP server
+pip install "dockerhub-api[agent]"   # + A2A agent server
+pip install "dockerhub-api[all]"     # everything
+```
+
+| Extra | Adds |
+|---|---|
+| `mcp` | FastMCP server (`dockerhub-mcp`) via `agent-utilities[mcp]` |
+| `agent` | Pydantic-AI A2A agent (`dockerhub-agent`) + Logfire via `agent-utilities[agent,logfire]` |
+| `all` | `mcp` + `agent` |
+| `test` | pytest toolchain for development |
+
+Or pull the published image:
+
+```bash
+docker pull knucklessg1/dockerhub-api:latest
+```
+
+---
+
+## Usage
+
+### Python API / CLI
+
+```python
+from dockerhub_api.auth import get_client
+
+api = get_client()   # reads DOCKERHUB_URL / DOCKER_HUB_USER / DOCKER_HUB_TOKEN
+
+repos = api.get_repositories(namespace="acme", ordering="-last_updated")
+api.create_repository(namespace="acme", name="release-images", is_private=True)
+tags = api.get_repository_tags(namespace="acme", repository="release-images")
+print(api.rate_limit)   # latest X-RateLimit-* snapshot
+```
+
+Every client method returns a uniform envelope:
+`{"status_code": int, "data": ..., "rate_limit": {"limit", "remaining", "reset"}}`.
+
+### MCP
+
+#### Available MCP Tools
+
+| Tool Module | Toggle Env Var | Enabled by Default | Description & Nested Actions |
+|---|---|---|---|
+| `hub_auth` | `AUTHTOOL` | True | Token lifecycle: `create_token`, `login` (deprecated), `two_factor_login`, `list_pats`, `create_pat`, `get_pat`, `update_pat`, `delete_pat`, `list_oats`, `create_oat`, `get_oat`, `update_oat`, `delete_oat` |
+| `hub_repos` | `REPOSTOOL` | True | Repositories & tags: `list`, `create`, `get`, `check`, `list_tags`, `check_tags`, `get_tag`, `check_tag`, `set_immutable_tags`, `verify_immutable_tags`, `assign_group` |
+| `hub_org` | `ORGTOOL` | True | Org admin: `get_settings`, `update_settings`, `list_members`, `export_members`, `update_member`, `remove_member`, `list_invites`, `delete_invite`, `resend_invite`, `bulk_invite` |
+| `hub_teams` | `TEAMSTOOL` | True | Teams: `list`, `create`, `get`, `update`, `patch`, `delete`, `list_members`, `add_member`, `remove_member` |
+| `hub_audit` | `AUDITTOOL` | True | Audit trail: `logs`, `actions` |
+| `hub_scim` | `SCIMTOOL` | True | SCIM 2.0: `service_provider_config`, `resource_types`, `resource_type`, `schemas`, `schema`, `list_users`, `get_user`, `create_user`, `update_user` |
+| `hub_admin` | `ADMINTOOL` | True | Diagnostics: `rate_limit`, `whoami` (local JWT introspection) |
+
+Run the server:
+
+```bash
+export DOCKER_HUB_USER=youruser
+export DOCKER_HUB_TOKEN=dckr_pat_xxx
+dockerhub-mcp --transport streamable-http --host 0.0.0.0 --port 8000
+```
+
+### Agent (A2A)
+
+```bash
+dockerhub-agent --mcp-url http://localhost:8000/mcp --web
+```
+
+---
+
+## Environment Variables
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `DOCKERHUB_URL` | `https://hub.docker.com` | Docker Hub API base URL |
+| `DOCKER_HUB_USER` | — | Account identifier (official hub-tool name, primary) |
+| `DOCKER_HUB_TOKEN` | — | Password, PAT `dckr_pat_*`, or org access token (primary) |
+| `DOCKERHUB_USERNAME` / `DOCKERHUB_TOKEN` | — | Legacy fallback aliases for the two above |
+| `DOCKERHUB_JWT` | — | Optional pre-minted bearer (overrides credential exchange) |
+| `DOCKERHUB_SSL_VERIFY` | `True` | TLS certificate verification |
+| `DOCKERHUB_ALLOW_DESTRUCTIVE` | `False` | Enable deletes and org-settings writes |
+| `AUTHTOOL` … `ADMINTOOL` | `True` | Per-module MCP tool toggles (see table above) |
+| `HOST` / `PORT` / `TRANSPORT` | `0.0.0.0` / `8000` / `stdio` | MCP server bind & transport (`stdio`, `streamable-http`, `sse`) |
+| `AUTH_TYPE` | `none` | MCP server auth mode (Docker image) |
+| `MCP_URL` | — | MCP endpoint the A2A agent connects to |
+| `ENABLE_OTEL` | `True` | OpenTelemetry / Langfuse export via agent-utilities |
+| `EUNOMIA_TYPE` / `EUNOMIA_POLICY_FILE` / `EUNOMIA_REMOTE_URL` | `none` / `mcp_policies.json` / — | Eunomia access-governance middleware |
+| `FASTMCP_LOG_LEVEL` / `NO_COLOR` | — | FastMCP logging controls |
+
+A complete annotated template lives in [.env.example](.env.example).
+
+---
+
+## Deployment
+
+Docker Compose definitions ship in [docker/](docker/):
+
+```bash
+cp .env.example .env       # fill in DOCKER_HUB_USER / DOCKER_HUB_TOKEN
+docker compose -f docker/mcp.compose.yml up -d     # MCP server only
+docker compose -f docker/agent.compose.yml up -d   # MCP server + A2A agent (port 9018)
+```
+
+Both services expose `/health` endpoints; see
+[docs/deployment.md](docs/deployment.md) for transports, Caddy ingress, and
+Technitium DNS guidance.
+
+---
+
+## Safety Model
+
+| Operation class | Default | Override |
+|---|---|---|
+| Reads (repos, tags, members, logs, SCIM) | allowed | — |
+| Repository create / immutable-tag config / invites / role updates | allowed | — |
+| Deletes (PATs, OATs, groups, members, invites) | **blocked** | `DOCKERHUB_ALLOW_DESTRUCTIVE=True` |
+| Org-settings writes (`PUT /v2/orgs/{org}/settings`) | **blocked** | `DOCKERHUB_ALLOW_DESTRUCTIVE=True` |
+
+---
+
+## Concepts
+
+The concept registry (`CONCEPT:HUB-1.x`) is documented in
+[docs/concepts.md](docs/concepts.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

dockerhub_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+dockerhub_api/__init__.py,sha256=k1wiT9akFBY7B-yLh83mkS1NLgtnGjRiFEyisivWJgc,2507
+dockerhub_api/__main__.py,sha256=U3vMyjze1PLsQP_7Ykt4ut64-J3zSRepGHR_hVDgv4M,99
+dockerhub_api/agent_server.py,sha256=pc4lde4kFMFYNoYVUEiT7XQYjv1V1mG-HShDeJlFox0,2665
+dockerhub_api/api_client.py,sha256=r2dnhw2iMA4FTrMibQOuus__gkQemsZ9P6gbZoOYHh0,1247
+dockerhub_api/auth.py,sha256=OJeYPbtD6HReobaZE3wHnkE7oE8XZAKyKsxzUjaeCMI,8710
+dockerhub_api/dockerhub_input_models.py,sha256=661VY4sWohGDc_QVnndbgRqI5mLVhOjED7fG9YS5ZPA,26142
+dockerhub_api/dockerhub_response_models.py,sha256=3jA-3aPcaHSgZXF3gaLD-VFDqzCQ59nKzuFZrOeeevI,9280
+dockerhub_api/main_agent.json,sha256=k9FA3f4eAiaeCbgCHj-ug5Vj38By7NhCbd9MMPdfhHw,983
+dockerhub_api/mcp_config.json,sha256=2OOXrwO1sDLyHQqpZwhvDHizPIe3by6YmK4KFE333gI,23
+dockerhub_api/mcp_server.py,sha256=XRxcRfE6Ph4-fh4T9TlA4bp_TZ8QAhiHv12zMXs1kzY,3512
+dockerhub_api/api/__init__.py,sha256=Ofb5z_yDBJ2JgbZxwQys6YBX327RFc0kKeOCOp1p3QY,47
+dockerhub_api/api/api_client_access_tokens.py,sha256=MsAgkA8QQOE3p5bLYL6mvjkqpg_ENasPILNfuR42zSE,2859
+dockerhub_api/api/api_client_audit_logs.py,sha256=uGqiKE8gOzkT4o6bDmz1TrhEAUDSudHNSsSMZRETEYg,1810
+dockerhub_api/api/api_client_auth.py,sha256=pqo2Rasdr-1lUXZRXK-q23SP2hGh-L2mafvMzuopzuc,3251
+dockerhub_api/api/api_client_base.py,sha256=WTMyCIDRXgSQPpSR32S2cKBAZa1BZtsYOCzpYVW1rK0,12236
+dockerhub_api/api/api_client_groups.py,sha256=FqGaAu9SznW2uCpZJyJEj1s07Wf7bVQhE1IBbxMUmX8,5336
+dockerhub_api/api/api_client_org_access_tokens.py,sha256=j3yqMoeZ3UTuXpDbcnmbfzMqfmEq-Gf5jFPfpWF-khk,3709
+dockerhub_api/api/api_client_orgs.py,sha256=l1siP_O_0GVzBrNrJTEHRchuL8lw-X0A7OJkjMQRSms,5644
+dockerhub_api/api/api_client_repositories.py,sha256=wwT3oe9lCcGtSGN1uXGqahCbYcm4pBSbrY7JmnHBk5k,7512
+dockerhub_api/api/api_client_scim.py,sha256=HLkUSzb1RHP0vOFpzANgMYKjTG4tPbgXfFKuD93FvoI,5287
+dockerhub_api/mcp/__init__.py,sha256=IEb_LmnQCWTk_Y__wS-2qWs_5EFbDUTmNkfQGFdldBE,3694
+dockerhub_api/mcp/mcp_admin.py,sha256=v-L8uCTWe7he-BAGoMl9dBapdHganA7RNgtRRGyPy48,1543
+dockerhub_api/mcp/mcp_audit.py,sha256=HNGnBxrHnuND31zontePiD56Zp2ObRoKc7MlnhXk-mQ,1458
+dockerhub_api/mcp/mcp_auth.py,sha256=bTi6teDamh5huppPGspwLKZqQ3-0d6eYtkDF-hJ-ntY,2652
+dockerhub_api/mcp/mcp_org.py,sha256=GBwQ2_WW-Zb0MmdAtg4uRNTYa4tve4dxMDjEoPgOacM,2238
+dockerhub_api/mcp/mcp_repos.py,sha256=CE3hcCYD1nzKidRDF-dRuyp2ANNN2uM2kiqpOodEE7s,2242
+dockerhub_api/mcp/mcp_scim.py,sha256=ZoBP9UvYlcEKs8-NN-wX3WGujt-8vaLbOvo2Hrnsimo,2106
+dockerhub_api/mcp/mcp_teams.py,sha256=upA2ojftlmNYlfZmoRNqkQAM0-oiyUqYQiBOOhtp7NE,1914
+dockerhub_api-0.1.0.dist-info/licenses/LICENSE,sha256=lAmFjsQO9B015kHJ11AulWIYtfW4DjC-_eP_yamF5Yg,1068
+dockerhub_api-0.1.0.dist-info/METADATA,sha256=6IDML66_rsD7497wU67qTlV4wUwhfe-gp8qolkV_Qfw,9268
+dockerhub_api-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dockerhub_api-0.1.0.dist-info/entry_points.txt,sha256=fDrOoLNTQvXQkguffAuFgiMXYi2KwnmE8N1a88esoMo,128
+dockerhub_api-0.1.0.dist-info/top_level.txt,sha256=2WKbefEedQJEA-Vfhw7K1aRwo7riYKLL1BomvcXNMio,14
+dockerhub_api-0.1.0.dist-info/RECORD,,

dockerhub_api-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dockerhub_api-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dockerhub-agent = dockerhub_api.agent_server:agent_server
+dockerhub-mcp = dockerhub_api.mcp_server:mcp_server

dockerhub_api-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Audel Rouhi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

dockerhub_api-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dockerhub_api