gax-cli 0.4.0__py3-none-any.whl

gax/projection.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+MODEL_MAX_ROWS = 10
+MODEL_MAX_STRING = 500
+REDACT_KEYS = {"token", "secret", "password", "authorization"}
+
+
+def _redact(obj: Any) -> Any:
+    if isinstance(obj, dict):
+        out = {}
+        for k, v in obj.items():
+            if k.lower() in REDACT_KEYS:
+                out[k] = "[redacted]"
+            else:
+                out[k] = _redact(v)
+        return out
+    if isinstance(obj, list):
+        return [_redact(x) for x in obj]
+    if isinstance(obj, str) and len(obj) > MODEL_MAX_STRING:
+        return obj[:MODEL_MAX_STRING] + "…"
+    return obj
+
+
+def project_data(data: Any, surface: str) -> tuple[Any, dict[str, Any]]:
+    meta: dict[str, Any] = {}
+    if surface == "full":
+        return data, meta
+
+    if surface not in ("model", "human"):
+        surface = "model"
+
+    projected = _redact(copy.deepcopy(data))
+    if isinstance(projected, dict) and "items" in projected and isinstance(projected["items"], list):
+        items = projected["items"]
+        if len(items) > MODEL_MAX_ROWS:
+            projected["items"] = items[:MODEL_MAX_ROWS]
+            meta["truncated"] = True
+            meta["row_count"] = len(items)
+    return projected, meta

gax/registry.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from gax.paths import MANIFESTS_DIR, USER_MANIFESTS_DIR
+
+
+@dataclass
+class CommandManifest:
+    command: str
+    version: str
+    description: str
+    category: str
+    adapter: str
+    backend: list[str] = field(default_factory=list)
+    required_scopes: list[str] = field(default_factory=list)
+    side_effects: str = "read"
+    idempotent: bool = True
+    input_schema: dict[str, Any] = field(default_factory=dict)
+    output_schema: dict[str, Any] = field(default_factory=dict)
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def cmd_id(self) -> str:
+        return f"{self.command}@{self.version}"
+
+    @property
+    def schema_uri(self) -> str:
+        return f"https://schemas.gax.dev/{self.command.replace('.', '/')}/v{self.version.split('.')[0]}"
+
+
+class Registry:
+    """
+    Command registry.
+
+    Loads from two places, in order: the manifests bundled with the package, then
+    `~/.gax/manifests/`. The user directory wins on conflict, so installing a
+    profile or hand-editing a command survives a package upgrade instead of being
+    overwritten by it.
+    """
+
+    def __init__(self, manifests_dir: Path | None = None) -> None:
+        self._dir = manifests_dir or MANIFESTS_DIR
+        # An explicit dir (tests, alternate deployments) means exactly that dir.
+        self._extra_dirs: list[Path] = [] if manifests_dir else [USER_MANIFESTS_DIR]
+        self._commands: dict[str, CommandManifest] = {}
+        self.reload()
+
+    @property
+    def source_dirs(self) -> list[Path]:
+        return [self._dir, *self._extra_dirs]
+
+    def reload(self) -> None:
+        self._commands.clear()
+        for directory in self.source_dirs:
+            if directory.exists():
+                self._load_dir(directory)
+
+    def _load_dir(self, directory: Path) -> None:
+        for path in sorted(directory.glob("*.yaml")):
+            data = yaml.safe_load(path.read_text()) or {}
+            cmd = data.get("command")
+            if not cmd:
+                continue
+            self._commands[cmd] = CommandManifest(
+                command=cmd,
+                version=str(data.get("version", "1.0.0")),
+                description=str(data.get("description", "")),
+                category=str(data.get("category", "general")),
+                adapter=str(data.get("adapter", "mock")),
+                backend=list(data.get("backend") or []),
+                required_scopes=list(data.get("required_scopes") or []),
+                side_effects=str(data.get("side_effects", "read")),
+                idempotent=bool(data.get("idempotent", True)),
+                input_schema=dict(data.get("input_schema") or {}),
+                output_schema=dict(data.get("output_schema") or {}),
+                raw=data,
+            )
+
+    def get(self, command: str) -> CommandManifest | None:
+        return self._commands.get(command)
+
+    def list_commands(self) -> list[CommandManifest]:
+        return list(self._commands.values())
+
+    def search(self, query: str, limit: int = 5) -> list[CommandManifest]:
+        q = query.lower().strip()
+        if not q:
+            return self.list_commands()[:limit]
+        scored: list[tuple[int, CommandManifest]] = []
+        for m in self._commands.values():
+            hay = f"{m.command} {m.description} {m.category}".lower()
+            score = 0
+            if q in m.command.lower():
+                score += 10
+            if q in m.description.lower():
+                score += 5
+            for word in q.split():
+                if word in hay:
+                    score += 2
+            if score > 0:
+                scored.append((score, m))
+        scored.sort(key=lambda x: (-x[0], x[1].command))
+        return [m for _, m in scored[:limit]]
+
+    def doc_stub(self, command: str) -> dict[str, Any] | None:
+        m = self.get(command)
+        if not m:
+            return None
+        props = (m.input_schema or {}).get("properties") or {}
+        return {
+            "command": m.command,
+            "version": m.version,
+            "description": m.description,
+            "usage": f"gax {m.command} --repo owner/name",
+            "required_scopes": m.required_scopes,
+            "arguments": {
+                k: {
+                    "type": v.get("type", "string"),
+                    "description": v.get("description", ""),
+                    "required": k in ((m.input_schema or {}).get("required") or []),
+                }
+                for k, v in props.items()
+            },
+            "side_effects": m.side_effects,
+        }

