vystak-provider-docker 0.1.0__tar.gz

vystak_provider_docker-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+.pytest_cache/
+.ruff_cache/
+.pyright/
+
+# TypeScript
+node_modules/
+*.tsbuildinfo
+coverage/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Vystak generated output (was .agentstack/ before rename)
+.vystak/
+.agentstack/
+
+# Tooling workspaces (brainstorm sessions, local agent state)
+.superpowers/

vystak_provider_docker-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: vystak-provider-docker
+Version: 0.1.0
+Summary: Vystak platform provider — deploys agents to Docker
+Project-URL: Homepage, https://vystak.dev
+Project-URL: Documentation, https://vystak.dev/docs
+Project-URL: Repository, https://github.com/vystak/vystak
+Project-URL: Issues, https://github.com/vystak/vystak/issues
+Author-email: Anatoliy Kolodkin <11351966+akolodkin@users.noreply.github.com>
+License-Expression: Apache-2.0
+Keywords: agent,ai,deployment,docker,provider,vystak
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.11
+Requires-Dist: docker>=7.0
+Requires-Dist: vystak>=0.1.0
+Description-Content-Type: text/markdown
+
+# vystak-provider-docker
+
+Platform provider that deploys Vystak agents to Docker.
+
+## Install
+
+```bash
+pip install vystak-provider-docker
+```
+
+Usually you don't install this directly — [`vystak-cli`](https://pypi.org/project/vystak-cli/) depends on it and invokes it automatically when your agent's `platform.type` is `docker`.
+
+## What it does
+
+On `vystak apply`, the provider builds a `ProvisionGraph` and rolls out, in topological order:
+
+- **Docker network** (`vystak-net`) — shared bridge for inter-agent A2A calls
+- **Postgres containers** — managed session / memory stores (if declared)
+- **SQLite volumes** — persistent local-only alternative
+- **Agent container** — builds the image from generated code, runs it on the shared network
+- **Gateway container** — optional; routes Slack / OpenAI-compatible traffic to one or more agents
+
+Each node has a health check; the provider waits for each to report healthy before proceeding to dependents.
+
+## License
+
+Apache-2.0

vystak_provider_docker-0.1.0/README.md

@@ -0,0 +1,27 @@
+# vystak-provider-docker
+
+Platform provider that deploys Vystak agents to Docker.
+
+## Install
+
+```bash
+pip install vystak-provider-docker
+```
+
+Usually you don't install this directly — [`vystak-cli`](https://pypi.org/project/vystak-cli/) depends on it and invokes it automatically when your agent's `platform.type` is `docker`.
+
+## What it does
+
+On `vystak apply`, the provider builds a `ProvisionGraph` and rolls out, in topological order:
+
+- **Docker network** (`vystak-net`) — shared bridge for inter-agent A2A calls
+- **Postgres containers** — managed session / memory stores (if declared)
+- **SQLite volumes** — persistent local-only alternative
+- **Agent container** — builds the image from generated code, runs it on the shared network
+- **Gateway container** — optional; routes Slack / OpenAI-compatible traffic to one or more agents
+
+Each node has a health check; the provider waits for each to report healthy before proceeding to dependents.
+
+## License
+
+Apache-2.0

vystak_provider_docker-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "vystak-provider-docker"
+version = "0.1.0"
+description = "Vystak platform provider — deploys agents to Docker"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+authors = [
+    { name = "Anatoliy Kolodkin", email = "11351966+akolodkin@users.noreply.github.com" },
+]
+keywords = ["vystak", "docker", "agent", "ai", "deployment", "provider"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Systems Administration",
+]
+dependencies = [
+    "vystak>=0.1.0",
+    "docker>=7.0",
+]
+
+[project.urls]
+Homepage = "https://vystak.dev"
+Documentation = "https://vystak.dev/docs"
+Repository = "https://github.com/vystak/vystak"
+Issues = "https://github.com/vystak/vystak/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/vystak_provider_docker"]
+
+[tool.uv.sources]
+vystak = { workspace = true }

