ChatCoolify 0.1.0__py3-none-any.whl

chatcoolify/__init__.py

@@ -0,0 +1,24 @@
+"""ChatCoolify: AI-safe integration with the official Coolify API."""
+
+from .client import (
+    DEFAULT_BASE_URL,
+    CoolifyAPIError,
+    CoolifyClient,
+    CoolifyConfigurationError,
+    CoolifyError,
+    CoolifyPermissionError,
+    PublicApplicationSpec,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "CoolifyAPIError",
+    "CoolifyClient",
+    "CoolifyConfigurationError",
+    "CoolifyError",
+    "CoolifyPermissionError",
+    "PublicApplicationSpec",
+    "__version__",
+]

chatcoolify/cli.py

@@ -0,0 +1,284 @@
+"""Command-line interface for safe Coolify inspection and automation."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import click
+
+from . import __version__
+from .client import DEFAULT_BASE_URL, CoolifyClient, CoolifyError, PublicApplicationSpec
+
+
+CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+
+def _emit(value: Any) -> None:
+    click.echo(json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True, default=str))
+
+
+def _client(ctx: click.Context) -> CoolifyClient:
+    return ctx.obj["client"]
+
+
+def _handle_error(error: CoolifyError) -> None:
+    raise click.ClickException(str(error)) from error
+
+
+def _render_tree(command: click.Group, *, brief: bool) -> str:
+    """Render the registered CLI surface instead of maintaining docs by hand."""
+
+    options = ["--help", "--version", "--tree", "--tree-brief", "--base-url", "--allow-write"]
+    lines = [command.name or "chatcoolify"]
+    for option in options:
+        lines.append(f"|- {option}")
+    commands = sorted(command.commands.values(), key=lambda item: item.name)
+    for index, subcommand in enumerate(commands):
+        connector = "`-" if index == len(commands) - 1 else "|-"
+        suffix = "" if brief else f"  # {subcommand.help or subcommand.short_help or ''}".rstrip()
+        lines.append(f"{connector} {subcommand.name}{suffix}")
+    return "\n".join(lines)
+
+
+def _tree_callback(brief: bool):
+    def callback(ctx: click.Context, _param: click.Parameter, value: bool) -> None:
+        if not value or ctx.resilient_parsing:
+            return
+        click.echo(_render_tree(ctx.command, brief=brief))
+        ctx.exit()
+
+    return callback
+
+
+@click.group(name="chatcoolify", context_settings=CONTEXT_SETTINGS)
+@click.version_option(__version__, prog_name="chatcoolify")
+@click.option("--tree", is_flag=True, is_eager=True, expose_value=False, callback=_tree_callback(False), help="Print the registered command tree.")
+@click.option("--tree-brief", is_flag=True, is_eager=True, expose_value=False, callback=_tree_callback(True), help="Print the registered command tree without descriptions.")
+@click.option(
+    "--base-url",
+    envvar="COOLIFY_BASE_URL",
+    default=DEFAULT_BASE_URL,
+    show_default=True,
+    help="Coolify control-plane URL. Keep API tokens out of command arguments.",
+)
+@click.option(
+    "--allow-write",
+    is_flag=True,
+    default=False,
+    help="Allow commands that create or deploy resources. Read-only is the default.",
+)
+@click.pass_context
+def main(ctx: click.Context, base_url: str, allow_write: bool) -> None:
+    """Use the official Coolify REST API with a local AI safety gate."""
+
+    ctx.ensure_object(dict)
+    ctx.obj["client"] = CoolifyClient.from_env(allow_write=allow_write)
+    if base_url != DEFAULT_BASE_URL:
+        ctx.obj["client"] = CoolifyClient(
+            base_url,
+            token=ctx.obj["client"].token,
+            allow_write=allow_write,
+        )
+
+
+@main.command()
+@click.pass_context
+def health(ctx: click.Context) -> None:
+    """Call the public health endpoint; no API token is needed."""
+
+    try:
+        _emit(_client(ctx).health())
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command()
+@click.pass_context
+def team(ctx: click.Context) -> None:
+    """Show the current team bound to the configured API token."""
+
+    try:
+        _emit(_client(ctx).current_team())
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command("overview")
+@click.pass_context
+def overview(ctx: click.Context) -> None:
+    """Show a compact read-only inventory for the configured team."""
+
+    client = _client(ctx)
+    try:
+        _emit(
+            {
+                "team": client.current_team(),
+                "projects": client.list_projects(),
+                "applications": client.list_applications(),
+                "servers": client.list_servers(),
+            }
+        )
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command("projects")
+@click.pass_context
+def projects(ctx: click.Context) -> None:
+    """List projects visible to the configured API token."""
+
+    try:
+        _emit(_client(ctx).list_projects())
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command("applications")
+@click.pass_context
+def applications(ctx: click.Context) -> None:
+    """List applications visible to the configured API token."""
+
+    try:
+        _emit(_client(ctx).list_applications())
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command("servers")
+@click.pass_context
+def servers(ctx: click.Context) -> None:
+    """List servers visible to the configured API token."""
+
+    try:
+        _emit(_client(ctx).list_servers())
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command("deployments")
+@click.argument("application_uuid")
+@click.option("--skip", default=0, type=click.IntRange(min=0), show_default=True)
+@click.option("--take", default=20, type=click.IntRange(min=1), show_default=True)
+@click.pass_context
+def deployments(ctx: click.Context, application_uuid: str, skip: int, take: int) -> None:
+    """List deployment history for one application."""
+
+    try:
+        _emit(_client(ctx).list_deployments(application_uuid, skip=skip, take=take))
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command("project-create")
+@click.argument("name")
+@click.option("--description", default=None, help="Optional project description.")
+@click.pass_context
+def project_create(ctx: click.Context, name: str, description: str | None) -> None:
+    """Create a project. Requires the global --allow-write flag."""
+
+    try:
+        _emit(_client(ctx).create_project(name, description=description))
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+def _website_spec(
+    project_uuid: str,
+    server_uuid: str,
+    environment_name: str,
+    environment_uuid: str,
+    repository_url: str,
+    branch: str,
+    build_pack: str,
+    name: str | None,
+    domain: str | None,
+    publish_directory: str | None,
+    port: int | None,
+    spa: bool,
+) -> PublicApplicationSpec:
+    return PublicApplicationSpec(
+        project_uuid=project_uuid,
+        server_uuid=server_uuid,
+        environment_name=environment_name,
+        environment_uuid=environment_uuid,
+        git_repository=repository_url,
+        git_branch=branch,
+        build_pack=build_pack,
+        name=name,
+        domains=domain,
+        publish_directory=publish_directory,
+        is_static=build_pack == "static",
+        is_spa=spa,
+        port=port,
+    )
+
+
+def _website_options(function):
+    options = [
+        click.option("--project-uuid", required=True),
+        click.option("--server-uuid", required=True),
+        click.option("--environment-name", default="production", show_default=True),
+        click.option("--environment-uuid", required=True),
+        click.option("--repository-url", required=True),
+        click.option("--branch", default="main", show_default=True),
+        click.option(
+            "--build-pack",
+            type=click.Choice(["static", "nixpacks", "railpack", "dockerfile", "dockercompose"]),
+            default="static",
+            show_default=True,
+        ),
+        click.option("--name", default=None),
+        click.option("--domain", default=None, help="Full HTTPS domain, for example https://site.example.com"),
+        click.option("--publish-directory", default="dist", show_default=True),
+        click.option("--port", type=click.IntRange(min=1, max=65535), default=None),
+        click.option("--spa/--no-spa", default=True, show_default=True),
+    ]
+    for option in reversed(options):
+        function = option(function)
+    return function
+
+
+@main.command("website-plan")
+@_website_options
+@click.pass_context
+def website_plan(ctx: click.Context, **kwargs: Any) -> None:
+    """Render a website payload without making a Coolify write request."""
+
+    del ctx
+    try:
+        spec = _website_spec(**kwargs)
+        _emit({"endpoint": "/api/v1/applications/public", "payload": spec.as_payload(instant_deploy=False)})
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command("website-create")
+@_website_options
+@click.option("--deploy", is_flag=True, default=False, help="Ask Coolify to deploy immediately after creation.")
+@click.pass_context
+def website_create(ctx: click.Context, deploy: bool, **kwargs: Any) -> None:
+    """Create a public Git website. Requires the global --allow-write flag."""
+
+    try:
+        spec = _website_spec(**kwargs)
+        _emit(_client(ctx).create_public_application(spec, instant_deploy=deploy))
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+@main.command("deploy")
+@click.argument("application_uuid")
+@click.option("--force", is_flag=True, default=False, help="Rebuild without the existing cache.")
+@click.pass_context
+def deploy(ctx: click.Context, application_uuid: str, force: bool) -> None:
+    """Trigger a deployment. Requires the global --allow-write flag."""
+
+    try:
+        _emit(_client(ctx).deploy(application_uuid, force=force))
+    except CoolifyError as error:
+        _handle_error(error)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

chatcoolify/client.py

@@ -0,0 +1,310 @@
+"""Typed, fail-closed client for the official Coolify REST API."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import os
+from typing import Any, Mapping, Sequence
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode, urljoin, urlparse
+from urllib.request import Request, urlopen
+
+DEFAULT_BASE_URL = "https://coolify.example.com"
+
+
+class CoolifyError(RuntimeError):
+    """Base exception for ChatCoolify."""
+
+
+class CoolifyConfigurationError(CoolifyError):
+    """Raised when the client lacks required local configuration."""
+
+
+class CoolifyPermissionError(CoolifyError):
+    """Raised before a write request when explicit consent is missing."""
+
+
+class CoolifyAPIError(CoolifyError):
+    """A sanitized error response from the Coolify API."""
+
+    def __init__(self, status: int, message: str) -> None:
+        self.status = status
+        self.message = message
+        super().__init__(f"Coolify API returned HTTP {status}: {message}")
+
+
+@dataclass(frozen=True)
+class PublicApplicationSpec:
+    """Minimum safe payload for a public Git-based Coolify application."""
+
+    project_uuid: str
+    server_uuid: str
+    environment_name: str
+    environment_uuid: str
+    git_repository: str
+    git_branch: str = "main"
+    build_pack: str = "static"
+    name: str | None = None
+    domains: str | None = None
+    publish_directory: str | None = None
+    is_static: bool = True
+    is_spa: bool = True
+    port: int | None = None
+    health_check_path: str | None = None
+
+    def as_payload(self, *, instant_deploy: bool = False) -> dict[str, Any]:
+        """Return the official API payload without adding sensitive fields."""
+
+        _require_text("project_uuid", self.project_uuid)
+        _require_text("server_uuid", self.server_uuid)
+        _require_text("environment_name", self.environment_name)
+        _require_text("environment_uuid", self.environment_uuid)
+        _require_repository(self.git_repository)
+        _require_text("git_branch", self.git_branch)
+        _require_text("build_pack", self.build_pack)
+
+        payload: dict[str, Any] = {
+            "project_uuid": self.project_uuid,
+            "server_uuid": self.server_uuid,
+            "environment_name": self.environment_name,
+            "environment_uuid": self.environment_uuid,
+            "git_repository": self.git_repository,
+            "git_branch": self.git_branch,
+            "build_pack": self.build_pack,
+            "is_static": self.is_static,
+            "is_spa": self.is_spa,
+            "instant_deploy": instant_deploy,
+        }
+        optional_text = {
+            "name": self.name,
+            "domains": self.domains,
+            "publish_directory": self.publish_directory,
+            "health_check_path": self.health_check_path,
+        }
+        for key, value in optional_text.items():
+            if value is not None and value.strip():
+                payload[key] = value.strip()
+        if self.port is not None:
+            if not 1 <= self.port <= 65535:
+                raise CoolifyConfigurationError("port must be between 1 and 65535")
+            payload["ports_exposes"] = str(self.port)
+        return payload
+
+
+class CoolifyClient:
+    """Small client around documented Coolify REST endpoints.
+
+    Instances are read-only by default. Callers must opt in to writes with
+    ``allow_write=True`` and use a Coolify token that itself has write or deploy
+    permission. This creates a local safety gate in addition to Coolify's own
+    team scope and API-token permissions.
+    """
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        *,
+        token: str | None = None,
+        allow_write: bool = False,
+        timeout: float = 30.0,
+    ) -> None:
+        self.base_url = _normalise_base_url(base_url)
+        self.token = token.strip() if token else None
+        self.allow_write = allow_write
+        self.timeout = timeout
+
+    @classmethod
+    def from_env(cls, *, allow_write: bool = False) -> "CoolifyClient":
+        """Create a client from process environment or the active ChatEnv profile."""
+
+        profile_values = _load_chatenv_values()
+        return cls(
+            os.getenv("COOLIFY_BASE_URL") or profile_values.get("COOLIFY_BASE_URL") or DEFAULT_BASE_URL,
+            token=os.getenv("COOLIFY_API_TOKEN") or profile_values.get("COOLIFY_API_TOKEN"),
+            allow_write=allow_write,
+        )
+
+    def health(self) -> dict[str, Any]:
+        """Read the public health endpoint without an API token."""
+
+        result = self._request("GET", "/api/health", auth=False)
+        if isinstance(result, dict):
+            return result
+        return {"ok": str(result).strip().upper() == "OK", "response": str(result).strip()}
+
+    def current_team(self) -> Mapping[str, Any]:
+        return _as_mapping(self._request("GET", "/api/v1/team"), "current team")
+
+    def list_teams(self) -> Sequence[Mapping[str, Any]]:
+        return _as_sequence(self._request("GET", "/api/v1/teams"), "teams")
+
+    def list_projects(self) -> Sequence[Mapping[str, Any]]:
+        return _as_sequence(self._request("GET", "/api/v1/projects"), "projects")
+
+    def list_applications(self) -> Sequence[Mapping[str, Any]]:
+        return _as_sequence(self._request("GET", "/api/v1/applications"), "applications")
+
+    def list_servers(self) -> Sequence[Mapping[str, Any]]:
+        return _as_sequence(self._request("GET", "/api/v1/servers"), "servers")
+
+    def list_deployments(self, application_uuid: str, *, skip: int = 0, take: int = 20) -> Sequence[Mapping[str, Any]]:
+        _require_text("application_uuid", application_uuid)
+        if skip < 0 or take < 1:
+            raise CoolifyConfigurationError("skip must be >= 0 and take must be >= 1")
+        query = urlencode({"skip": skip, "take": take})
+        path = f"/api/v1/deployments/applications/{quote(application_uuid, safe='')}?{query}"
+        return _as_sequence(self._request("GET", path), "deployments")
+
+    def create_project(self, name: str, *, description: str | None = None) -> Mapping[str, Any]:
+        """Create a project only after the caller explicitly enabled writes."""
+
+        _require_text("name", name)
+        payload: dict[str, Any] = {"name": name.strip()}
+        if description and description.strip():
+            payload["description"] = description.strip()
+        return _as_mapping(self._request("POST", "/api/v1/projects", payload=payload, write=True), "project")
+
+    def create_public_application(
+        self,
+        spec: PublicApplicationSpec,
+        *,
+        instant_deploy: bool = False,
+    ) -> Mapping[str, Any]:
+        """Create a public Git application using Coolify's documented API."""
+
+        return _as_mapping(
+            self._request(
+                "POST",
+                "/api/v1/applications/public",
+                payload=spec.as_payload(instant_deploy=instant_deploy),
+                write=True,
+            ),
+            "application",
+        )
+
+    def deploy(self, application_uuid: str, *, force: bool = False) -> Mapping[str, Any]:
+        """Trigger an application deployment with an explicit deploy-capable client."""
+
+        _require_text("application_uuid", application_uuid)
+        return _as_mapping(
+            self._request(
+                "POST",
+                "/api/v1/deploy",
+                payload={"uuid": application_uuid, "force": force},
+                write=True,
+            ),
+            "deployment",
+        )
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        payload: Mapping[str, Any] | None = None,
+        auth: bool = True,
+        write: bool = False,
+    ) -> Any:
+        if write and not self.allow_write:
+            raise CoolifyPermissionError(
+                "write operation blocked locally; recreate the client or CLI with explicit write permission"
+            )
+        if auth and not self.token:
+            raise CoolifyConfigurationError(
+                "COOLIFY_API_TOKEN is required for protected Coolify API operations"
+            )
+
+        url = urljoin(f"{self.base_url}/", path.lstrip("/"))
+        headers = {"Accept": "application/json", "User-Agent": "ChatCoolify/0.1.0"}
+        data = None
+        if auth:
+            headers["Authorization"] = f"Bearer {self.token}"
+        if payload is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(payload).encode("utf-8")
+
+        request = Request(url, data=data, headers=headers, method=method.upper())
+        try:
+            with urlopen(request, timeout=self.timeout) as response:  # nosec B310 - URL is user-configured API origin
+                content_type = response.headers.get_content_type()
+                raw = response.read().decode("utf-8")
+                if not raw:
+                    return None
+                if content_type == "application/json" or raw.lstrip().startswith(("{", "[")):
+                    return json.loads(raw)
+                return raw
+        except HTTPError as error:
+            message = _error_message(error)
+            raise CoolifyAPIError(error.code, message) from error
+        except URLError as error:
+            raise CoolifyError(f"Coolify API is unreachable: {error.reason}") from error
+
+
+def _load_chatenv_values() -> Mapping[str, str]:
+    """Read the active package-owned ChatEnv profile without copying secrets."""
+
+    try:
+        from chatenv import EnvStore, get_paths
+
+        from .config import CoolifyConfig
+
+        return EnvStore(get_paths().envs_dir).load_active(CoolifyConfig)
+    except (ImportError, OSError, ValueError):
+        return {}
+
+
+def _normalise_base_url(value: str) -> str:
+    candidate = value.strip().rstrip("/")
+    parsed = urlparse(candidate)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise CoolifyConfigurationError("COOLIFY_BASE_URL must be an absolute http(s) URL")
+    return candidate
+
+
+def _require_text(name: str, value: str) -> None:
+    if not value or not value.strip():
+        raise CoolifyConfigurationError(f"{name} is required")
+
+
+def _require_repository(value: str) -> None:
+    _require_text("git_repository", value)
+    parsed = urlparse(value)
+    if parsed.scheme != "https" or not parsed.netloc:
+        raise CoolifyConfigurationError("git_repository must be an HTTPS repository URL")
+
+
+def _as_mapping(value: Any, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise CoolifyError(f"Coolify returned an unexpected {label} response")
+    return value
+
+
+def _as_sequence(value: Any, label: str) -> Sequence[Mapping[str, Any]]:
+    if not isinstance(value, list) or not all(isinstance(item, Mapping) for item in value):
+        raise CoolifyError(f"Coolify returned an unexpected {label} response")
+    return value
+
+
+def _error_message(error: HTTPError) -> str:
+    """Extract only a short server message; never include request headers or token data."""
+
+    try:
+        raw = error.read().decode("utf-8", errors="replace")
+        parsed = json.loads(raw)
+        if isinstance(parsed, Mapping) and isinstance(parsed.get("message"), str):
+            return parsed["message"][:500]
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        pass
+    return error.reason or "request failed"
+
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "CoolifyAPIError",
+    "CoolifyClient",
+    "CoolifyConfigurationError",
+    "CoolifyError",
+    "CoolifyPermissionError",
+    "PublicApplicationSpec",
+]