gax/schemas/envelope.v1.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.gax.dev/envelope/v1",
+  "title": "GAX Envelope v1",
+  "type": "object",
+  "required": ["v", "ok", "cmd", "audit_id", "surface", "data", "meta"],
+  "properties": {
+    "v": { "const": 1 },
+    "ok": { "type": "boolean" },
+    "cmd": { "type": "string", "description": "command@version" },
+    "audit_id": { "type": "string" },
+    "schema": { "type": "string", "format": "uri" },
+    "surface": { "enum": ["model", "human", "full"] },
+    "data": {},
+    "meta": {
+      "type": "object",
+      "properties": {
+        "truncated": { "type": "boolean" },
+        "cursor": { "type": "string" },
+        "row_count": { "type": "integer" },
+        "duration_ms": { "type": "number" }
+      },
+      "additionalProperties": true
+    },
+    "error": {
+      "type": ["object", "null"],
+      "properties": {
+        "kind": { "type": "string" },
+        "message": { "type": "string" },
+        "retryable": { "type": "boolean" }
+      }
+    },
+    "next": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["cmd", "args"],
+        "properties": {
+          "cmd": { "type": "string" },
+          "args": { "type": "object" },
+          "reason": { "type": "string" }
+        }
+      }
+    }
+  }
+}

gax/secrets.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from gax.paths import ensure_gax_home
+
+
+def _use_keyring() -> bool:
+    try:
+        import keyring  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def _service_name(tenant: str, provider: str) -> str:
+    return f"gax:{tenant}:{provider}"
+
+
+def save_secret(tenant: str, provider: str, data: dict[str, Any], *, file_path: Path) -> None:
+    """Prefer OS keychain when keyring is installed; else encrypted-at-rest file (mode 600)."""
+    payload = json.dumps(data)
+    if _use_keyring():
+        import keyring
+
+        keyring.set_password(_service_name(tenant, provider), "oauth_tokens", payload)
+        # Remove plaintext file if migrating
+        if file_path.exists():
+            file_path.unlink()
+        return
+    ensure_gax_home()
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    file_path.write_text(payload)
+    file_path.chmod(0o600)
+
+
+def load_secret(tenant: str, provider: str, *, file_path: Path) -> dict[str, Any] | None:
+    if _use_keyring():
+        import keyring
+
+        raw = keyring.get_password(_service_name(tenant, provider), "oauth_tokens")
+        if raw:
+            return json.loads(raw)
+    if file_path.exists():
+        return json.loads(file_path.read_text())
+    return None

gax/side_effects.py

