hydracept 0.1.0__tar.gz

hydracept-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: hydracept
+Version: 0.1.0
+Summary: Python client and CLI for the Hydracept public API — AI execution infrastructure for games.
+Author: Zencode
+License: MIT
+Project-URL: Homepage, https://hydracept.com
+Project-URL: Documentation, https://hydracept.com/docs
+Project-URL: Repository, https://github.com/hydracept/hydracept-public
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: typer>=0.15.0
+Requires-Dist: rich>=13.9.0
+Requires-Dist: PyYAML>=6.0
+
+# hydracept
+
+Python client for the Hydracept public API — AI execution infrastructure for games.
+
+```bash
+pip install hydracept
+```
+
+```python
+from hydracept import HydraceptClient
+
+client = HydraceptClient("https://api.hydracept.com", token="...")
+job = client.submit_capability_job(
+    "image.generate.v1",
+    {
+        "context": {
+            "productId": "my-product",
+            "projectId": "cpr_...",
+            "environment": "development",
+        },
+        "input": {"prompt": "cute slime icon"},
+        "execution": {"executionPreference": "automatic"},
+        "idempotencyKey": "demo-1",
+    },
+)
+```
+
+CLI: `hydracept login`, `hydracept init`, `hydracept doctor`
+
+Docs: https://docs.hydracept.com
+
+A Zencode product · © Zencode Consulting Inc.

hydracept-0.1.0/README.md

@@ -0,0 +1,32 @@
+# hydracept
+
+Python client for the Hydracept public API — AI execution infrastructure for games.
+
+```bash
+pip install hydracept
+```
+
+```python
+from hydracept import HydraceptClient
+
+client = HydraceptClient("https://api.hydracept.com", token="...")
+job = client.submit_capability_job(
+    "image.generate.v1",
+    {
+        "context": {
+            "productId": "my-product",
+            "projectId": "cpr_...",
+            "environment": "development",
+        },
+        "input": {"prompt": "cute slime icon"},
+        "execution": {"executionPreference": "automatic"},
+        "idempotencyKey": "demo-1",
+    },
+)
+```
+
+CLI: `hydracept login`, `hydracept init`, `hydracept doctor`
+
+Docs: https://docs.hydracept.com
+
+A Zencode product · © Zencode Consulting Inc.

hydracept-0.1.0/hydracept/__init__.py

