geyser-open 0.1.0__tar.gz

geyser_open-0.1.0/.gitignore

@@ -0,0 +1,24 @@
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+dist/
+build/
+.geyser/
+.release-build/
+.release-python/
+release-standalone/
+release-assets/
+*.tar.gz
+*.whl
+*.sig
+*.crt
+*.pem
+*.key
+coverage.xml
+site/

geyser_open-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.5
+Name: geyser-open
+Version: 0.1.0
+Summary: Public developer CLI for durable Geyser agents
+Project-URL: Homepage, https://geyserlabs.ai/developers
+Project-URL: Documentation, https://docs.geyserlabs.ai
+Project-URL: Repository, https://github.com/geyserlabs/geyser-open
+Project-URL: Security, https://github.com/geyserlabs/geyser-open/security/policy
+Author-email: Geyser Labs <security@geyserlabs.ai>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: geyser-sdk==0.1.0
+Requires-Dist: keyring<26,>=25.6
+Requires-Dist: platformdirs<5,>=4.3
+Provides-Extra: test
+Requires-Dist: pytest-asyncio<2,>=0.24; extra == 'test'
+Requires-Dist: pytest<10,>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# geyser-open
+
+Installs the `geyser` command for scaffolding, validating, testing, packaging,
+signing, staging, canarying, and inspecting durable Geyser work.
+
+`--yes` skips only the local confirmation prompt. It never bypasses server
+scopes, tenant policy, approval binding, qualification, or promotion gates.

geyser_open-0.1.0/README.md

@@ -0,0 +1,7 @@
+# geyser-open
+
+Installs the `geyser` command for scaffolding, validating, testing, packaging,
+signing, staging, canarying, and inspecting durable Geyser work.
+
+`--yes` skips only the local confirmation prompt. It never bypasses server
+scopes, tenant policy, approval binding, qualification, or promotion gates.