@@ -0,0 +1,67 @@
+"""
+Side-effect ladder — the danger level of a command, and the ceiling a capability
+is allowed to reach.
+
+Every manifest declares `side_effects: read | write | destructive`. Every capability
+carries a `max_side_effect` ceiling (default `read`). A capability may only invoke a
+command whose level is at or below its ceiling.
+
+**Why this exists as a second check.** The capability already carries an explicit
+command allowlist, so in principle naming the command is enough. But an allowlist is
+edited by humans under time pressure, and the failure mode is silent: add
+`k8s.pod.delete` to a token that was meant to be read-only and nothing complains. The
+ceiling makes that mistake inert — two independent things must be wrong before
+something gets deleted, and the second one has to be stated in the explicit language
+of danger rather than as an opaque command name.
+
+Defaults fail closed:
+  - a manifest with no/unknown `side_effects` is treated as `destructive`
+  - a capability with no ceiling is treated as `read`
+
+so a command added without thinking about danger is refused rather than allowed.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Ordered least → most dangerous. Index is the comparison key.
+LADDER: tuple[str, ...] = ("read", "write", "destructive")
+
+DEFAULT_CEILING = "read"
+# Unknown manifest levels fail closed at the top of the ladder.
+UNKNOWN_LEVEL = "destructive"
+
+
+def level_rank(level: str | None) -> int:
+    """Rank of a side-effect level. Unknown/missing → most dangerous."""
+    if not level:
+        return LADDER.index(UNKNOWN_LEVEL)
+    try:
+        return LADDER.index(str(level).strip().lower())
+    except ValueError:
+        return LADDER.index(UNKNOWN_LEVEL)
+
+
+def normalize(level: str | None) -> str:
+    """Canonical level name, failing closed on anything unrecognized."""
+    return LADDER[level_rank(level)]
+
+
+def capability_ceiling(claims: dict[str, Any]) -> str:
+    """
+    The ceiling this capability may reach.
+
+    Absent → `read`. A capability minted before ceilings existed therefore cannot
+    invoke a destructive command, which is the safe direction for that migration.
+    """
+    return normalize(claims.get("max_side_effect") or DEFAULT_CEILING)
+
+
+def exceeds_ceiling(claims: dict[str, Any], command_level: str | None) -> bool:
+    """True when `command_level` is more dangerous than the capability allows."""
+    return level_rank(command_level) > level_rank(capability_ceiling(claims))
+
+
+def is_destructive(level: str | None) -> bool:
+    return normalize(level) == "destructive"

gax/spiffe.py

@@ -0,0 +1,32 @@
+"""SPIFFE / workload identity hooks for gaxd (MVP)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+
+def workload_identity() -> dict[str, Any]:
+    """Read SPIFFE material from env (set by tbot, SPIRE agent, or K8s CSI)."""
+    cert = os.environ.get("GAX_SPIFFE_CERT_PATH", "")
+    key = os.environ.get("GAX_SPIFFE_KEY_PATH", "")
+    svid = os.environ.get("GAX_SPIFFE_SVID", "")
+    spiffe_id = os.environ.get("GAX_SPIFFE_ID", "")
+    out: dict[str, Any] = {
+        "enabled": bool(cert or svid or spiffe_id),
+        "spiffe_id": spiffe_id or None,
+        "cert_present": bool(cert and Path(cert).exists()),
+        "key_present": bool(key and Path(key).exists()),
+    }
+    if svid:
+        out["svid_jwt_prefix"] = svid[:20] + "…"
+    return out
+
+
+def attest_metadata() -> dict[str, Any]:
+    """Metadata attached to audit events when workload identity is configured."""
+    wi = workload_identity()
+    if not wi["enabled"]:
+        return {}
+    return {"workload_identity": wi}

gax/vault.py