chatcoolify/config.py

@@ -0,0 +1,48 @@
+"""ChatEnv schema for ChatCoolify credentials and API endpoint."""
+
+from __future__ import annotations
+
+import os
+
+from chatenv import BaseEnvConfig, EnvField, EnvStore, get_paths
+
+
+class CoolifyConfig(BaseEnvConfig):
+    """Typed configuration for the existing Coolify control plane."""
+
+    _title = "Coolify Configuration"
+    _aliases = ["coolify", "chatcoolify"]
+    _storage_dir = "Coolify"
+
+    COOLIFY_BASE_URL = EnvField(
+        "COOLIFY_BASE_URL",
+        default="https://coolify.example.com",
+        desc="Public HTTPS URL of the Coolify control plane",
+    )
+    COOLIFY_API_TOKEN = EnvField(
+        "COOLIFY_API_TOKEN",
+        desc="Team-scoped Coolify API token; use the minimum required permissions and expiration",
+        is_sensitive=True,
+    )
+
+    @classmethod
+    def test(cls) -> None:
+        """Validate a configured endpoint, while keeping unconfigured schemas offline."""
+
+        from .client import DEFAULT_BASE_URL, CoolifyClient, CoolifyError
+
+        profile_values = EnvStore(get_paths().envs_dir).load_active(cls)
+        base_url = os.getenv("COOLIFY_BASE_URL") or profile_values.get("COOLIFY_BASE_URL") or DEFAULT_BASE_URL
+        if base_url == DEFAULT_BASE_URL:
+            print("ChatCoolify schema loaded; configure COOLIFY_BASE_URL to run a health check.")
+            return
+        try:
+            result = CoolifyClient(base_url).health()
+        except CoolifyError as error:
+            raise RuntimeError(f"Coolify health check failed: {error}") from error
+        if not result.get("ok"):
+            raise RuntimeError("Coolify health check did not report OK")
+        print(f"Coolify health check passed for {base_url}.")
+
+
+__all__ = ["CoolifyConfig"]