vystak_provider_docker-0.1.0/src/vystak_provider_docker/__init__.py

@@ -0,0 +1,7 @@
+"""Vystak Docker platform provider."""
+
+__version__ = "0.1.0"
+
+from vystak_provider_docker.provider import DockerProvider
+
+__all__ = ["DockerProvider", "__version__"]

vystak_provider_docker-0.1.0/src/vystak_provider_docker/gateway.py

@@ -0,0 +1,121 @@
+"""Gateway container provisioning for Docker."""
+
+import json
+from pathlib import Path
+
+import docker
+import docker.errors
+
+GATEWAY_DOCKERFILE = """\
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+CMD ["python", "server.py"]
+"""
+
+GATEWAY_REQUIREMENTS = """\
+fastapi>=0.115
+uvicorn>=0.34
+httpx>=0.28
+slack-bolt>=1.21
+aiohttp>=3.9
+aiosqlite>=0.20
+"""
+
+
+def _gateway_container_name(gateway_name: str) -> str:
+    return f"vystak-gateway-{gateway_name}"
+
+
+def write_gateway_source(gateway_dir: Path) -> None:
+    """Write gateway server source files to a build directory."""
+    gateway_dir.mkdir(parents=True, exist_ok=True)
+
+    import vystak_gateway
+
+    pkg_dir = Path(vystak_gateway.__file__).parent
+
+    for filename in ["server.py", "router.py", "store.py", "__init__.py"]:
+        src = pkg_dir / filename
+        if src.exists():
+            content = src.read_text()
+            # Rewrite package imports to local imports for Docker deployment
+            content = content.replace("from vystak_gateway.", "from ")
+            content = content.replace(
+                "from vystak.schema.openai import", "from openai_types import"
+            )
+            (gateway_dir / filename).write_text(content)
+
+    # Bundle OpenAI-compatible schema types
+    import vystak.schema.openai as _openai_schema
+
+    _openai_src = Path(_openai_schema.__file__)
+    if _openai_src.exists():
+        (gateway_dir / "openai_types.py").write_text(_openai_src.read_text())
+
+    providers_dir = gateway_dir / "providers"
+    providers_dir.mkdir(parents=True, exist_ok=True)
+    providers_src = pkg_dir / "providers"
+    for filename in ["__init__.py", "base.py", "slack.py"]:
+        src = providers_src / filename
+        if src.exists():
+            content = src.read_text()
+            content = content.replace("from vystak_gateway.", "from ")
+            (providers_dir / filename).write_text(content)
+
+    (gateway_dir / "requirements.txt").write_text(GATEWAY_REQUIREMENTS)
+    (gateway_dir / "Dockerfile").write_text(GATEWAY_DOCKERFILE)
+
+
+def write_routes_file(routes_path: Path, providers_list: list, routes_list: list) -> None:
+    """Write routes.json for the gateway."""
+    routes_path.parent.mkdir(parents=True, exist_ok=True)
+    data = {"providers": providers_list, "routes": routes_list}
+    routes_path.write_text(json.dumps(data, indent=2))
+
+
+def build_gateway_image(client, gateway_name: str, gateway_dir: str) -> None:
+    """Build a Docker image for the gateway."""
+    image_tag = f"{_gateway_container_name(gateway_name)}:latest"
+    client.images.build(path=gateway_dir, tag=image_tag)
+
+
+def provision_gateway(
+    client, gateway_name: str, network, routes_path: str, env: dict, port: int = 8080
+) -> None:
+    """Start or restart a gateway container."""
+    container_name = _gateway_container_name(gateway_name)
+
+    try:
+        existing = client.containers.get(container_name)
+        existing.stop()
+        existing.remove()
+    except docker.errors.NotFound:
+        pass
+
+    image_tag = f"{container_name}:latest"
+    abs_routes = str(Path(routes_path).resolve())
+
+    client.containers.run(
+        image_tag,
+        name=container_name,
+        detach=True,
+        ports={"8080/tcp": port},
+        environment=env,
+        volumes={abs_routes: {"bind": "/app/routes.json", "mode": "ro"}},
+        network=network.name,
+        labels={"vystak.gateway": gateway_name},
+    )
+
+
+def destroy_gateway(client, gateway_name: str) -> None:
+    """Stop and remove a gateway container."""
+    container_name = _gateway_container_name(gateway_name)
+    try:
+        container = client.containers.get(container_name)
+        container.stop()
+        container.remove()
+    except docker.errors.NotFound:
+        pass