@@ -0,0 +1,69 @@
+"""Multi-tenant secret vault (file MVP; HashiCorp Vault hook via env)."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from gax.paths import GAX_HOME, ensure_gax_home
+from gax.secrets import load_secret, save_secret
+
+VAULT_DIR = GAX_HOME / "vault"
+
+
+def _tenant_path(tenant: str) -> Path:
+    ensure_gax_home()
+    d = VAULT_DIR / tenant
+    d.mkdir(parents=True, exist_ok=True)
+    return d / "secrets.json"
+
+
+def vault_put(tenant: str, key: str, value: str) -> None:
+    hv = os.environ.get("GAX_HASHICORP_VAULT_ADDR")
+    if hv:
+        _vault_hc_put(hv, tenant, key, value)
+        return
+    path = _tenant_path(tenant)
+    data = load_secret(tenant, "vault", file_path=path) or {}
+    data[key] = value
+    save_secret(tenant, "vault", data, file_path=path)
+
+
+def vault_get(tenant: str, key: str) -> str | None:
+    hv = os.environ.get("GAX_HASHICORP_VAULT_ADDR")
+    if hv:
+        return _vault_hc_get(hv, tenant, key)
+    path = _tenant_path(tenant)
+    data = load_secret(tenant, "vault", file_path=path) or {}
+    return data.get(key)
+
+
+def _vault_hc_headers() -> dict[str, str]:
+    tok = os.environ.get("GAX_HASHICORP_VAULT_TOKEN", "")
+    h = {"Content-Type": "application/json"}
+    if tok:
+        h["X-Vault-Token"] = tok
+    return h
+
+
+def _vault_hc_put(addr: str, tenant: str, key: str, value: str) -> None:
+    path = f"{addr.rstrip('/')}/v1/secret/data/gax/{tenant}/{key}"
+    httpx.post(
+        path,
+        headers=_vault_hc_headers(),
+        json={"data": {"value": value}},
+        timeout=15.0,
+    ).raise_for_status()
+
+
+def _vault_hc_get(addr: str, tenant: str, key: str) -> str | None:
+    path = f"{addr.rstrip('/')}/v1/secret/data/gax/{tenant}/{key}"
+    r = httpx.get(path, headers=_vault_hc_headers(), timeout=15.0)
+    if r.status_code == 404:
+        return None
+    r.raise_for_status()
+    return (r.json().get("data") or {}).get("data", {}).get("value")

gax_cli-0.4.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: gax-cli
+Version: 0.4.0
+Summary: Governed execution layer for agent shell commands — capability-gated, audited, MCP-compatible
+Author: Sparsh Nagpal
+License: MIT
+Project-URL: Homepage, https://github.com/0sparsh2/GAX
+Project-URL: Repository, https://github.com/0sparsh2/GAX
+Project-URL: Documentation, https://github.com/0sparsh2/GAX/blob/main/docs/QUICKSTART.md
+Project-URL: Issues, https://github.com/0sparsh2/GAX/issues
+Keywords: ai-agents,mcp,model-context-protocol,agent-governance,capability-security,audit,llm-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: jsonschema>=4.20
+Requires-Dist: PyJWT>=2.8
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Provides-Extra: keyring
+Requires-Dist: keyring>=25.0; extra == "keyring"
+
+# GAX — Governed Agent eXecution
+
+**Your MCP gateway can't see `bash`. GAX governs both.**
+
+GAX is a governed execution layer for agent shell commands. Agents get a
+command-line-shaped surface; OAuth, policy, audit, and tenancy live in a sidecar the
+model never sees.
+
+The guarantee: **an agent can only run commands you registered, every invoke is checked
+against a capability token before any backend runs, and every invoke produces an
+`audit_id`.**
+
+It **complements MCP** rather than competing with it — MCP servers become adapters behind
+stable command names, so one policy file and one audit trail cover both your MCP calls
+and your shell calls.
+
+Full docs, research, and evaluation: **https://github.com/0sparsh2/GAX**
+
+---
+
+## Install
+
+```bash
+pip install gax-cli
+gax init --profile k8s --profile github
+```
+
+That creates `~/.gax`, mints a 30-day **read-only** capability, starts the sidecar, and
+registers 22 real commands. Measured on a clean machine: about a second.
+
+```bash
+gax k8s.pod.logs --pod web-1     # works immediately, no exports needed
+gax doctor                       # diagnose config, capability, sidecar, backends
+```
+
+## See it stop something dangerous
+
+```bash
+export GAX_K8S_MOCK=1            # no cluster needed
+gax k8s.namespace.delete --namespace prod
+```
+
+```json
+{
+  "ok": false,
+  "error": {
+    "kind": "policy_denied",
+    "message": "side_effects 'destructive' exceeds capability ceiling 'read'"
+  },
+  "audit_id": "aud_cef808f0fadd41e7"
+}
+```
+
+Refused before `kubectl` was ever spawned, and the denial is audited with its arguments.
+
+Even if the command sits on the token's allowlist it is *still* refused, because the
+danger ceiling is a separate control — **two independent things must be wrong before
+something gets deleted.**
+
+To run it, raise the ceiling deliberately, with `--dry-run` available first:
+
+```bash
+export GAX_CAP="$(gax auth cap-mint --command k8s.namespace.delete \
+  --scope k8s:namespaces:write --max-side-effect destructive --raw)"
+
+gax k8s.namespace.delete --namespace staging --dry-run
+```
+
+## Use it from any MCP client
+
+```bash
+claude mcp add gax -- gax-mcp
+```
+
+Publishes exactly three tools — `gax_search`, `gax_doc`, `gax_invoke` — keeping the
+registry behind them, so schema cost stays constant no matter how many commands you
+register.
+
+## Add your own command
+
+One YAML file in `~/.gax/manifests/`:
+
+```yaml
+command: db.migration.run
+version: "1.0.0"
+description: Apply pending migrations
+adapter: exec
+required_scopes: [db:schema:write]
+side_effects: destructive     # sets the ceiling required to invoke it
+input_schema:
+  type: object
+  properties:
+    env:     { type: string, description: Target environment }
+    dry_run: { type: boolean, description: Validate without applying }
+  required: [env]
+```
+
+CLI flags are generated from the schema. Omit `side_effects` and GAX fails closed —
+undeclared commands are treated as `destructive`.
+
+Generate manifests instead of writing them: `gax openapi generate spec.json`.
+
+## Commands
+
+| | |
+|---|---|
+| `gax init` / `gax doctor` | Setup and diagnostics |
+| `gax profile list` / `add` | Bundled command sets (`k8s`, `github`) |
+| `gax search` / `doc` / `schema` | Lazy discovery |
+| `gax <command>` | Invoke a registered command |
+| `gax auth cap-mint` | Mint a capability (`--max-side-effect read\|write\|destructive`) |
+| `gax auth login` | OAuth 2.0 device flow |
+| `gax plan run <file>` | Multi-step / parallel workflows |
+| `gax vault put` / `get` | Tenant secrets (file or HashiCorp) |
+| `gax compliance export` | SOC2-aligned audit export |
+| `gaxd start` / `stop` / `status` | Sidecar lifecycle |
+| `gax-mcp` | Run GAX as an MCP server (stdio) |
+
+Audit log: `~/.gax/audit.jsonl`, one JSON object per invocation, including denials.
+
+## Honest scope
+
+- Raw CLI costs ~3.5× fewer tokens than GAX on like-for-like tasks. Governance is not
+  free, and we publish that number rather than a flattering one.
+- Vault, SPIFFE, and OPA integrations are hooks and stubs, not production features.
+- The evaluation is a self-assessment by the author; methodology and known defects are
+  documented in the repository.
+
+MIT licensed. Issues and contributions: https://github.com/0sparsh2/GAX

gax_cli-0.4.0.dist-info/RECORD

@@ -0,0 +1,66 @@
+gax/__init__.py,sha256=MtEPF32M-McRPfaigQYR6LxocQx0UzKyWW5x7mbAp5A,63
+gax/audit.py,sha256=xsYEQ9OP2seWC4MJOrC9HCCinbJf6UCBg3hhXvCqVnc,1390
+gax/caps.py,sha256=R6UanAet-EEgAkuCUxm954e-3bsmUGe4sI6YEUODiVo,2889
+gax/cli.py,sha256=7wi9AVg5hcr5i4rYkPLFCNoWbyOBfCVD3tyJAFsrNiE,24173
+gax/client.py,sha256=wBlg_5q28K2XS5ixW6TPF6y7rQDbSK_Ws6EKgTZZePU,1838
+gax/compliance.py,sha256=xZ1tD__hxC0GMFiGtpGU6ZBbXrhStCV9oTojFJJqvvA,2025
+gax/daemon.py,sha256=ZblMjUu1nicmc6BTFP6arLrF1z2mfbdGrvYLSow75-8,5996
+gax/envelope.py,sha256=AF7qcfpI1y1XCLwFIeICgBE0vRbiMb1W0BaHkCjrpr4,1443
+gax/executor.py,sha256=WU2Wyjl0MZsY4vWpFl4EqY9DfjmC8UdU1IzHZS7952k,4091
+gax/macaroons_cap.py,sha256=VJPKletpgwOPdkxB7Ltes_xBfsoisCSTCslv1-hKZRM,2517
+gax/mcp_client.py,sha256=UQwM_upcT54uUgiMv-GGUxMQGGnamkBFZlDO6UnAXNk,3587
+gax/mcp_server.py,sha256=wiC_ErL0FWC3PwfHNXgZstNfORDCiGyfDCaXuZG4e38,10249
+gax/oauth.py,sha256=U4ZoTjI1RefFWcRp35DiWlCYYgqp4Z2K0hKsBO8U-4w,6069
+gax/onboarding.py,sha256=sQUWnsR6M92GHoCyFK7PAki7X1Jp57UnY2IaOvGTzps,13008
+gax/opa_policy.py,sha256=2JfkvZjTtC16Du34icypxzpLf1yR34NvmZ9BgydiciU,1432
+gax/openapi_gen.py,sha256=siVSMBq6Ua45yPHWD0aJc1D6fBkVcq-mxNcPNi1AIQ8,3297
+gax/otel_audit.py,sha256=D0ReRaA-mYLPj7LfA3MHQ5-lnKyHH7YeHWyT-fRvaQQ,1327
+gax/paths.py,sha256=nzU2t51yGfldhw_w_n9L_b-dAYGogCmiY1JvopxoDug,1574
+gax/plan.py,sha256=H0djp11oao9k2hJkz46CiOlm6SFD_xNzb4Tjqtpa44A,4793
+gax/policy.py,sha256=ZVCo20a--Fy9fgW9IK9moRrCSrQ2TSc4PerfvQnBWGE,1353
+gax/policy_bundle.py,sha256=jUYHu_TJddIZPcxk_rQHceWqg_BrqwQjxFFcwK3fkY4,2200
+gax/profiles.py,sha256=ScNM2AjEv5_LCJ4krIBNGsydSZhx-xgCwA4RuGDSUfI,4475
+gax/projection.py,sha256=pv1DmGK1bNjXXnHR7p2FzYSKE_BVaozizdYFMknjruw,1247
+gax/registry.py,sha256=Ba27QZAbIzmReC3oKRkwdjo6KhQUtn4vDq5bfDqlzvM,4683
+gax/secrets.py,sha256=KDGNl3dyGTGYenb6tKaCsSO_m2lK7pId3Syi0xujZxk,1356
+gax/side_effects.py,sha256=gtYKUJ7ZtCWcbhigjQXjcm2bE3z3-FqyqN5izh41NEE,2566
+gax/spiffe.py,sha256=F5EBL3I1Sxhp3uJHWWEHrKSgslsgerGJpKAVtuCTkt0,1039
+gax/vault.py,sha256=c9gFLLGCbaWOycIksvQyj_QPsy9mAVmJQYBZn4Sz2AU,1972
+gax/adapters/__init__.py,sha256=2tFcSP8OoYq9z8b9suULv-r8QV3nFz737pX86qABScc,69
+gax/adapters/base.py,sha256=WvenAGsiGe3SpyjKxCAc9rBXr8bCb7PZTYbi3Ze5aTQ,887
+gax/adapters/exec_adapter.py,sha256=RdeyxAlyoD6BOMGXE65MnIhS8wcLrlInGVxEjO0fi3o,8008
+gax/adapters/http_adapter.py,sha256=M7E79JIm4bfMwERWDH7ggziTrBKuDVb2THoVbUWAbHQ,1078
+gax/adapters/k8s_adapter.py,sha256=p3pvwxFoBrPsf6ECr-CEqgCiNNi8Xso4oxZcTmHsYZo,10873
+gax/adapters/mcp_bridge.py,sha256=srprT_oBQVT5vxNEO2Ebe9FW1TSNYgU5MnuVZ57SjBI,3610
+gax/adapters/mock_adapter.py,sha256=mCButxH3n1Ctal8tPQDPqAuZ_PEZfuew-JfvyoF9mQU,1885
+gax/config/oauth_providers.yaml,sha256=yHT9uGVGSFStT2-1pQf-2FXfRpYfmjwXhVknXvxx7ac,730
+gax/config/policy.rego,sha256=mJEUxxhQegn2U87vvIaRp0YTc8P6ydOwaojBbFtDJ-g,298
+gax/config/policy.yaml,sha256=-1eaJdVEDo4LrowFFBcij-P1QvGQ2UK4-skFwQYXksI,1948
+gax/manifests/aws.s3.list.yaml,sha256=yNrKSXGMe7RPwqgfFq9y3JRHMr1R-JrKhs-5-ivDvXo,342
+gax/manifests/demo.echo.yaml,sha256=yUUG9QjYLa775FfRPe2WL3_iNHEN1XI7o3bWh4qngqQ,357
+gax/manifests/gh.pr.list.yaml,sha256=ydaisewA8GqZ_rlR6I5UtdDFT1AUEKDTc9JO3-pXKvc,826
+gax/manifests/gh.pr.view.yaml,sha256=kJVGwUUguesQWBtm1tWGQnpz6c4-BuJzWONixCfuZJU,565
+gax/manifests/jira.issue.get.yaml,sha256=k7Bz28o6gKyFaIsfwUt-Wx0PJaFu9puPc3GyAPUM1oI,353
+gax/manifests/k8s.deployment.scale.yaml,sha256=ic-HlPhFQlX2ArGos1SYIfxe8YGJ36lTaCChAwJHEP0,906
+gax/manifests/k8s.pod.delete.yaml,sha256=gSGcVn_E7J1Za3Uem7WghNUV0OpZLdVqzZQFcKrw4N8,768
+gax/manifests/kubectl.get.pods.yaml,sha256=GLSHU6rrumgCNN0UJaRJim-mj30K_WxLABlBPFe5Kmo,391
+gax/manifests/mcp.github.list_pulls.yaml,sha256=nWDUGOnh-QW5UhMnNIOE_wg41Z68o4DQ2SJHa_YF3ag,605
+gax/manifests/pet_findpetsbystatus.yaml,sha256=8mvQ9F8RVIuqp5AAES0drPbP1oPMN-t1HgEjkOpEj50,319
+gax/manifests/pet_getpetbyid.yaml,sha256=lJ8nWdnXLWeOyLlRhavtCo4TElw0WdwiNRTZto2t8SQ,305
+gax/profiles/github/gh.issue.list.yaml,sha256=Qh80Z3MHmKMW7UiwMRwddTSri3Aij6uYuTQZvS3Ks2U,487
+gax/profiles/github/gh.issue.view.yaml,sha256=LlFdKLjkutG6t-j-JGTnK-VOo9O6g2OcUBxOw43YBnw,412
+gax/profiles/github/gh.pr.comment.yaml,sha256=ax-RTErkvEpxI3Vgwgx3-DvSw6FysQwhlx35ZoPHdWI,580
+gax/profiles/github/gh.pr.merge.yaml,sha256=wkuFsbIOCTxkWACLRToMEw_q2vr-V6Z88rcDKvCbhoE,625
+gax/profiles/github/gh.run.list.yaml,sha256=csBxO1qh_m8SFSZCfW95PjxX59KBxfulS7AXdT3gPx0,421
+gax/profiles/k8s/k8s.deployment.list.yaml,sha256=sXsE0KfPoikaIDIkH1_bjsBOM_hAu2zZYNd5eAa3QoQ,350
+gax/profiles/k8s/k8s.deployment.restart.yaml,sha256=d5_viY8w02yu--hdjfWONQC1dLKXbSR5pc4yjLPx8qk,553
+gax/profiles/k8s/k8s.namespace.delete.yaml,sha256=3FZkRnC8Q2i_9fvXuYDB3Zlf2BLUumm1pr4AarY6YJ8,499
+gax/profiles/k8s/k8s.pod.describe.yaml,sha256=QtEMd6u_UAWKCxyPDM9jrOxlqur3D5qK0TdVasBl49w,430
+gax/profiles/k8s/k8s.pod.logs.yaml,sha256=NySwRyDbnBbqwGXMDvaE6AQwnk2mQDeJZN9BAOZlovI,595
+gax/profiles/k8s/k8s.service.list.yaml,sha256=yQv8Xe3Xd-k7P2ZKOpHSoUx88V-m_2p-LvLyvr4us2o,341
+gax/schemas/envelope.v1.json,sha256=8xJzS2DOa9OLboSTTF9g2z3qsCw6CbPC-8z7zWjZjwk,1321
+gax_cli-0.4.0.dist-info/METADATA,sha256=ag56qONifVADjiKjh2jZn1NfrGjgugnLBAF5rvTHCjc,5713
+gax_cli-0.4.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+gax_cli-0.4.0.dist-info/entry_points.txt,sha256=Jnu0YxVDRRiSZ-x_aZr3XD6xWp7KTkzrICfxgF9yZM8,90
+gax_cli-0.4.0.dist-info/top_level.txt,sha256=1LX0rekJftkdwIHUy--CeuWoPGXAtOkBkJsa4AfuUAQ,4
+gax_cli-0.4.0.dist-info/RECORD,,

gax_cli-0.4.0.dist-info/WHEEL

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

gax_cli-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+gax = gax.cli:main
+gax-mcp = gax.mcp_server:main
+gaxd = gax.daemon:main