chatcoolify-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: ChatCoolify
+Version: 0.1.0
+Summary: AI-safe Python client and CLI for the official Coolify API
+Author-email: ChatArch <1073853456@qq.com>
+License-Expression: MIT
+Project-URL: Homepage, https://arch.gh.wzhecnu.cn/ChatCoolify/
+Project-URL: Documentation, https://arch.gh.wzhecnu.cn/ChatCoolify/
+Project-URL: Repository, https://github.com/ChatArch/ChatCoolify
+Project-URL: Issues, https://github.com/ChatArch/ChatCoolify/issues
+Keywords: ai,chatarch,coolify,deployment,mcp,paas
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: chatenv<0.3.0,>=0.2.9
+Requires-Dist: click<9.0,>=8.1
+Provides-Extra: dev
+Requires-Dist: build<2.0,>=1.2; extra == "dev"
+Requires-Dist: pytest<10.0,>=8.0; extra == "dev"
+Requires-Dist: twine<7.0,>=5.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs<2.0,>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material<10.0,>=9.5; extra == "docs"
+Requires-Dist: mkdocs-static-i18n<2.0,>=1.2; extra == "docs"
+Requires-Dist: mkdocs-minify-plugin<1.0,>=0.8; extra == "docs"
+Requires-Dist: mike<3.0,>=2.0; extra == "docs"
+Dynamic: license-file
+
+<div align="center">
+
+# ChatCoolify
+
+AI-safe Python client and MkDocs guide for the official Coolify API.
+
+[文档](https://arch.gh.wzhecnu.cn/ChatCoolify/) · [English](README.en.md) · [PyPI](https://pypi.org/project/ChatCoolify/) · [源码](https://github.com/ChatArch/ChatCoolify)
+
+</div>
+
+## 解决什么问题
+
+ChatCoolify 不替代 Coolify，而是把官方 REST API 变成可测试的 Python 客户端和 CLI：
+
+- 默认只读，适合 AI 清点服务器、项目、应用与部署状态；
+- 写操作必须有 Coolify Token 权限并显式传递 `--allow-write`；
+- 支持 ChatEnv 配置、公开 Git 网站计划与创建、部署触发；
+- 文档覆盖邀请制协作、MCP、网站、API、数据库和运维边界。
+
+## 安装
+
+```bash
+python -m pip install --upgrade ChatCoolify
+chatcoolify --version
+chatcoolify --tree
+```
+
+支持 Python `>=3.10`。
+
+## 最快开始
+
+```bash
+chatcoolify --base-url https://<coolify-url> health
+```
+
+需要受保护 API 时，先在 Coolify 创建 Team-scoped 最小权限 Token，再通过 ChatEnv 配置：
+
+```bash
+chatenv init -t coolify -I
+chatenv set COOLIFY_BASE_URL=https://<coolify-url>
+chatenv set COOLIFY_API_TOKEN='<team-scoped-token>'
+chatcoolify overview
+```
+
+## 网站计划示例
+
+```bash
+chatcoolify website-plan \
+  --project-uuid PROJECT_UUID \
+  --server-uuid SERVER_UUID \
+  --environment-uuid ENVIRONMENT_UUID \
+  --repository-url https://github.com/example/simple-site \
+  --domain https://site.example.com
+```
+
+该命令只输出官方 API payload。真正创建资源需要同时具备 `write` Token 和显式写门：
+
+```bash
+chatcoolify --allow-write website-create ...
+```
+
+## 安全边界
+
+- 不把 Token 写入参数、仓库、日志或提示词。
+- 不向普通 AI 或 CI 提供 `root` Token。
+- Team 角色不是虚拟机隔离；不可信代码不应共享生产 Docker 守护进程。
+- 完整操作流程见 [文档](https://arch.gh.wzhecnu.cn/ChatCoolify/)。
+
+## 开发
+
+```bash
+python -m pip install -e '.[dev,docs]'
+python -m pytest -q
+python -m mkdocs build --strict
+python -m build
+python -m twine check dist/*
+```
+
+## 许可证
+
+MIT。

chatcoolify-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+chatcoolify/__init__.py,sha256=bUbYnP9qZr5jmZUpirt-gpsavsHki04X-0mFqpTjxFc,498
+chatcoolify/cli.py,sha256=CYGLbtTPnqo49TK1V31xOJnsvj-jJyx0eQacEEZQmXM,9235
+chatcoolify/client.py,sha256=Cl14yehC67DT5CwHvFizgkVEiKkhm8X5jkZOqn4uht0,11557
+chatcoolify/config.py,sha256=Qq-sgi9myNf0FawaOFSprq1o5fLKTEr2vxk0v73l8Lc,1708
+chatcoolify-0.1.0.dist-info/licenses/LICENSE,sha256=G-fJLQ4pkXXISE3qeN8J5Cw5VRoNongA0hbsHA9TRe8,1065
+chatcoolify-0.1.0.dist-info/METADATA,sha256=Mm_nMaG1C-qFYFqUUAmQ7gI6HAQHdYL1Sss7Xt8XSUE,3625
+chatcoolify-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+chatcoolify-0.1.0.dist-info/entry_points.txt,sha256=9-SlV-yBBEOx9wym6tXyTPDd9ruLXX9ErcJk8eUaNI0,105
+chatcoolify-0.1.0.dist-info/top_level.txt,sha256=FnAqcxT8tBv7rlyLWLwSziJ6oTaQ97p06hq4P5qv8rM,12
+chatcoolify-0.1.0.dist-info/RECORD,,

chatcoolify-0.1.0.dist-info/WHEEL

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

chatcoolify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[chatenv.configs]
+chatcoolify = chatcoolify.config
+
+[console_scripts]
+chatcoolify = chatcoolify.cli:main

chatcoolify-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ChatArch
+
+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.

chatcoolify-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+chatcoolify