vystak_provider_docker-0.1.0/src/vystak_provider_docker/network.py

@@ -0,0 +1,13 @@
+"""Docker network management for Vystak."""
+
+import docker  # noqa: F401 — re-exported for test patching (vystak_provider_docker.network.docker)
+
+NETWORK_NAME = "vystak-net"
+
+
+def ensure_network(client, name: str = NETWORK_NAME):
+    """Create the Vystak Docker network if it doesn't exist."""
+    existing = client.networks.list(names=[name])
+    if existing:
+        return existing[0]
+    return client.networks.create(name, driver="bridge")

vystak_provider_docker-0.1.0/src/vystak_provider_docker/nodes/__init__.py

@@ -0,0 +1,13 @@
+"""Docker provider node types for the provisioning graph."""
+
+from vystak_provider_docker.nodes.agent import DockerAgentNode
+from vystak_provider_docker.nodes.gateway import DockerGatewayNode
+from vystak_provider_docker.nodes.network import DockerNetworkNode
+from vystak_provider_docker.nodes.service import DockerServiceNode
+
+__all__ = [
+    "DockerAgentNode",
+    "DockerGatewayNode",
+    "DockerNetworkNode",
+    "DockerServiceNode",
+]

vystak_provider_docker-0.1.0/src/vystak_provider_docker/nodes/agent.py