geyser_open-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "geyser-open"
+version = "0.1.0"
+description = "Public developer CLI for durable Geyser agents"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [{ name = "Geyser Labs", email = "security@geyserlabs.ai" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+]
+dependencies = [
+  "geyser-sdk==0.1.0",
+  "keyring>=25.6,<26",
+  "platformdirs>=4.3,<5",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8,<10", "pytest-asyncio>=0.24,<2"]
+
+[project.scripts]
+geyser = "geyser_cli.__main__:main"
+
+[project.urls]
+Homepage = "https://geyserlabs.ai/developers"
+Documentation = "https://docs.geyserlabs.ai"
+Repository = "https://github.com/geyserlabs/geyser-open"
+Security = "https://github.com/geyserlabs/geyser-open/security/policy"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/geyser_cli"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/geyser_cli", "tests", "README.md", "pyproject.toml"]

geyser_open-0.1.0/src/geyser_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Geyser developer CLI."""
+
+__version__ = "0.1.0"

geyser_open-0.1.0/src/geyser_cli/__main__.py

@@ -0,0 +1,375 @@
+"""Command line entry point for the public Geyser developer platform."""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+import shutil
+import subprocess
+import sys
+import uuid
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any, cast
+
+import httpx
+from geyser_sdk import (
+    ApprovalDecision,
+    CancelRequest,
+    ForkCreate,
+    GeyserClient,
+    LocalEmulator,
+    PackagePromotion,
+    PackageUpload,
+    ProblemError,
+    TypedTask,
+    bytes_digest,
+    normalize_contract,
+    validate_outcome,
+)
+
+from . import __version__
+from .auth import DeviceAuthorization, login_device, login_service_token
+from .credentials import CredentialStore
+from .extensions import inspect_archive, package_extension, test_extension, validate_extension
+from .output import emit
+from .scaffolds import KINDS, scaffold
+
+DEFAULT_API_URL = "https://agents.geyserlabs.ai"
+DEFAULT_SCOPES = ["development:read", "runs:read", "packages:upload", "packages:stage"]
+
+
+def _add_path(command: argparse.ArgumentParser) -> None:
+    command.add_argument("path", nargs="?", type=Path, default=Path.cwd())
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="geyser", description="Build governed durable agents.")
+    parser.add_argument("--api-url", default=os.getenv("GEYSER_API_URL", DEFAULT_API_URL))
+    parser.add_argument("--profile", default=os.getenv("GEYSER_PROFILE", "default"))
+    parser.add_argument("--json", action="store_true", help="emit stable JSON")
+    parser.add_argument("--allow-file-credentials", action="store_true")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    login = commands.add_parser("login", help="authenticate with OAuth device flow")
+    login.add_argument("--scope", action="append", dest="scopes")
+    login.add_argument("--no-browser", action="store_true")
+    login.add_argument("--service-token-stdin", action="store_true", help=argparse.SUPPRESS)
+    commands.add_parser("logout", help="remove the current profile credential")
+    commands.add_parser("doctor", help="check local configuration and public API reachability")
+
+    init = commands.add_parser("init", help="create a safe extension scaffold")
+    init.add_argument("kind", choices=KINDS)
+    init.add_argument("name")
+    init.add_argument("--output", type=Path, default=Path.cwd())
+    for name in ("validate", "test", "dev", "package"):
+        _add_path(commands.add_parser(name))
+    validate_result = commands.add_parser("validate-outcome")
+    validate_result.add_argument("contract", type=Path)
+    validate_result.add_argument("result", type=Path)
+    sign = commands.add_parser("sign", help="sign exact package bytes using Sigstore")
+    sign.add_argument("archive", type=Path)
+    sign.add_argument("--bundle", type=Path)
+    publish = commands.add_parser("publish", help="upload exact signed bytes to staging")
+    publish.add_argument("archive", type=Path)
+    publish.add_argument("--stage", action="store_true", required=True)
+    publish.add_argument("--signature-bundle", type=Path)
+    publish.add_argument("--yes", action="store_true")
+    promote = commands.add_parser("promote", help="request promotion of exact staged bytes")
+    promote.add_argument("package_id")
+    promote.add_argument("--digest", required=True)
+    promote.add_argument("--canary", action="store_true", required=True)
+    promote.add_argument("--yes", action="store_true")
+    commands.add_parser("status", help="list package lifecycle state")
+
+    runs = commands.add_parser("runs")
+    run_commands = runs.add_subparsers(dest="runs_command", required=True)
+    run_list = run_commands.add_parser("list")
+    run_list.add_argument("--customer", action="store_true")
+    for name in ("get", "watch", "trace"):
+        command = run_commands.add_parser(name)
+        command.add_argument("run_id")
+        command.add_argument("--customer", action="store_true")
+    fork = run_commands.add_parser("fork")
+    fork.add_argument("run_id")
+    fork.add_argument("--child-run-id", required=True)
+    fork.add_argument("--expected-sequence", type=int, required=True)
+    fork.add_argument("--reason-code", default="developer_requested")
+    fork.add_argument("--yes", action="store_true")
+    stop = run_commands.add_parser("stop")
+    stop.add_argument("run_id")
+    stop.add_argument("--expected-sequence", type=int, required=True)
+    stop.add_argument("--reason-code", default="developer_requested")
+    stop.add_argument("--yes", action="store_true")
+
+    approvals = commands.add_parser("approvals")
+    approval_commands = approvals.add_subparsers(dest="approvals_command", required=True)
+    approval_commands.add_parser("list")
+    approval_get = approval_commands.add_parser("get")
+    approval_get.add_argument("approval_id")
+    decide = approval_commands.add_parser("decide")
+    decide.add_argument("run_id")
+    decide.add_argument("approval_id")
+    decide.add_argument("decision", choices=("approve", "reject"))
+    decide.add_argument("--expected-sequence", type=int, required=True)
+    decide.add_argument("--binding-digest", required=True)
+    decide.add_argument("--reason-code", required=True)
+    decide.add_argument("--yes", action="store_true")
+    capabilities = commands.add_parser("capabilities")
+    capabilities.add_argument("--agent", required=True)
+    commands.add_parser("version")
+    return parser
+
+
+def _store(args: argparse.Namespace) -> CredentialStore:
+    return CredentialStore(args.profile, allow_file_fallback=args.allow_file_credentials)
+
+
+def _client(args: argparse.Namespace) -> GeyserClient:
+    credential = _store(args).load()
+    if credential is None:
+        raise RuntimeError("not authenticated; run `geyser login`")
+    return GeyserClient(args.api_url, credential.access_token)
+
+
+def _confirm(args: argparse.Namespace, preview: dict[str, Any]) -> None:
+    emit({"preview": preview, "server_authority_required": True}, machine=args.json)
+    if args.yes:
+        return
+    if not sys.stdin.isatty() or input("Continue? [y/N] ").strip().casefold() not in {"y", "yes"}:
+        raise RuntimeError("operation canceled before server authorization")
+
+
+def _manifest_from_archive(path: Path) -> dict[str, Any]:
+    import zipfile
+
+    with zipfile.ZipFile(path) as archive:
+        return cast(dict[str, Any], json.loads(archive.read("geyser-package.json")))
+
+
+def _handle_local(args: argparse.Namespace) -> Any:
+    if args.command == "init":
+        return {"path": os.fspath(scaffold(args.kind, args.name, args.output)), "created": True}
+    if args.command == "validate":
+        return {"valid": True, **validate_extension(args.path)}
+    if args.command == "test":
+        result = test_extension(args.path)
+        if result["failed"]:
+            raise RuntimeError(f"frozen cases failed: {result['failed']}")
+        return result
+    if args.command == "package":
+        return package_extension(args.path)
+    if args.command == "validate-outcome":
+        contract = normalize_contract(json.loads(args.contract.read_text(encoding="utf-8")))
+        if contract is None:
+            raise ValueError("outcome contract is empty")
+        validate_outcome(contract, json.loads(args.result.read_text(encoding="utf-8")))
+        return {"valid": True, "contract_digest": contract["contract_digest"]}
+    if args.command == "dev":
+        root = args.path.expanduser().resolve()
+        result = test_extension(root)
+        task = TypedTask(
+            task_id="local-task",
+            context_id="local-context",
+            prompt_digest="sha256:" + "0" * 64,
+            model_ref="deterministic:echo",
+        )
+        emulator = LocalEmulator()
+        emulator.admit("local-run", task)
+        emulator.append(
+            "local-run",
+            event_type="run.completed",
+            key="complete",
+            expected_sequence=1,
+            data={
+                "extension_digest": bytes_digest(
+                    root.joinpath("geyser-package.json").read_bytes()
+                )
+            },
+        )
+        return {"extension": result, "run": emulator.project("local-run"), "network_used": False}
+    raise RuntimeError("unknown local command")
+
+
+def _doctor(args: argparse.Namespace) -> dict[str, Any]:
+    credential = _store(args).load()
+    reachable = False
+    api_version = ""
+    try:
+        response = httpx.get(f"{args.api_url.rstrip('/')}/api/v1/openapi.json", timeout=5)
+        reachable = response.status_code == 200
+        if reachable:
+            api_version = str(response.json().get("info", {}).get("version") or "")
+    except httpx.HTTPError:
+        pass
+    return {
+        "python": sys.version.split()[0],
+        "cli_version": __version__,
+        "api_url": args.api_url,
+        "api_reachable": reachable,
+        "api_version": api_version,
+        "authenticated": credential is not None,
+        "profile": args.profile,
+    }
+
+
+def _handle_network(args: argparse.Namespace) -> Any:
+    with _client(args) as client:
+        if args.command == "status":
+            return client.list_packages()
+        if args.command == "capabilities":
+            return client.capabilities(agent_name=args.agent)
+        if args.command == "runs":
+            if args.runs_command == "list":
+                return client.list_runs(customer=args.customer)
+            if args.runs_command == "get":
+                return client.get_run(args.run_id, customer=args.customer)
+            if args.runs_command == "trace":
+                return client.trace(args.run_id, customer=args.customer)
+            if args.runs_command == "watch":
+                return {"events": list(client.watch_events(args.run_id, customer=args.customer))}
+            if args.runs_command == "stop":
+                operation = {
+                    "operation": "stop_run",
+                    "run_id": args.run_id,
+                    "expected_sequence": args.expected_sequence,
+                }
+                _confirm(args, operation)
+                request = CancelRequest(
+                    cancellation_id="cancel_" + uuid.uuid4().hex,
+                    expected_sequence=args.expected_sequence,
+                    reason_code=args.reason_code,
+                )
+                return client.cancel_run(args.run_id, request)
+            operation = {
+                "operation": "fork_run",
+                "run_id": args.run_id,
+                "child_run_id": args.child_run_id,
+                "expected_sequence": args.expected_sequence,
+            }
+            _confirm(args, operation)
+            fork_request = ForkCreate(
+                fork_id="fork_" + uuid.uuid4().hex,
+                child_run_id=args.child_run_id,
+                expected_sequence=args.expected_sequence,
+                reason_code=args.reason_code,
+            )
+            return client.fork(args.run_id, fork_request)
+        if args.command == "approvals":
+            if args.approvals_command == "list":
+                return client.list_approvals()
+            if args.approvals_command == "get":
+                return client.get_approval(args.approval_id)
+            operation = {
+                "operation": "approval_decision",
+                "run_id": args.run_id,
+                "approval_id": args.approval_id,
+                "decision": args.decision,
+                "binding_digest": args.binding_digest,
+            }
+            _confirm(args, operation)
+            decision = ApprovalDecision(
+                decision_id="decision_" + uuid.uuid4().hex,
+                decision=args.decision,
+                expected_approval_sequence=args.expected_sequence,
+                binding_digest=args.binding_digest,
+                reason_code=args.reason_code,
+            )
+            return client.decide_approval(args.run_id, args.approval_id, decision)
+        if args.command == "publish":
+            archive = args.archive.expanduser().resolve()
+            details = inspect_archive(archive)
+            manifest = _manifest_from_archive(archive)
+            _confirm(args, {"operation": "package_upload", "stage": "staging", **details})
+            bundle = {}
+            if args.signature_bundle:
+                bundle = json.loads(args.signature_bundle.read_text(encoding="utf-8"))
+            upload = PackageUpload(
+                name=str(manifest["name"]),
+                version=str(manifest["version"]),
+                digest=str(details["digest"]),
+                media_type="application/vnd.geyser.extension+zip",
+                content_base64=base64.b64encode(archive.read_bytes()).decode(),
+                signature_bundle=bundle,
+            )
+            return client.upload_package(upload, idempotency_key=str(details["digest"]))
+        if args.command == "promote":
+            _confirm(args, {
+                "operation": "package_promotion",
+                "package_id": args.package_id,
+                "target": "canary",
+                "expected_digest": args.digest,
+            })
+            promotion = PackagePromotion(
+                promotion_id="promote_" + uuid.uuid4().hex,
+                target="canary",
+                expected_digest=args.digest,
+            )
+            return client.promote_package(args.package_id, promotion)
+    raise RuntimeError("unknown network command")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        if args.command == "version":
+            value: Any = {"geyser_open": __version__}
+        elif args.command == "login":
+            store = _store(args)
+            if args.service_token_stdin:
+                value = login_service_token(store, sys.stdin.readline())
+            else:
+                def notify(device: DeviceAuthorization) -> None:
+                    emit({
+                        "verification_uri": device.verification_uri,
+                        "user_code": device.user_code,
+                    }, machine=args.json)
+
+                value = login_device(
+                    args.api_url,
+                    store,
+                    scopes=args.scopes or DEFAULT_SCOPES,
+                    open_browser=not args.no_browser,
+                    notify=notify,
+                )
+        elif args.command == "logout":
+            value = {"removed": _store(args).delete(), "profile": args.profile}
+        elif args.command == "doctor":
+            value = _doctor(args)
+        elif args.command in {"init", "validate", "validate-outcome", "test", "dev", "package"}:
+            value = _handle_local(args)
+        elif args.command == "sign":
+            archive = args.archive.expanduser().resolve()
+            inspect_archive(archive)
+            bundle = (
+                args.bundle or archive.with_suffix(archive.suffix + ".sigstore.json")
+            ).resolve()
+            executable = shutil.which("sigstore")
+            if executable is None:
+                raise RuntimeError("Sigstore CLI is not installed")
+            result = subprocess.run(  # noqa: S603 - resolved executable and argv, no shell
+                [executable, "sign", "--bundle", os.fspath(bundle), os.fspath(archive)],
+                check=False,
+            )
+            if result.returncode:
+                raise RuntimeError("Sigstore signing failed; no package lifecycle state changed")
+            value = {"signed": True, "archive": os.fspath(archive), "bundle": os.fspath(bundle)}
+        else:
+            value = _handle_network(args)
+        emit(value, machine=args.json)
+        return 0
+    except (OSError, ValueError, RuntimeError, ProblemError, httpx.HTTPError) as exc:
+        if args.json:
+            emit({"error": type(exc).__name__, "detail": str(exc)}, machine=True)
+        else:
+            print(f"geyser: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+
+
+__all__ = ["main"]

geyser_open-0.1.0/src/geyser_cli/auth.py

@@ -0,0 +1,100 @@
+"""OAuth device flow for humans and bounded service tokens for CI."""
+
+from __future__ import annotations
+
+import time
+import webbrowser
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from .credentials import CredentialStore, StoredCredential
+
+CLIENT_ID = "geyser-public-cli"
+
+
+@dataclass(frozen=True, slots=True)
+class DeviceAuthorization:
+    device_code: str
+    user_code: str
+    verification_uri: str
+    verification_uri_complete: str
+    expires_in: int
+    interval: int
+
+
+def login_device(
+    base_url: str,
+    store: CredentialStore,
+    *,
+    scopes: list[str],
+    open_browser: bool = True,
+    timeout: float = 10.0,
+    notify: Callable[[DeviceAuthorization], None] | None = None,
+) -> dict[str, Any]:
+    with httpx.Client(base_url=base_url.rstrip("/"), timeout=timeout) as client:
+        response = client.post(
+            "/api/v1/oauth/device/code",
+            json={"client_id": CLIENT_ID, "scope": " ".join(scopes)},
+        )
+        if response.status_code >= 400:
+            raise RuntimeError(
+                f"device authorization could not start ({response.status_code})"
+            )
+        device = DeviceAuthorization(**response.json())
+        if notify:
+            notify(device)
+        if open_browser:
+            webbrowser.open(device.verification_uri_complete or device.verification_uri)
+        deadline = time.monotonic() + device.expires_in
+        interval = max(1, device.interval)
+        while time.monotonic() < deadline:
+            token_response = client.post(
+                "/api/v1/oauth/token",
+                json={
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                    "device_code": device.device_code,
+                    "client_id": CLIENT_ID,
+                },
+            )
+            value = token_response.json()
+            if token_response.status_code == 200:
+                credential = StoredCredential(
+                    access_token=str(value["access_token"]),
+                    token_type=str(value.get("token_type") or "Bearer"),
+                    expires_at=time.time() + float(value.get("expires_in") or 0),
+                    scope=str(value.get("scope") or ""),
+                    customer_id=int(value.get("customer_id") or 0),
+                    project_id=str(value.get("project_id") or ""),
+                )
+                backend = store.save(credential)
+                return {
+                    "authenticated": True,
+                    "storage": backend,
+                    "scope": credential.scope.split(),
+                    "customer_id": credential.customer_id,
+                    "project_id": credential.project_id,
+                }
+            error = str(value.get("error") or "")
+            if error == "authorization_pending":
+                time.sleep(interval)
+                continue
+            if error == "slow_down":
+                interval += 5
+                time.sleep(interval)
+                continue
+            failure = error or str(token_response.status_code)
+            raise RuntimeError(f"device authorization failed: {failure}")
+    raise RuntimeError("device authorization expired")
+
+
+def login_service_token(store: CredentialStore, token: str) -> dict[str, Any]:
+    if not token.strip():
+        raise ValueError("service token input was empty")
+    backend = store.save(StoredCredential(access_token=token.strip()))
+    return {"authenticated": True, "storage": backend, "credential_type": "service"}
+
+
+__all__ = ["CLIENT_ID", "DeviceAuthorization", "login_device", "login_service_token"]

geyser_open-0.1.0/src/geyser_cli/credentials.py

@@ -0,0 +1,97 @@
+"""Credential storage with keychain-first, explicitly opted-in file fallback."""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+from dataclasses import dataclass
+
+import keyring
+from keyring.errors import KeyringError
+from platformdirs import user_config_path
+
+SERVICE = "ai.geyser.developer-cli"
+
+
+@dataclass(frozen=True, slots=True)
+class StoredCredential:
+    access_token: str
+    token_type: str = "Bearer"  # noqa: S105 - OAuth token scheme, not a secret
+    expires_at: float = 0
+    scope: str = ""
+    customer_id: int = 0
+    project_id: str = ""
+
+
+class CredentialStore:
+    def __init__(self, profile: str = "default", *, allow_file_fallback: bool = False) -> None:
+        self.profile = profile
+        self.allow_file_fallback = allow_file_fallback
+        self.path = user_config_path("geyser", "Geyser Labs") / "credentials.json"
+
+    def save(self, credential: StoredCredential) -> str:
+        payload = json.dumps(credential.__dict__ if hasattr(credential, "__dict__") else {
+            "access_token": credential.access_token,
+            "token_type": credential.token_type,
+            "expires_at": credential.expires_at,
+            "scope": credential.scope,
+            "customer_id": credential.customer_id,
+            "project_id": credential.project_id,
+        })
+        try:
+            keyring.set_password(SERVICE, self.profile, payload)
+            return "os-keychain"
+        except (KeyringError, RuntimeError):
+            if not self.allow_file_fallback:
+                raise RuntimeError(
+                    "OS keychain is unavailable; rerun with --allow-file-credentials to opt in "
+                    "to a permission-restricted file"
+                ) from None
+        self.path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        existing: dict[str, str] = {}
+        if self.path.exists():
+            existing = json.loads(self.path.read_text(encoding="utf-8"))
+        existing[self.profile] = payload
+        temporary = self.path.with_suffix(".tmp")
+        temporary.write_text(json.dumps(existing), encoding="utf-8")
+        os.chmod(temporary, stat.S_IRUSR | stat.S_IWUSR)
+        temporary.replace(self.path)
+        return "restricted-file"
+
+    def load(self) -> StoredCredential | None:
+        payload: str | None = None
+        try:
+            payload = keyring.get_password(SERVICE, self.profile)
+        except (KeyringError, RuntimeError):
+            pass
+        if payload is None and self.allow_file_fallback and self.path.exists():
+            mode = stat.S_IMODE(self.path.stat().st_mode)
+            if mode & 0o077:
+                raise RuntimeError("credential fallback file permissions are not 0600")
+            payload = json.loads(self.path.read_text(encoding="utf-8")).get(self.profile)
+        if payload is None:
+            return None
+        value = json.loads(payload)
+        return StoredCredential(**value)
+
+    def delete(self) -> bool:
+        removed = False
+        try:
+            if keyring.get_password(SERVICE, self.profile) is not None:
+                keyring.delete_password(SERVICE, self.profile)
+                removed = True
+        except (KeyringError, RuntimeError):
+            pass
+        if self.allow_file_fallback and self.path.exists():
+            values = json.loads(self.path.read_text(encoding="utf-8"))
+            removed = values.pop(self.profile, None) is not None or removed
+            if values:
+                self.path.write_text(json.dumps(values), encoding="utf-8")
+                os.chmod(self.path, 0o600)
+            else:
+                self.path.unlink()
+        return removed
+
+
+__all__ = ["CredentialStore", "StoredCredential"]

geyser_open-0.1.0/src/geyser_cli/extensions.py

@@ -0,0 +1,151 @@
+"""Validation, deterministic packaging, and frozen extension tests."""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+import zipfile
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from geyser_sdk import bytes_digest
+from pydantic import BaseModel, ConfigDict, Field
+
+from .scaffolds import KINDS
+
+MAX_FILE_BYTES = 2 * 1024 * 1024
+MAX_PACKAGE_BYTES = 10 * 1024 * 1024
+IGNORED_PARTS = frozenset({".git", ".geyser", ".venv", "__pycache__"})
+
+
+class ExtensionManifest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    schema_version: int = 1
+    kind: str
+    name: str
+    version: str
+    permissions: list[str] = Field(default_factory=list, max_length=128)
+
+
+def _load_json(path: Path) -> Any:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"invalid JSON file {path}: {exc}") from exc
+
+
+def validate_extension(root: Path) -> dict[str, Any]:
+    root = root.expanduser().resolve()
+    if not root.is_dir():
+        raise ValueError(f"extension directory does not exist: {root}")
+    manifest_path = root / "geyser-package.json"
+    manifest = ExtensionManifest.model_validate(_load_json(manifest_path))
+    if manifest.schema_version != 1 or manifest.kind not in KINDS:
+        raise ValueError("unsupported extension manifest kind or schema version")
+    files = 0
+    total = 0
+    for path in sorted(root.rglob("*")):
+        relative = path.relative_to(root)
+        if set(relative.parts) & IGNORED_PARTS:
+            continue
+        mode = path.lstat().st_mode
+        if stat.S_ISLNK(mode) or not (stat.S_ISREG(mode) or stat.S_ISDIR(mode)):
+            raise ValueError(f"extension contains unsafe file type: {relative}")
+        if path.is_file():
+            size = path.stat().st_size
+            if size > MAX_FILE_BYTES:
+                raise ValueError(f"extension file exceeds 2 MiB: {relative}")
+            files += 1
+            total += size
+    if total > MAX_PACKAGE_BYTES:
+        raise ValueError("extension exceeds the 10 MiB unpacked bound")
+    cases_path = root / "evals" / "cases.json"
+    cases = _load_json(cases_path)
+    if not isinstance(cases, dict) or cases.get("frozen") is not True:
+        raise ValueError("evals/cases.json must declare frozen=true")
+    rows = cases.get("cases")
+    if not isinstance(rows, list) or not rows:
+        raise ValueError("evals/cases.json must contain at least one case")
+    if not any(isinstance(row, dict) and row.get("critical") is True for row in rows):
+        raise ValueError("at least one frozen critical denial case is required")
+    return {"manifest": manifest.model_dump(), "files": files, "size_bytes": total}
+
+
+def test_extension(root: Path) -> dict[str, Any]:
+    validation = validate_extension(root)
+    cases = _load_json(root.expanduser().resolve() / "evals" / "cases.json")["cases"]
+    failed = [row.get("case_id", "unknown") for row in cases if row.get("expected") not in {
+        "success", "deny_without_explicit_authority"
+    }]
+    return {
+        **validation,
+        "cases": len(cases),
+        "passed": len(cases) - len(failed),
+        "failed": failed,
+    }
+
+
+def package_extension(root: Path, output: Path | None = None) -> dict[str, Any]:
+    root = root.expanduser().resolve()
+    validation = validate_extension(root)
+    manifest = validation["manifest"]
+    output = output or root / ".geyser" / "dist" / (
+        f"{manifest['name']}-{manifest['version']}.geyser.zip"
+    )
+    output = output.expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as archive:
+        for path in sorted(root.rglob("*")):
+            relative = path.relative_to(root)
+            if not path.is_file() or set(relative.parts) & IGNORED_PARTS:
+                continue
+            info = zipfile.ZipInfo(PurePosixPath(relative).as_posix(), (1980, 1, 1, 0, 0, 0))
+            info.compress_type = zipfile.ZIP_DEFLATED
+            info.external_attr = (stat.S_IFREG | 0o644) << 16
+            archive.writestr(info, path.read_bytes())
+    package_bytes = output.read_bytes()
+    if len(package_bytes) > MAX_PACKAGE_BYTES:
+        output.unlink(missing_ok=True)
+        raise ValueError("extension archive exceeds 10 MiB")
+    return {
+        "path": os.fspath(output),
+        "name": manifest["name"],
+        "version": manifest["version"],
+        "digest": bytes_digest(package_bytes),
+        "size_bytes": len(package_bytes),
+        "media_type": "application/vnd.geyser.extension+zip",
+    }
+
+
+def inspect_archive(path: Path) -> dict[str, Any]:
+    path = path.expanduser().resolve()
+    if path.stat().st_size > MAX_PACKAGE_BYTES:
+        raise ValueError("archive exceeds 10 MiB")
+    total = 0
+    names: set[str] = set()
+    with zipfile.ZipFile(path) as archive:
+        for info in archive.infolist():
+            pure = PurePosixPath(info.filename)
+            if pure.is_absolute() or ".." in pure.parts or "" in pure.parts:
+                raise ValueError("archive contains path traversal")
+            if info.filename in names:
+                raise ValueError("archive contains duplicate paths")
+            names.add(info.filename)
+            mode = info.external_attr >> 16
+            if stat.S_ISLNK(mode):
+                raise ValueError("archive contains a symbolic link")
+            total += info.file_size
+            if info.file_size > MAX_FILE_BYTES or total > MAX_PACKAGE_BYTES:
+                raise ValueError("archive exceeds unpacked safety bounds")
+    return {"path": os.fspath(path), "digest": bytes_digest(path.read_bytes()), "files": len(names)}
+
+
+__all__ = [
+    "ExtensionManifest",
+    "inspect_archive",
+    "package_extension",
+    "test_extension",
+    "validate_extension",
+]

geyser_open-0.1.0/src/geyser_cli/output.py

@@ -0,0 +1,31 @@
+"""Stable human and machine-readable command output."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import BaseModel
+
+
+def serializable(value: Any) -> Any:
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="json")
+    if isinstance(value, dict):
+        return {key: serializable(child) for key, child in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [serializable(child) for child in value]
+    return value
+
+
+def emit(value: Any, *, machine: bool) -> None:
+    normalized = serializable(value)
+    if machine:
+        print(json.dumps(normalized, sort_keys=True, separators=(",", ":"), ensure_ascii=False))
+    elif isinstance(normalized, str):
+        print(normalized)
+    else:
+        print(json.dumps(normalized, indent=2, sort_keys=True, ensure_ascii=False))
+
+
+__all__ = ["emit", "serializable"]

geyser_open-0.1.0/src/geyser_cli/scaffolds.py

@@ -0,0 +1,120 @@
+"""Safe extension scaffolds used by ``geyser init``."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+KINDS = ("skill", "connector", "tool", "evaluator", "model-profile", "agent-bundle")
+_NAME = re.compile(r"^[a-z][a-z0-9-]{1,63}$")
+
+
+def _json(value: object) -> str:
+    return json.dumps(value, indent=2, sort_keys=True, ensure_ascii=False) + "\n"
+
+
+def scaffold_files(kind: str, name: str) -> dict[str, str]:
+    common = {
+        "geyser-package.json": _json({
+            "schema_version": 1,
+            "kind": kind,
+            "name": name,
+            "version": "0.1.0",
+            "permissions": [],
+        }),
+        "README.md": (
+            f"# {name}\n\nA credential-free `{kind}` extension for Geyser Open. "
+            "Declared permissions do not grant authority; server policy remains authoritative.\n"
+        ),
+        "evals/cases.json": _json({
+            "schema_version": 1,
+            "frozen": True,
+            "cases": [
+                {"case_id": "bounded-success-1", "critical": False, "expected": "success"},
+                {
+                    "case_id": "critical-denial-1",
+                    "critical": True,
+                    "expected": "deny_without_explicit_authority",
+                },
+            ],
+        }),
+    }
+    if kind == "skill":
+        return {**common, "SKILL.md": (
+            f"# {name}\n\n## Purpose\n\nDescribe one bounded capability.\n\n"
+            "## Authority\n\nThis skill never grants tools, credentials, or approval.\n"
+        )}
+    if kind == "connector":
+        return {**common, "connector.json": _json({
+            "schema_version": 1,
+            "connector_id": name,
+            "directions": ["inbound"],
+            "identity_link_required": True,
+            "content_storage": "customer_cell_reference_only",
+            "delivery": {"deduplicate": True, "max_loop_hops": 8},
+            "permissions": {"event_types": [], "network_origins": []},
+            "revocable": True,
+        })}
+    if kind == "tool":
+        return {**common, "tool.json": _json({
+            "schema_version": 1,
+            "tool_name": name,
+            "description": "Describe the bounded effect without promising authority.",
+            "input_schema": {"type": "object", "additionalProperties": False},
+            "effect_class": "read_only",
+            "approval_posture": "policy_decides",
+            "idempotency_required": True,
+        })}
+    if kind == "evaluator":
+        return {**common, "evaluator.json": _json({
+            "schema_version": 1,
+            "evaluator_id": name,
+            "score_range": [0, 1],
+            "critical_slices": ["authorization", "privacy", "false_success"],
+            "content_capture": False,
+        })}
+    if kind == "model-profile":
+        return {**common, "model-profile.json": _json({
+            "schema_version": 1,
+            "profile_id": name,
+            "qualified": False,
+            "qualification_ref": "",
+            "custody": "declare-before-use",
+            "fallback": "none",
+            "task_performance_cards": {},
+        })}
+    return {**common, "agent-bundle-selection.json": _json({
+        "schema_version": 1,
+        "name": name,
+        "components": [
+            "identity_persona",
+            "skills",
+            "policy_references",
+            "brain_export",
+            "history_index",
+            "artifact_manifest",
+        ],
+        "owner_review_required": True,
+        "include_credentials": False,
+        "include_provider_sessions": False,
+        "include_hidden_reasoning": False,
+    })}
+
+
+def scaffold(kind: str, name: str, output: Path) -> Path:
+    if kind not in KINDS:
+        raise ValueError("unknown scaffold kind")
+    if _NAME.fullmatch(name) is None:
+        raise ValueError("name must be 2-64 lowercase letters, numbers, and hyphens")
+    root = output.expanduser().resolve() / name
+    if root.exists() and any(root.iterdir()):
+        raise FileExistsError(f"refusing to overwrite non-empty scaffold: {root}")
+    for relative, body in scaffold_files(kind, name).items():
+        target = root / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(body, encoding="utf-8")
+    return root
+
+
+__all__ = ["KINDS", "scaffold", "scaffold_files"]

geyser_open-0.1.0/tests/test_auth.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import pytest
+from geyser_cli.auth import login_device
+from geyser_cli.credentials import StoredCredential
+
+
+class MemoryStore:
+    credential: StoredCredential | None = None
+
+    def save(self, credential: StoredCredential) -> str:
+        self.credential = credential
+        return "test-keychain"
+
+
+def test_device_flow(monkeypatch: pytest.MonkeyPatch) -> None:
+    responses = iter([
+        httpx.Response(200, json={
+            "device_code": "device-secret",
+            "user_code": "ABCD-EFGH",
+            "verification_uri": "https://auth.example/device",
+            "verification_uri_complete": "https://auth.example/device?code=ABCD-EFGH",
+            "expires_in": 60,
+            "interval": 1,
+        }),
+        httpx.Response(400, json={"error": "authorization_pending"}),
+        httpx.Response(200, json={
+            "access_token": "access-secret",
+            "token_type": "Bearer",
+            "expires_in": 3600,
+            "scope": "development:read runs:read",
+            "customer_id": 1,
+            "project_id": "project-1",
+        }),
+    ])
+
+    class Client:
+        def __init__(self, **_kwargs: Any) -> None:
+            pass
+
+        def __enter__(self) -> Client:
+            return self
+
+        def __exit__(self, *_args: object) -> None:
+            pass
+
+        def post(self, *_args: object, **_kwargs: object) -> httpx.Response:
+            return next(responses)
+
+    monkeypatch.setattr("geyser_cli.auth.httpx.Client", Client)
+    monkeypatch.setattr("geyser_cli.auth.time.sleep", lambda _seconds: None)
+    store = MemoryStore()
+    notifications: list[str] = []
+    value = login_device(
+        "https://api.example",
+        store,  # type: ignore[arg-type]
+        scopes=["development:read"],
+        open_browser=False,
+        notify=lambda device: notifications.append(device.user_code),
+    )
+    assert value["storage"] == "test-keychain"
+    assert store.credential is not None
+    assert store.credential.access_token == "access-secret"  # noqa: S105 - test fixture
+    assert notifications == ["ABCD-EFGH"]

geyser_open-0.1.0/tests/test_cli_local.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import json
+import stat
+import zipfile
+from pathlib import Path
+
+import pytest
+from geyser_cli.__main__ import main
+from geyser_cli.credentials import CredentialStore, StoredCredential
+from geyser_cli.extensions import inspect_archive, package_extension
+
+
+def test_complete_local_workflow(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    assert main(["--json", "init", "tool", "careful-search", "--output", str(tmp_path)]) == 0
+    root = tmp_path / "careful-search"
+    created = json.loads(capsys.readouterr().out)
+    assert created["created"] is True
+    assert main(["--json", "validate", str(root)]) == 0
+    assert json.loads(capsys.readouterr().out)["valid"] is True
+    assert main(["--json", "test", str(root)]) == 0
+    assert json.loads(capsys.readouterr().out)["passed"] == 2
+    assert main(["--json", "dev", str(root)]) == 0
+    assert json.loads(capsys.readouterr().out)["network_used"] is False
+    assert main(["--json", "package", str(root)]) == 0
+    packaged = json.loads(capsys.readouterr().out)
+    archive = Path(packaged["path"])
+    first = archive.read_bytes()
+    assert package_extension(root)["digest"] == packaged["digest"]
+    assert archive.read_bytes() == first
+    assert inspect_archive(archive)["files"] >= 4
+
+
+def test_outcome_cli_and_errors(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    contract = tmp_path / "contract.json"
+    result = tmp_path / "result.json"
+    contract.write_text(json.dumps({
+        "schema_version": 1,
+        "schema_ref": "example:answer:v1",
+        "json_schema": {
+            "type": "object", "properties": {"answer": {"type": "string"}},
+            "required": ["answer"], "additionalProperties": False,
+        },
+    }))
+    result.write_text('{"answer":"yes"}')
+    assert main(["--json", "validate-outcome", str(contract), str(result)]) == 0
+    assert json.loads(capsys.readouterr().out)["valid"] is True
+    result.write_text('{"wrong":true}')
+    assert main(["--json", "validate-outcome", str(contract), str(result)]) == 2
+    assert "OutcomeValidationError" in capsys.readouterr().out
+    assert main(["--json", "init", "tool", "BAD", "--output", str(tmp_path)]) == 2
+
+
+def test_archive_traversal_symlink_and_bounds(tmp_path: Path) -> None:
+    traversal = tmp_path / "traversal.zip"
+    with zipfile.ZipFile(traversal, "w") as archive:
+        archive.writestr("../escape", "bad")
+    with pytest.raises(ValueError, match="traversal"):
+        inspect_archive(traversal)
+    symlink = tmp_path / "symlink.zip"
+    with zipfile.ZipFile(symlink, "w") as archive:
+        info = zipfile.ZipInfo("link")
+        info.external_attr = (stat.S_IFLNK | 0o777) << 16
+        archive.writestr(info, "target")
+    with pytest.raises(ValueError, match="symbolic link"):
+        inspect_archive(symlink)
+
+
+def test_explicit_restricted_file_credential_fallback(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    def unavailable(*_args: object) -> None:
+        raise RuntimeError("no keychain")
+
+    monkeypatch.setattr("geyser_cli.credentials.keyring.set_password", unavailable)
+    monkeypatch.setattr("geyser_cli.credentials.keyring.get_password", unavailable)
+    monkeypatch.setattr("geyser_cli.credentials.keyring.delete_password", unavailable)
+    denied = CredentialStore("test", allow_file_fallback=False)
+    denied.path = tmp_path / "credentials.json"
+    with pytest.raises(RuntimeError, match="opt in"):
+        denied.save(StoredCredential(access_token="secret"))  # noqa: S106 - test fixture
+    store = CredentialStore("test", allow_file_fallback=True)
+    store.path = tmp_path / "credentials.json"
+    assert store.save(StoredCredential(access_token="secret")) == "restricted-file"  # noqa: S106
+    assert stat.S_IMODE(store.path.stat().st_mode) == 0o600
+    assert store.load() is not None
+    assert store.load().access_token == "secret"  # type: ignore[union-attr]  # noqa: S105
+    assert store.delete() is True
+    assert not store.path.exists()
+
+
+def test_version_is_machine_readable(capsys: pytest.CaptureFixture[str]) -> None:
+    assert main(["--json", "version"]) == 0
+    assert json.loads(capsys.readouterr().out)["geyser_open"] == "0.1.0"

geyser_open-0.1.0/tests/test_cli_network.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+from geyser_cli import __main__ as cli
+from geyser_cli.extensions import package_extension
+from geyser_cli.scaffolds import scaffold
+
+SHA = "sha256:" + "a" * 64
+
+
+class FakeClient:
+    def __enter__(self) -> FakeClient:
+        return self
+
+    def __exit__(self, *_args: object) -> None:
+        pass
+
+    def list_packages(self) -> dict[str, Any]:
+        return {"data": []}
+
+    def capabilities(self, *, agent_name: str) -> dict[str, Any]:
+        return {"agent_name": agent_name, "capabilities": {}}
+
+    def list_runs(self, *, customer: bool = False) -> dict[str, Any]:
+        return {"data": [], "customer": customer}
+
+    def get_run(self, run_id: str, *, customer: bool = False) -> dict[str, Any]:
+        return {"run_id": run_id, "customer": customer}
+
+    def trace(self, run_id: str, *, customer: bool = False) -> dict[str, Any]:
+        return {"trace_id": run_id, "customer": customer}
+
+    def watch_events(self, run_id: str, *, customer: bool = False) -> Iterator[dict[str, Any]]:
+        yield {"run_id": run_id, "customer": customer}
+
+    def cancel_run(self, run_id: str, request: Any) -> dict[str, Any]:
+        return {"run_id": run_id, "cancellation_id": request.cancellation_id}
+
+    def fork(self, run_id: str, request: Any) -> dict[str, Any]:
+        return {"run_id": run_id, "fork_id": request.fork_id}
+
+    def list_approvals(self) -> dict[str, Any]:
+        return {"data": []}
+
+    def get_approval(self, approval_id: str) -> dict[str, Any]:
+        return {"approval_id": approval_id}
+
+    def decide_approval(self, run_id: str, approval_id: str, decision: Any) -> dict[str, Any]:
+        return {"run_id": run_id, "approval_id": approval_id, "decision": decision.decision}
+
+    def upload_package(self, package: Any, *, idempotency_key: str) -> dict[str, Any]:
+        return {"name": package.name, "digest": idempotency_key, "stage": "staging"}
+
+    def promote_package(self, package_id: str, promotion: Any) -> dict[str, Any]:
+        return {"package_id": package_id, "target": promotion.target}
+
+
+@pytest.mark.parametrize("arguments", [
+    ["status"],
+    ["capabilities", "--agent", "Ada"],
+    ["runs", "list", "--customer"],
+    ["runs", "get", "run-1"],
+    ["runs", "watch", "run-1"],
+    ["runs", "trace", "run-1", "--customer"],
+    ["runs", "stop", "run-1", "--expected-sequence", "2", "--yes"],
+    ["runs", "fork", "run-1", "--child-run-id", "run-2", "--expected-sequence", "2", "--yes"],
+    ["approvals", "list"],
+    ["approvals", "get", "approval-1"],
+    [
+        "approvals", "decide", "run-1", "approval-1", "approve",
+        "--expected-sequence", "2", "--binding-digest", SHA,
+        "--reason-code", "reviewed", "--yes",
+    ],
+    ["promote", "package-1", "--digest", SHA, "--canary", "--yes"],
+])
+def test_network_commands(
+    arguments: list[str], monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(cli, "_client", lambda _args: FakeClient())
+    assert cli.main(["--json", *arguments]) == 0
+    output = capsys.readouterr().out.strip().splitlines()
+    assert json.loads(output[-1])
+
+
+def test_publish_and_sign(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    root = scaffold("tool", "sample-tool", tmp_path)
+    archive = Path(package_extension(root)["path"])
+    monkeypatch.setattr(cli, "_client", lambda _args: FakeClient())
+    assert cli.main(["--json", "publish", str(archive), "--stage", "--yes"]) == 0
+    assert json.loads(capsys.readouterr().out.strip().splitlines()[-1])["stage"] == "staging"
+    monkeypatch.setattr(cli.shutil, "which", lambda _name: "/usr/bin/true")
+    monkeypatch.setattr(
+        cli.subprocess,
+        "run",
+        lambda *_args, **_kwargs: SimpleNamespace(returncode=0),
+    )
+    assert cli.main(["--json", "sign", str(archive)]) == 0
+
+
+def test_doctor_and_confirmation_cancel(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(cli, "_store", lambda _args: SimpleNamespace(load=lambda: None))
+    monkeypatch.setattr(cli.httpx, "get", lambda *_args, **_kwargs: SimpleNamespace(
+        status_code=200, json=lambda: {"info": {"version": "2026-08-24"}}
+    ))
+    assert cli.main(["--json", "doctor"]) == 0
+    assert json.loads(capsys.readouterr().out)["api_reachable"] is True
+    monkeypatch.setattr(cli, "_client", lambda _args: FakeClient())
+    monkeypatch.setattr(cli.sys.stdin, "isatty", lambda: False)
+    assert cli.main(["--json", "runs", "stop", "run-1", "--expected-sequence", "2"]) == 2
+
+
+@pytest.mark.parametrize(
+    "kind", ["skill", "connector", "evaluator", "model-profile", "agent-bundle"]
+)
+def test_all_scaffold_kinds(kind: str, tmp_path: Path) -> None:
+    root = scaffold(kind, f"sample-{kind}", tmp_path)
+    assert (root / "geyser-package.json").is_file()