@@ -0,0 +1,115 @@
+"""Hydracept Python client — public API surface."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Iterator
+
+import httpx
+
+
+class HydraceptClient:
+    def __init__(self, base_url: str, token: str, *, timeout: float = 120.0) -> None:
+        self.base_url = base_url.rstrip("/")
+        self._headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+        self._timeout = timeout
+
+    def _get(self, path: str) -> dict[str, Any]:
+        response = httpx.get(
+            f"{self.base_url}{path}",
+            headers=self._headers,
+            timeout=self._timeout,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _post(self, path: str, body: dict[str, Any] | None = None) -> dict[str, Any]:
+        response = httpx.post(
+            f"{self.base_url}{path}",
+            headers=self._headers,
+            json=body,
+            timeout=self._timeout,
+        )
+        response.raise_for_status()
+        if not response.content:
+            return {}
+        return response.json()
+
+    def capabilities(self) -> dict[str, Any]:
+        return self._get("/v1/capabilities")
+
+    def describe_capability(self, key: str) -> dict[str, Any]:
+        return self._get(f"/v1/capabilities/{key}")
+
+    def invoke_capability(self, key: str, body: dict[str, Any]) -> dict[str, Any]:
+        return self._post(f"/v1/capabilities/{key}/invoke", body)
+
+    def submit_capability_job(self, key: str, body: dict[str, Any]) -> dict[str, Any]:
+        return self._post(f"/v1/capabilities/{key}/jobs", body)
+
+    def get_job(self, job_id: str) -> dict[str, Any]:
+        return self._get(f"/v1/jobs/{job_id}")
+
+    def get_job_receipt(self, job_id: str) -> dict[str, Any]:
+        return self._get(f"/v1/jobs/{job_id}/receipt")
+
+    def cancel_job(self, job_id: str) -> dict[str, Any]:
+        return self._post(f"/v1/jobs/{job_id}/cancel")
+
+    def agent_context(self) -> dict[str, Any]:
+        return self._get("/v1/agent-context")
+
+    def diagnostics_session(self) -> dict[str, Any]:
+        return self._get("/v1/diagnostics/session")
+
+    def policy_dry_run(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._post("/v1/policy-evaluations", body)
+
+
+def iter_invocation_events(
+    base_url: str,
+    token: str,
+    execution_id: str,
+    *,
+    last_event_id: str | None = None,
+) -> Iterator[dict[str, Any]]:
+    """Maintained SSE helper for legacy invocation streams."""
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "text/event-stream",
+    }
+    if last_event_id:
+        headers["Last-Event-ID"] = last_event_id
+    with httpx.stream(
+        "GET",
+        f"{base_url.rstrip('/')}/v1/invocations/{execution_id}/events",
+        headers=headers,
+        timeout=None,
+    ) as response:
+        response.raise_for_status()
+        event_name = "message"
+        data_lines: list[str] = []
+        event_id: str | None = None
+        for line in response.iter_lines():
+            if line == "":
+                if data_lines:
+                    yield {
+                        "id": event_id,
+                        "event": event_name,
+                        "data": json.loads("\n".join(data_lines)),
+                    }
+                event_name = "message"
+                data_lines = []
+                event_id = None
+                continue
+            if line.startswith(":"):
+                continue
+            if line.startswith("id:"):
+                event_id = line[3:].strip()
+            elif line.startswith("event:"):
+                event_name = line[6:].strip()
+            elif line.startswith("data:"):
+                data_lines.append(line[5:].lstrip())

hydracept-0.1.0/hydracept/cli/__init__.py

@@ -0,0 +1 @@
+"""Package marker for public Hydracept CLI."""

hydracept-0.1.0/hydracept/cli/main.py

@@ -0,0 +1,433 @@
+"""Public Hydracept CLI — device login, init, doctor, capabilities, jobs, consumer-check."""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+import time
+import webbrowser
+from pathlib import Path
+from typing import Any
+
+import httpx
+import typer
+from rich.console import Console
+
+from hydracept import HydraceptClient
+from hydracept.consumer_boundary import scan_path
+
+app = typer.Typer(help="Hydracept public CLI — AI execution infrastructure for games.")
+capabilities_app = typer.Typer(help="Capability discovery and invoke")
+jobs_app = typer.Typer(help="Durable jobs")
+app.add_typer(capabilities_app, name="capabilities")
+app.add_typer(jobs_app, name="jobs")
+console = Console()
+
+DEFAULT_API = os.environ.get("HYDRACEPT_API_URL", "https://api.hydracept.com")
+
+
+def _config_dir(project_root: Path) -> Path:
+    return project_root / ".hydracept"
+
+
+def _secrets_path(project_root: Path) -> Path:
+    return _config_dir(project_root) / "secrets.json"
+
+
+def _config_path(project_root: Path) -> Path:
+    return _config_dir(project_root) / "config.json"
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _write_secrets(project_root: Path, payload: dict[str, Any]) -> Path:
+    path = _secrets_path(project_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    existing = _read_json(path)
+    existing.update(payload)
+    path.write_text(json.dumps(existing, indent=2) + "\n", encoding="utf-8")
+    try:
+        path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass
+    return path
+
+
+def _ensure_gitignore(project_root: Path) -> None:
+    gitignore = project_root / ".gitignore"
+    hints = [".hydracept/secrets.json", ".hydracept/*.env", ".env.hydracept"]
+    existing = gitignore.read_text(encoding="utf-8") if gitignore.exists() else ""
+    additions = [h for h in hints if h not in existing]
+    if not additions:
+        return
+    with gitignore.open("a", encoding="utf-8") as handle:
+        handle.write("\n# Hydracept local secrets\n")
+        for hint in additions:
+            handle.write(f"{hint}\n")
+    console.print(f"[green]Updated[/green] {gitignore}")
+
+
+def _resolve_token(project_root: Path, token: str | None) -> str:
+    if token:
+        return token
+    env = (
+        os.environ.get("HYDRACEPT_API_KEY")
+        or os.environ.get("HYDRACEPT_TOKEN")
+        or ""
+    ).strip()
+    if env:
+        return env
+    secrets = _read_json(_secrets_path(project_root))
+    # Prefer project API credential over human session token
+    return str(secrets.get("apiKey") or secrets.get("token") or "")
+
+
+def _auth_headers(token: str) -> dict[str, str]:
+    return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+
+
+@app.command("login")
+def login_cmd(
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    project_root: Path = typer.Option(Path.cwd(), "--project-root"),
+    open_browser: bool = typer.Option(True, "--open/--no-open"),
+) -> None:
+    """Authenticate a human via device authorization (headless-friendly)."""
+    start = httpx.post(f"{api.rstrip('/')}/v1/auth/device/start", timeout=30.0)
+    start.raise_for_status()
+    payload = start.json()
+    user_code = payload.get("userCode") or payload.get("user_code")
+    verification = (
+        payload.get("verificationUri")
+        or payload.get("verification_uri")
+        or f"{os.environ.get('HYDRACEPT_SITE_URL', 'https://hydracept.com')}/activate"
+    )
+    console.print("[bold]Starting Hydracept authentication...[/bold]")
+    console.print(f"Open: [cyan]{verification}[/cyan]")
+    console.print(f"Code: [bold]{user_code}[/bold]")
+    if open_browser:
+        try:
+            webbrowser.open(str(verification))
+        except Exception:
+            pass
+    device_code = payload.get("deviceCode") or payload.get("device_code")
+    while True:
+        token_resp = httpx.post(
+            f"{api.rstrip('/')}/v1/auth/device/token",
+            json={"deviceCode": device_code},
+            timeout=30.0,
+        )
+        if token_resp.status_code == 428:
+            time.sleep(2)
+            continue
+        token_resp.raise_for_status()
+        data = token_resp.json()
+        token = data.get("token")
+        if not token:
+            console.print("[red]No token in device response[/red]")
+            raise typer.Exit(1)
+        _write_secrets(project_root, {"token": token, "kind": "human_session"})
+        _ensure_gitignore(project_root)
+        console.print("[green]Signed in[/green] (human session). Run [bold]hydracept init[/bold] next.")
+        break
+
+
+@app.command("init")
+def init_cmd(
+    apply: bool = typer.Option(False, "--apply"),
+    yes: bool = typer.Option(False, "--yes"),
+    print_env: bool = typer.Option(False, "--print-env"),
+    rotate: bool = typer.Option(False, "--rotate"),
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    project_root: Path = typer.Option(Path.cwd(), "--project-root"),
+) -> None:
+    """Idempotent project bootstrap. login = human; init = service principal."""
+    config_dir = _config_dir(project_root)
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_path = _config_path(project_root)
+    secrets = _read_json(_secrets_path(project_root))
+    human_token = str(secrets.get("token") or "")
+    if not human_token:
+        console.print("[red]No human session. Run hydracept login first.[/red]")
+        raise typer.Exit(1)
+
+    config: dict[str, Any] = {
+        "apiBaseUrl": api.rstrip("/"),
+        "environment": "development",
+        "detectedStack": _detect_stack(project_root),
+    }
+    if config_path.exists():
+        config = {**_read_json(config_path), **config}
+
+    try:
+        context = httpx.get(
+            f"{api.rstrip('/')}/v1/session/context",
+            headers=_auth_headers(human_token),
+            timeout=30.0,
+        )
+        if context.status_code == 200:
+            ctx = context.json()
+            if ctx.get("productId"):
+                config["productId"] = ctx["productId"]
+            env = ctx.get("environment")
+            if isinstance(env, dict) and env.get("slug"):
+                config["environment"] = env["slug"]
+            project = ctx.get("project")
+            if isinstance(project, dict):
+                config["projectId"] = project.get("id")
+                config["projectName"] = project.get("displayName")
+            org = ctx.get("organization")
+            if isinstance(org, dict):
+                config["organizationId"] = org.get("id")
+                config["organizationName"] = org.get("displayName")
+    except httpx.HTTPError as exc:
+        console.print(f"[yellow]session/context unavailable:[/yellow] {exc}")
+
+    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+    console.print(f"[green]Wrote[/green] {config_path}")
+
+    existing_key = str(secrets.get("apiKey") or "")
+    if existing_key and not rotate and apply:
+        console.print("[green]Reusing existing project API credential[/green]")
+        if print_env:
+            console.print(f"HYDRACEPT_API_KEY={existing_key}")
+        return
+
+    if not apply:
+        console.print("Run with --apply to create/select a project API credential.")
+        return
+    if not yes:
+        console.print("Refusing --apply without --yes")
+        raise typer.Exit(1)
+
+    # Prefer Free bootstrap when org missing
+    api_key: str | None = existing_key or None
+    if not api_key or rotate:
+        bootstrap = httpx.post(
+            f"{api.rstrip('/')}/v1/onboarding/bootstrap-free",
+            headers=_auth_headers(human_token),
+            json={},
+            timeout=60.0,
+        )
+        if bootstrap.status_code < 400:
+            body = bootstrap.json()
+            api_key = (
+                body.get("apiKey")
+                or body.get("token")
+                or (body.get("credential") or {}).get("secret")
+            )
+            if body.get("projectId"):
+                config["projectId"] = body["projectId"]
+            if body.get("organizationId"):
+                config["organizationId"] = body["organizationId"]
+            config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+        elif not api_key:
+            console.print(
+                f"[red]bootstrap-free failed ({bootstrap.status_code}). "
+                "Create an API key in Studio or retry after Free activation.[/red]"
+            )
+            raise typer.Exit(1)
+
+    if api_key:
+        secrets_path = _write_secrets(
+            project_root,
+            {"apiKey": api_key, "kind": "service_principal"},
+        )
+        _ensure_gitignore(project_root)
+        env_path = config_dir / "local.env"
+        env_path.write_text(
+            f"HYDRACEPT_API_URL={api.rstrip('/')}\n"
+            f"HYDRACEPT_API_KEY={api_key}\n"
+            f"HYDRACEPT_PROJECT={config.get('projectId') or ''}\n"
+            f"HYDRACEPT_ENVIRONMENT={config.get('environment') or 'development'}\n",
+            encoding="utf-8",
+        )
+        try:
+            env_path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+        except OSError:
+            pass
+        console.print(f"[green]Wrote credential to[/green] {secrets_path} and {env_path}")
+        if print_env:
+            console.print(f"HYDRACEPT_API_KEY={api_key}")
+        else:
+            console.print("[dim]API key not printed (use --print-env to display).[/dim]")
+
+
+def _detect_stack(project_root: Path) -> str:
+    is_dotnet = any(project_root.glob("*.csproj")) or (project_root / "Assets").exists()
+    is_unity = (project_root / "Assets").exists() and (project_root / "ProjectSettings").exists()
+    if is_unity:
+        return "unity"
+    if is_dotnet:
+        return "dotnet"
+    if (project_root / "package.json").exists():
+        return "node"
+    if (project_root / "pyproject.toml").exists() or (project_root / "requirements.txt").exists():
+        return "python"
+    return "unknown"
+
+
+@app.command("doctor")
+def doctor_cmd(
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    project_root: Path = typer.Option(Path.cwd(), "--project-root"),
+    token: str = typer.Option("", "--token"),
+) -> None:
+    resolved = _resolve_token(project_root, token or None)
+    if not resolved:
+        console.print("[red]No API credential. Run hydracept login && hydracept init --apply --yes[/red]")
+        raise typer.Exit(1)
+    client = HydraceptClient(api, resolved)
+    session = client.diagnostics_session()
+    console.print("[green]diagnostics/session[/green]")
+    console.print_json(data=session)
+    try:
+        providers = httpx.get(
+            f"{api.rstrip('/')}/v1/diagnostics/providers",
+            headers=_auth_headers(resolved),
+            timeout=30.0,
+        )
+        if providers.status_code == 200:
+            console.print("[green]diagnostics/providers[/green]")
+            console.print_json(data=providers.json())
+    except httpx.HTTPError:
+        pass
+
+
+@app.command("agent-context")
+def agent_context_cmd(
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    output: Path = typer.Option(Path(".hydracept/agent-context.json"), "--output"),
+) -> None:
+    response = httpx.get(f"{api.rstrip('/')}/v1/agent-context", timeout=60.0)
+    response.raise_for_status()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(response.json(), indent=2), encoding="utf-8")
+    console.print(f"[green]Wrote[/green] {output}")
+
+
+@app.command("health")
+def health_cmd(api: str = typer.Option(DEFAULT_API, "--api")) -> None:
+    response = httpx.get(f"{api.rstrip('/')}/healthz", timeout=15.0)
+    response.raise_for_status()
+    console.print_json(data=response.json())
+
+
+@app.command("consumer-check")
+def consumer_check_cmd(
+    path: Path = typer.Option(Path.cwd(), "--path"),
+    strict: bool = typer.Option(False, "--strict"),
+) -> None:
+    code, detail = scan_path(path)
+    if code != 0:
+        console.print(detail)
+        raise typer.Exit(1)
+    console.print(f"[green]{detail}[/green]")
+    if strict:
+        console.print("[green]Consumer boundary check passed[/green]")
+
+
+@capabilities_app.command("list")
+def capabilities_list(
+    api: str = typer.Option(DEFAULT_API, "--api"),
+) -> None:
+    response = httpx.get(f"{api.rstrip('/')}/v1/capabilities", timeout=30.0)
+    response.raise_for_status()
+    console.print_json(data=response.json())
+
+
+@capabilities_app.command("describe")
+def capabilities_describe(
+    key: str = typer.Argument(...),
+    api: str = typer.Option(DEFAULT_API, "--api"),
+) -> None:
+    response = httpx.get(f"{api.rstrip('/')}/v1/capabilities/{key}", timeout=30.0)
+    response.raise_for_status()
+    console.print_json(data=response.json())
+
+
+@capabilities_app.command("invoke")
+def capabilities_invoke(
+    key: str = typer.Argument(...),
+    body: Path = typer.Argument(...),
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    project_root: Path = typer.Option(Path.cwd(), "--project-root"),
+    token: str = typer.Option("", "--token"),
+) -> None:
+    resolved = _resolve_token(project_root, token or None)
+    payload = json.loads(body.read_text(encoding="utf-8"))
+    client = HydraceptClient(api, resolved)
+    console.print_json(data=client.invoke_capability(key, payload))
+
+
+@jobs_app.command("submit")
+def jobs_submit(
+    capability_key: str = typer.Argument(...),
+    body: Path = typer.Argument(...),
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    project_root: Path = typer.Option(Path.cwd(), "--project-root"),
+    token: str = typer.Option("", "--token"),
+    watch: bool = typer.Option(False, "--watch"),
+) -> None:
+    resolved = _resolve_token(project_root, token or None)
+    payload = json.loads(body.read_text(encoding="utf-8"))
+    client = HydraceptClient(api, resolved)
+    data = client.submit_capability_job(capability_key, payload)
+    console.print_json(data=data)
+    if not watch:
+        return
+    job_id = data.get("jobId") or data.get("executionId")
+    while job_id:
+        status = client.get_job(str(job_id))
+        state = status.get("status") or status.get("currentStatus")
+        console.print(state)
+        if str(state).lower() in {"succeeded", "failed", "canceled", "cancelled"}:
+            console.print_json(data=status)
+            break
+        time.sleep(2)
+
+
+@jobs_app.command("get")
+def jobs_get(
+    job_id: str = typer.Argument(...),
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    project_root: Path = typer.Option(Path.cwd(), "--project-root"),
+    token: str = typer.Option("", "--token"),
+) -> None:
+    client = HydraceptClient(api, _resolve_token(project_root, token or None))
+    console.print_json(data=client.get_job(job_id))
+
+
+@jobs_app.command("receipt")
+def jobs_receipt(
+    job_id: str = typer.Argument(...),
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    project_root: Path = typer.Option(Path.cwd(), "--project-root"),
+    token: str = typer.Option("", "--token"),
+) -> None:
+    client = HydraceptClient(api, _resolve_token(project_root, token or None))
+    console.print_json(data=client.get_job_receipt(job_id))
+
+
+@jobs_app.command("cancel")
+def jobs_cancel(
+    job_id: str = typer.Argument(...),
+    api: str = typer.Option(DEFAULT_API, "--api"),
+    project_root: Path = typer.Option(Path.cwd(), "--project-root"),
+    token: str = typer.Option("", "--token"),
+) -> None:
+    client = HydraceptClient(api, _resolve_token(project_root, token or None))
+    console.print_json(data=client.cancel_job(job_id))
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

hydracept-0.1.0/hydracept/consumer_boundary.py

@@ -0,0 +1,109 @@
+"""Embedded consumer-boundary scanner for the public hydracept CLI."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from importlib import resources
+from pathlib import Path
+
+import yaml
+
+FORBIDDEN_HOSTS = [
+    "api.openai.com",
+    "api.elevenlabs.io",
+    "api.anthropic.com",
+]
+
+FORBIDDEN_LEGACY_PATHS = [
+    "/v1/visual/jobs",
+    "/v1/invocations",
+    "POST /v1/jobs",
+]
+
+FORBIDDEN_PACKAGE_PATTERNS = [
+    re.compile(r"ProjectReference.*Zencode Forge", re.I),
+    re.compile(r"file:.*Zencode Forge/clients", re.I),
+    re.compile(r"file:.*[/\\]Hydracept[/\\](apps|packages|workers)", re.I),
+    re.compile(r"from hydracept_api\b", re.I),
+    re.compile(r"import hydracept_api\b", re.I),
+    re.compile(r"from forge_api\b", re.I),
+    re.compile(r"import forge_api\b", re.I),
+    re.compile(r"@zencode/forge-client", re.I),
+    re.compile(r"Zencode\.Forge\.Client", re.I),
+    re.compile(r"zencode-forge", re.I),
+]
+
+LEGACY_STALE_PATTERNS = [
+    re.compile(r"Zencode Forge", re.I),
+    re.compile(r"\bforge consumer-check\b", re.I),
+    re.compile(r"\bforge doctor\b", re.I),
+    re.compile(r"\bforge login\b", re.I),
+    re.compile(r"forge\.zencode", re.I),
+    re.compile(r"\bFORGE_[A-Z0-9_]+\b"),
+    re.compile(r"forge-dev-token"),
+]
+
+SCAN_EXTENSIONS = {".cs", ".ts", ".tsx", ".js", ".mjs", ".py", ".json", ".csproj"}
+
+
+def _load_exceptions() -> list[dict]:
+    try:
+        data_files = resources.files("hydracept.data")
+        text = (data_files / "hydracept-consumer-exceptions.yaml").read_text(encoding="utf-8")
+        data = yaml.safe_load(text) or {}
+        return list(data.get("exceptions") or [])
+    except Exception:
+        return []
+
+
+def _expired_exceptions(exceptions: list[dict]) -> list[str]:
+    now = datetime.now(timezone.utc).date()
+    expired: list[str] = []
+    for entry in exceptions:
+        expires = entry.get("expires")
+        if not expires:
+            continue
+        try:
+            exp_date = datetime.strptime(str(expires), "%Y-%m-%d").date()
+        except ValueError:
+            expired.append(str(entry))
+            continue
+        if exp_date < now:
+            expired.append(str(entry))
+    return expired
+
+
+def scan(root: Path) -> list[str]:
+    violations: list[str] = []
+    for path in root.rglob("*"):
+        if not path.is_file() or path.suffix.lower() not in SCAN_EXTENSIONS:
+            continue
+        if "node_modules" in path.parts or ".git" in path.parts or "dist" in path.parts:
+            continue
+        text = path.read_text(encoding="utf-8", errors="replace")
+        rel = path.relative_to(root).as_posix()
+        for host in FORBIDDEN_HOSTS:
+            if host in text:
+                violations.append(f"{rel}: direct provider host {host}")
+        for legacy_path in FORBIDDEN_LEGACY_PATHS:
+            if legacy_path in text:
+                violations.append(f"{rel}: legacy API path {legacy_path}")
+        for pattern in FORBIDDEN_PACKAGE_PATTERNS:
+            if pattern.search(text):
+                violations.append(f"{rel}: forbidden package reference ({pattern.pattern})")
+        for pattern in LEGACY_STALE_PATTERNS:
+            if pattern.search(text):
+                violations.append(f"{rel}: legacy Forge branding ({pattern.pattern})")
+    return violations
+
+
+def scan_path(target: Path) -> tuple[int, str]:
+    expired = _expired_exceptions(_load_exceptions())
+    if expired:
+        return 1, "Expired hydracept-consumer-exceptions:\n" + "\n".join(f"  - {e}" for e in expired)
+    violations = scan(target)
+    if violations:
+        detail = "Consumer boundary violations:\n" + "\n".join(f"  - {v}" for v in violations)
+        return 1, detail
+    return 0, f"Consumer boundary OK ({target})"