@@ -0,0 +1,182 @@
+"""DockerAgentNode — builds and runs an agent as a Docker container."""
+
+import os
+from pathlib import Path
+
+import docker.errors
+from vystak.providers.base import DeployPlan, GeneratedCode
+from vystak.provisioning.health import HealthCheck, NoopHealthCheck
+from vystak.provisioning.node import Provisionable, ProvisionResult
+from vystak.schema.agent import Agent
+
+
+class DockerAgentNode(Provisionable):
+    """Builds a Docker image and runs an agent container."""
+
+    def __init__(self, client, agent: Agent, generated_code: GeneratedCode, plan: DeployPlan):
+        self._client = client
+        self._agent = agent
+        self._generated_code = generated_code
+        self._plan = plan
+
+    @property
+    def name(self) -> str:
+        return f"agent:{self._agent.name}"
+
+    @property
+    def depends_on(self) -> list[str]:
+        deps = ["network"]
+        if self._agent.sessions is not None:
+            deps.append(self._agent.sessions.name)
+        if self._agent.memory is not None:
+            deps.append(self._agent.memory.name)
+        for svc in self._agent.services:
+            deps.append(svc.name)
+        return deps
+
+    def _container_name(self) -> str:
+        return f"vystak-{self._agent.name}"
+
+    def provision(self, context: dict) -> ProvisionResult:
+        try:
+            container_name = self._container_name()
+            network = context["network"].info["network"]
+
+            # Stop existing container
+            try:
+                existing = self._client.containers.get(container_name)
+                existing.stop()
+                existing.remove()
+            except docker.errors.NotFound:
+                pass
+
+            # Write build files
+            build_dir = Path(".vystak") / self._agent.name
+            build_dir.mkdir(parents=True, exist_ok=True)
+            for filename, content in self._generated_code.files.items():
+                file_path = build_dir / filename
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                file_path.write_text(content)
+
+            # Bundle OpenAI-compatible schema types for Docker deployment
+            import vystak.schema.openai as _openai_schema
+
+            _openai_src = Path(_openai_schema.__file__)
+            if _openai_src.exists():
+                (build_dir / "openai_types.py").write_text(_openai_src.read_text())
+
+            # Build Dockerfile
+            mcp_installs = ""
+            needs_node = False
+            if self._agent.mcp_servers:
+                install_cmds = []
+                for mcp in self._agent.mcp_servers:
+                    if mcp.install:
+                        install_cmds.append(f"RUN {mcp.install}")
+                    for field in (mcp.install or "", mcp.command or ""):
+                        if "npm" in field or "npx" in field:
+                            needs_node = True
+                if install_cmds:
+                    mcp_installs = "\n".join(install_cmds) + "\n"
+
+            node_install = ""
+            if needs_node:
+                node_install = (
+                    "RUN apt-get update && apt-get install -y nodejs npm "
+                    "&& rm -rf /var/lib/apt/lists/*\n"
+                )
+
+            dockerfile_content = (
+                "FROM python:3.11-slim\n"
+                "WORKDIR /app\n"
+                f"{node_install}"
+                f"{mcp_installs}"
+                "COPY requirements.txt .\n"
+                "RUN pip install --no-cache-dir -r requirements.txt\n"
+                "COPY . .\n"
+                f'CMD ["python", "{self._generated_code.entrypoint}"]\n'
+            )
+            (build_dir / "Dockerfile").write_text(dockerfile_content)
+
+            # Build image
+            image_tag = f"{container_name}:latest"
+            self._client.images.build(path=str(build_dir), tag=image_tag)
+
+            # Build env vars
+            env = {}
+            for secret in self._agent.secrets:
+                value = os.environ.get(secret.name)
+                if value:
+                    env[secret.name] = value
+            # Connection strings from upstream services
+            if self._agent.sessions:
+                dep_result = context.get(self._agent.sessions.name)
+                if dep_result and dep_result.info.get("connection_string"):
+                    env["SESSION_STORE_URL"] = dep_result.info["connection_string"]
+
+            if self._agent.memory:
+                dep_result = context.get(self._agent.memory.name)
+                if dep_result and dep_result.info.get("connection_string"):
+                    env["MEMORY_STORE_URL"] = dep_result.info["connection_string"]
+
+            # Build volumes
+            volumes = {}
+            for dep_name in self.depends_on:
+                if dep_name == "network":
+                    continue
+                dep_result = context.get(dep_name)
+                if dep_result and dep_result.info.get("engine") == "sqlite":
+                    volumes[dep_result.info["volume_name"]] = {
+                        "bind": "/data",
+                        "mode": "rw",
+                    }
+
+            # Run container
+            host_port = self._agent.port if self._agent.port else None
+            self._client.containers.run(
+                image_tag,
+                name=container_name,
+                detach=True,
+                ports={"8000/tcp": host_port},
+                environment=env,
+                volumes=volumes,
+                network=network.name,
+                labels={
+                    "vystak.hash": self._plan.target_hash,
+                    "vystak.agent": self._agent.name,
+                },
+            )
+
+            # Get the actual port
+            container = self._client.containers.get(container_name)
+            port_info = container.ports.get("8000/tcp")
+            actual_port = port_info[0]["HostPort"] if port_info else "?"
+            url = f"http://localhost:{actual_port}"
+
+            return ProvisionResult(
+                name=self.name,
+                success=True,
+                info={
+                    "url": url,
+                    "container_name": container_name,
+                    "port": actual_port,
+                },
+            )
+        except Exception as e:
+            return ProvisionResult(
+                name=self.name,
+                success=False,
+                error=str(e),
+            )
+
+    def health_check(self) -> HealthCheck:
+        return NoopHealthCheck()
+
+    def destroy(self) -> None:
+        container_name = self._container_name()
+        try:
+            container = self._client.containers.get(container_name)
+            container.stop()
+            container.remove()
+        except docker.errors.NotFound:
+            pass