hydracept-0.1.0/hydracept/data/hydracept-consumer-exceptions.yaml

@@ -0,0 +1,4 @@
+# Temporary registry of product-side Hydracept bypasses during consumer migration.
+# Each entry expires; hydracept consumer-check fails on expired entries.
+
+exceptions: []

hydracept-0.1.0/hydracept.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: hydracept
+Version: 0.1.0
+Summary: Python client and CLI for the Hydracept public API — AI execution infrastructure for games.
+Author: Zencode
+License: MIT
+Project-URL: Homepage, https://hydracept.com
+Project-URL: Documentation, https://hydracept.com/docs
+Project-URL: Repository, https://github.com/hydracept/hydracept-public
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: typer>=0.15.0
+Requires-Dist: rich>=13.9.0
+Requires-Dist: PyYAML>=6.0
+
+# hydracept
+
+Python client for the Hydracept public API — AI execution infrastructure for games.
+
+```bash
+pip install hydracept
+```
+
+```python
+from hydracept import HydraceptClient
+
+client = HydraceptClient("https://api.hydracept.com", token="...")
+job = client.submit_capability_job(
+    "image.generate.v1",
+    {
+        "context": {
+            "productId": "my-product",
+            "projectId": "cpr_...",
+            "environment": "development",
+        },
+        "input": {"prompt": "cute slime icon"},
+        "execution": {"executionPreference": "automatic"},
+        "idempotencyKey": "demo-1",
+    },
+)
+```
+
+CLI: `hydracept login`, `hydracept init`, `hydracept doctor`
+
+Docs: https://docs.hydracept.com
+
+A Zencode product · © Zencode Consulting Inc.

hydracept-0.1.0/hydracept.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+hydracept/__init__.py
+hydracept/consumer_boundary.py
+hydracept.egg-info/PKG-INFO
+hydracept.egg-info/SOURCES.txt
+hydracept.egg-info/dependency_links.txt
+hydracept.egg-info/entry_points.txt
+hydracept.egg-info/requires.txt
+hydracept.egg-info/top_level.txt
+hydracept/cli/__init__.py
+hydracept/cli/main.py
+hydracept/data/__init__.py
+hydracept/data/hydracept-consumer-exceptions.yaml

hydracept-0.1.0/hydracept.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hydracept-0.1.0/hydracept.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hydracept = hydracept.cli.main:app

hydracept-0.1.0/hydracept.egg-info/requires.txt

@@ -0,0 +1,4 @@
+httpx>=0.27.0
+typer>=0.15.0
+rich>=13.9.0
+PyYAML>=6.0

hydracept-0.1.0/hydracept.egg-info/top_level.txt

@@ -0,0 +1 @@
+hydracept

hydracept-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hydracept"
+version = "0.1.0"
+description = "Python client and CLI for the Hydracept public API — AI execution infrastructure for games."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Zencode" }]
+dependencies = [
+  "httpx>=0.27.0",
+  "typer>=0.15.0",
+  "rich>=13.9.0",
+  "PyYAML>=6.0",
+]
+
+[project.urls]
+Homepage = "https://hydracept.com"
+Documentation = "https://hydracept.com/docs"
+Repository = "https://github.com/hydracept/hydracept-public"
+
+[project.scripts]
+hydracept = "hydracept.cli.main:app"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["hydracept*"]
+
+[tool.setuptools.package-data]
+hydracept = ["data/*.yaml"]

hydracept-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+