vystak_provider_docker-0.1.0/src/vystak_provider_docker/nodes/gateway.py

@@ -0,0 +1,84 @@
+"""DockerGatewayNode — provisions a gateway container."""
+
+from vystak.provisioning.health import HealthCheck, NoopHealthCheck
+from vystak.provisioning.node import Provisionable, ProvisionResult
+
+from vystak_provider_docker.gateway import (
+    build_gateway_image,
+    destroy_gateway,
+    provision_gateway,
+    write_gateway_source,
+    write_routes_file,
+)
+
+
+class DockerGatewayNode(Provisionable):
+    """Provisions a gateway container for agent channel routing."""
+
+    def __init__(self, client, gw_name: str, gw_info: dict, agent_name: str):
+        self._client = client
+        self._gw_name = gw_name
+        self._gw_info = gw_info
+        self._agent_name = agent_name
+
+    @property
+    def name(self) -> str:
+        return f"gateway:{self._gw_name}"
+
+    @property
+    def depends_on(self) -> list[str]:
+        return [f"agent:{self._agent_name}"]
+
+    def provision(self, context: dict) -> ProvisionResult:
+        try:
+            from pathlib import Path
+
+            network = context["network"].info["network"]
+            gateway = self._gw_info.get("gateway")
+            gateway_dir = Path(".vystak") / f"gateway-{self._gw_name}"
+
+            write_gateway_source(gateway_dir)
+
+            routes_path = gateway_dir / "routes.json"
+            write_routes_file(
+                routes_path,
+                list(self._gw_info.get("providers", {}).values()),
+                self._gw_info.get("routes", []),
+            )
+
+            build_gateway_image(self._client, self._gw_name, str(gateway_dir))
+
+            env = {}
+            for prov in self._gw_info.get("providers", {}).values():
+                for key, value in prov.get("config", {}).items():
+                    if isinstance(value, str) and value:
+                        env_key = f"{prov['name'].upper().replace('-', '_')}_{key.upper()}"
+                        env[env_key] = value
+
+            port = gateway.config.get("port", 8080) if gateway else 8080
+            provision_gateway(
+                self._client,
+                self._gw_name,
+                network,
+                routes_path=str(routes_path),
+                env=env,
+                port=port,
+            )
+
+            return ProvisionResult(
+                name=self.name,
+                success=True,
+                info={"gateway_name": self._gw_name, "port": port},
+            )
+        except Exception as e:
+            return ProvisionResult(
+                name=self.name,
+                success=False,
+                error=str(e),
+            )
+
+    def health_check(self) -> HealthCheck:
+        return NoopHealthCheck()
+
+    def destroy(self) -> None:
+        destroy_gateway(self._client, self._gw_name)

vystak_provider_docker-0.1.0/src/vystak_provider_docker/nodes/network.py

@@ -0,0 +1,40 @@
+"""DockerNetworkNode — creates the shared Docker network."""
+
+from vystak.provisioning.health import HealthCheck, NoopHealthCheck
+from vystak.provisioning.node import Provisionable, ProvisionResult
+
+NETWORK_NAME = "vystak-net"
+
+
+class DockerNetworkNode(Provisionable):
+    """Ensures the vystak-net Docker network exists."""
+
+    def __init__(self, client):
+        self._client = client
+
+    @property
+    def name(self) -> str:
+        return "network"
+
+    @property
+    def depends_on(self) -> list[str]:
+        return []
+
+    def provision(self, context: dict) -> ProvisionResult:
+        existing = self._client.networks.list(names=[NETWORK_NAME])
+        if existing:
+            network = existing[0]
+        else:
+            network = self._client.networks.create(NETWORK_NAME, driver="bridge")
+
+        return ProvisionResult(
+            name=self.name,
+            success=True,
+            info={"network_name": network.name, "network": network},
+        )
+
+    def health_check(self) -> HealthCheck:
+        return NoopHealthCheck()
+
+    def destroy(self) -> None:
+        pass  # Networks persist across deployments