dooers-cli 0.5.0__tar.gz

dooers_cli-0.5.0/.gitignore

@@ -0,0 +1,7 @@
+dist/
+*.egg-info
+.pytest_cache
+.ruff_cache
+.mypy_cache
+__pycache__/
+.venv/

dooers_cli-0.5.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: dooers-cli
+Version: 0.5.0
+Summary: Dooers CLI — push agents to Dooers, manage agent records, authenticate from the terminal
+Project-URL: Repository, https://github.com/Dooers-ai/dooers-cli
+Author-email: Dooers <dev@dooers.ai>
+License-Expression: MIT
+Keywords: agents,cli,deployment,docker,dooers,gcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: dooers-protocol>=0.4.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.13.2
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: tqdm>=4.66.4
+Requires-Dist: typer>=0.12.3
+Provides-Extra: dev
+Requires-Dist: build>=1.4.3; extra == 'dev'
+Requires-Dist: mypy>=1.20.1; extra == 'dev'
+Requires-Dist: poethepoet>=0.44.0; extra == 'dev'
+Requires-Dist: pytest-cov>=7.1.0; extra == 'dev'
+Requires-Dist: pytest>=9.0.3; extra == 'dev'
+Requires-Dist: respx>=0.21.1; extra == 'dev'
+Requires-Dist: ruff>=0.15.11; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0; extra == 'dev'
+Requires-Dist: types-tqdm>=4.66.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dooers (CLI)
+
+The Dooers CLI. Installed by agent creators.
+
+```bash
+pip install dooers
+```
+
+## Commands
+
+```bash
+# auth (email prompts if omitted)
+dooers login you@example.com
+dooers whoami
+dooers logout
+
+# agents
+dooers agents list
+dooers agents create --name my-agent
+dooers agents show ag_8h2k
+
+# push (reads dooers.yaml in cwd unless agent_id given)
+dooers validate
+dooers push [<agent_id>] [--tag latest] [--env prod|stg|dev]
+```
+
+## Global config (precedence: flag > env > default)
+
+| Setting | Flag | Env var | Default |
+|---|---|---|---|
+| Core API host | `--core-url` | `DOOERS_CORE_URL` | `https://api.dooers.ai` |
+| dooers-push host | `--push-url` | `DOOERS_PUSH_URL` | `https://host.dooers.ai` |
+| Target environment | `--env` | `DOOERS_ENV` | `prod` |
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run poe dev
+```

dooers_cli-0.5.0/README.md

@@ -0,0 +1,40 @@
+# dooers (CLI)
+
+The Dooers CLI. Installed by agent creators.
+
+```bash
+pip install dooers
+```
+
+## Commands
+
+```bash
+# auth (email prompts if omitted)
+dooers login you@example.com
+dooers whoami
+dooers logout
+
+# agents
+dooers agents list
+dooers agents create --name my-agent
+dooers agents show ag_8h2k
+
+# push (reads dooers.yaml in cwd unless agent_id given)
+dooers validate
+dooers push [<agent_id>] [--tag latest] [--env prod|stg|dev]
+```
+
+## Global config (precedence: flag > env > default)
+
+| Setting | Flag | Env var | Default |
+|---|---|---|---|
+| Core API host | `--core-url` | `DOOERS_CORE_URL` | `https://api.dooers.ai` |
+| dooers-push host | `--push-url` | `DOOERS_PUSH_URL` | `https://host.dooers.ai` |
+| Target environment | `--env` | `DOOERS_ENV` | `prod` |
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run poe dev
+```

dooers_cli-0.5.0/pyproject.toml

@@ -0,0 +1,83 @@
+[project]
+name = "dooers-cli"
+version = "0.5.0"
+description = "Dooers CLI — push agents to Dooers, manage agent records, authenticate from the terminal"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    {name = "Dooers", email = "dev@dooers.ai"},
+]
+keywords = ["dooers", "cli", "deployment", "agents", "docker", "gcp"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+
+dependencies = [
+    "typer>=0.12.3",
+    "httpx>=0.28.1",
+    "pydantic>=2.13.2",
+    "pyyaml>=6.0.2",
+    "tqdm>=4.66.4",
+    "dooers-protocol>=0.4.0",
+]
+
+[tool.uv.sources]
+dooers-protocol = { path = "../dooers-protocol", editable = true }
+
+[project.urls]
+Repository = "https://github.com/Dooers-ai/dooers-cli"
+
+[project.scripts]
+dooers = "dooers.cli.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dooers"]
+
+[project.optional-dependencies]
+dev = [
+    "mypy>=1.20.1",
+    "poethepoet>=0.44.0",
+    "pytest>=9.0.3",
+    "pytest-cov>=7.1.0",
+    "respx>=0.21.1",
+    "ruff>=0.15.11",
+    "build>=1.4.3",
+    "types-pyyaml>=6.0.0",
+    "types-tqdm>=4.66.0",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "BLE"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.poe.tasks]
+format = "ruff format ."
+"format:imports" = "ruff check --select I --fix ."
+check = "ruff check ."
+"check:fix" = "ruff check --fix ."
+typecheck = "mypy src/dooers/cli"
+test = "pytest"
+"test:cov" = "pytest --cov=src --cov-report=term-missing"
+dev = ["check", "typecheck", "test"]
+build = "python -m build"

dooers_cli-0.5.0/src/dooers/cli/__init__.py

@@ -0,0 +1,3 @@
+"""dooers — the Dooers CLI."""
+
+__version__ = "0.3.0"

dooers_cli-0.5.0/src/dooers/cli/agent_store.py

@@ -0,0 +1,66 @@
+"""v2 core-backed agent store. Talks to /api/v2/agents with {success,data}."""
+
+import json
+
+import httpx
+from dooers.protocol.agents import AgentRecord, CreateAgentRequest
+
+
+class AgentStoreError(RuntimeError):
+    pass
+
+
+def _data(resp: httpx.Response):
+    body = resp.json()
+    if isinstance(body, dict) and body.get("success") is False:
+        raise AgentStoreError(body.get("error", {}).get("message", f"HTTP {resp.status_code}"))
+    if resp.status_code >= 400:
+        raise AgentStoreError(f"HTTP {resp.status_code}")
+    return body.get("data", body)
+
+
+def _record(d: dict) -> AgentRecord:
+    return AgentRecord(
+        agent_id=d["agentId"],
+        name=d.get("name", ""),
+        owner_user_id=d.get("ownerUserId"),
+        organization_id=d.get("organizationId"),
+        host_url=d.get("hostUrl"),
+    )
+
+
+class HTTPCoreAgentStore:
+    def __init__(self, base_url: str, token: str, timeout: float = 15.0) -> None:
+        self.api = base_url.rstrip("/") + "/api/v2"
+        self.token = token
+        self._timeout = timeout
+
+    def _h(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self.token}"}
+
+    def create(self, req: CreateAgentRequest) -> AgentRecord:
+        body = json.dumps({"organizationId": req.organization_id, "name": req.name})
+        r = httpx.post(
+            f"{self.api}/agents",
+            headers={**self._h(), "content-type": "application/json"},
+            content=body,
+            timeout=self._timeout,
+        )
+        return _record(_data(r))
+
+    def list_by_org(self, organization_id: str) -> list[AgentRecord]:
+        url = f"{self.api}/agents/organization/{organization_id}"
+        r = httpx.get(url, headers=self._h(), timeout=self._timeout)
+        return [_record(d) for d in _data(r)]
+
+    def get(self, agent_id: str) -> AgentRecord:
+        r = httpx.get(f"{self.api}/agents/{agent_id}", headers=self._h(), timeout=self._timeout)
+        if r.status_code == 404:
+            raise KeyError(agent_id)
+        return _record(_data(r))
+
+    def update(self, agent_id: str, patch: dict) -> AgentRecord:
+        r = httpx.patch(
+            f"{self.api}/agents/{agent_id}", headers=self._h(), json=patch, timeout=self._timeout
+        )
+        return _record(_data(r))

dooers_cli-0.5.0/src/dooers/cli/agents.py

@@ -0,0 +1,100 @@
+"""`dooers agents` subcommands: list, create, show (core v2)."""
+
+from pathlib import Path
+
+import typer
+from dooers.protocol import PROTOCOL_VERSION
+from dooers.protocol.agents import (
+    AgentManifest,
+    CreateAgentRequest,
+    ProfileConfig,
+    UiConfig,
+    WhatsAppConfig,
+)
+
+from dooers.cli import config
+from dooers.cli.agent_store import AgentStoreError, HTTPCoreAgentStore
+from dooers.cli.org import resolve_org_for_cli
+from dooers.cli.settings import Settings
+from dooers.cli.token_store import TokenStore, is_token_expired
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _store(ctx: typer.Context) -> tuple[HTTPCoreAgentStore, Settings]:
+    settings: Settings = ctx.obj
+    store_token = TokenStore()
+    token = store_token.load()
+    if not token or is_token_expired(token, store=store_token):
+        typer.echo("Not authenticated. Run `dooers login`.", err=True)
+        raise typer.Exit(code=1)
+    return HTTPCoreAgentStore(settings.core_url, token), settings
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: str = typer.Option(..., help="Display name for the new agent."),
+    org: str | None = typer.Option(None, "--org", help="Organization id (else resolved/prompted)."),
+    description: str | None = typer.Option(
+        None, "--description", help="Short description of the agent."
+    ),
+) -> None:
+    store, settings = _store(ctx)
+    organization_id = resolve_org_for_cli(settings, org)
+    try:
+        rec = store.create(CreateAgentRequest(organization_id=organization_id, name=name))
+    except AgentStoreError as e:
+        typer.echo(f"create failed: {e}", err=True)
+        raise typer.Exit(code=1) from e
+    config.write_manifest(
+        AgentManifest(
+            protocol_version=PROTOCOL_VERSION,
+            agent_id=rec.agent_id,
+            name=rec.name,
+            organization_id=rec.organization_id or organization_id,
+            description=description,
+            message_path="/",
+            message_scheme="wss",
+            whatsapp=WhatsAppConfig(enabled=False, path=None),
+            profile=ProfileConfig(),
+            ui=UiConfig(),
+        ),
+        directory=Path.cwd(),
+    )
+    typer.echo(f"Created {rec.agent_id}. {config.MANIFEST_FILENAME} written.")
+    typer.echo("Edit dooers.yaml (message_path, whatsapp, profile) then run dooers push.")
+
+
+@app.command(name="list")
+def list_agents(ctx: typer.Context, org: str | None = typer.Option(None, "--org")) -> None:
+    store, settings = _store(ctx)
+    organization_id = resolve_org_for_cli(settings, org)
+    try:
+        records = store.list_by_org(organization_id)
+    except AgentStoreError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1) from e
+    if not records:
+        typer.echo("No agents yet. Try `dooers agents create --name my-agent`.")
+        return
+    typer.echo(f"{'ID':<38}{'NAME':<24}URL")
+    for r in records:
+        typer.echo(f"{r.agent_id:<38}{r.name:<24}{r.host_url or '—'}")
+
+
+@app.command()
+def show(ctx: typer.Context, agent_id: str = typer.Argument(...)) -> None:
+    store, _ = _store(ctx)
+    try:
+        r = store.get(agent_id)
+    except KeyError:
+        typer.echo(f"Agent {agent_id} not found.", err=True)
+        raise typer.Exit(code=1)
+    except AgentStoreError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1) from e
+    typer.echo(f"ID:    {r.agent_id}")
+    typer.echo(f"Name:  {r.name}")
+    typer.echo(f"Org:   {r.organization_id}")
+    typer.echo(f"URL:   {r.host_url or '—'}")

dooers_cli-0.5.0/src/dooers/cli/auth.py

@@ -0,0 +1,80 @@
+"""`dooers login` / `whoami` / `logout` command implementations.
+
+Registered as top-level commands from cli.py.
+"""
+
+import typer
+
+from dooers.cli.core_client import CoreClient, CoreClientError
+from dooers.cli.settings import Settings
+from dooers.cli.token_store import TokenStore, is_token_expired
+
+
+def _settings(ctx: typer.Context) -> Settings:
+    s = ctx.obj
+    if not isinstance(s, Settings):
+        typer.echo("internal: settings not resolved", err=True)
+        raise typer.Exit(code=1)
+    return s
+
+
+def login(
+    ctx: typer.Context,
+    email: str | None = typer.Argument(None, help="Your email address. Prompted if omitted."),
+) -> None:
+    """Authenticate with Dooers via OTP sent to email."""
+    settings = _settings(ctx)
+    if not email:
+        email = typer.prompt("Email")
+    store = TokenStore()
+
+    existing = store.load()
+    if existing and not is_token_expired(existing, store=store):
+        typer.echo("Already authenticated. Run `dooers logout` first to re-login.")
+        raise typer.Exit(code=0)
+
+    client = CoreClient(base_url=settings.core_url)
+    try:
+        typer.echo("Requesting verification code…")
+        client.send_otp(email)
+        code = typer.prompt("Enter the code emailed to you")
+        token, expires_at = client.verify_otp(email, code)
+    except CoreClientError as e:
+        typer.echo(f"Authentication failed: {e}", err=True)
+        raise typer.Exit(code=1) from e
+
+    store.save(token, expires_at=expires_at)
+    typer.echo("Authenticated.")
+
+
+def whoami(ctx: typer.Context) -> None:
+    """Show the currently authenticated user."""
+    settings = _settings(ctx)
+    store = TokenStore()
+    token = store.load()
+    if not token:
+        typer.echo("Not authenticated. Run `dooers login`.", err=True)
+        raise typer.Exit(code=1)
+    if is_token_expired(token, store=store):
+        typer.echo("Session expired. Run `dooers login`.", err=True)
+        store.clear()
+        raise typer.Exit(code=1)
+
+    client = CoreClient(base_url=settings.core_url, token=token)
+    try:
+        me = client.me()
+    except CoreClientError as e:
+        typer.echo(f"whoami failed: {e}", err=True)
+        raise typer.Exit(code=1) from e
+    typer.echo(f"Authenticated as {me.email} (user_id={me.user_id})")
+
+
+def logout(ctx: typer.Context) -> None:
+    """Clear local credentials."""
+    settings = _settings(ctx)
+    store = TokenStore()
+    token = store.load()
+    if token:
+        CoreClient(base_url=settings.core_url, token=token).revoke()
+    store.clear()
+    typer.echo("Logged out.")

dooers_cli-0.5.0/src/dooers/cli/cli.py

@@ -0,0 +1,40 @@
+"""Top-level Typer app — login/whoami/logout + agents group + push."""
+
+import typer
+
+from . import agents, auth, org, push, validate
+from .settings import Settings
+
+app = typer.Typer(
+    name="dooers",
+    add_completion=False,
+    no_args_is_help=True,
+    help="Dooers CLI — push agents to Dooers, manage agent records, authenticate.",
+)
+
+
+@app.callback()
+def _root(
+    ctx: typer.Context,
+    core_url: str | None = typer.Option(None, "--core-url", help="Override core API URL."),
+    push_url: str | None = typer.Option(None, "--push-url", help="Override dooers-push URL."),
+    env: str | None = typer.Option(None, "--env", help="Target environment: prod | stg | dev."),
+) -> None:
+    """Resolve global settings once per invocation."""
+    ctx.obj = Settings.resolve(core_url=core_url, push_url=push_url, env=env)
+
+
+app.command(name="login", help="Authenticate with Dooers (OTP via email).")(auth.login)
+app.command(name="whoami", help="Show the currently authenticated user.")(auth.whoami)
+app.command(name="logout", help="Clear local credentials.")(auth.logout)
+app.add_typer(agents.app, name="agents", help="Manage agents — subcommands: list | create | show.")
+app.add_typer(org.app, name="org", help="Manage organization — subcommands: list | use.")
+app.command(
+    name="validate",
+    help="Validate dooers.yaml, Dockerfile, and SDK dependency/import conventions.",
+)(validate.validate)
+app.command(name="push", help="Archive cwd and push it as a new build of an agent.")(push.push)
+
+
+if __name__ == "__main__":
+    app()

dooers_cli-0.5.0/src/dooers/cli/config.py

@@ -0,0 +1,28 @@
+"""dooers.yaml reader/writer."""
+
+from pathlib import Path
+
+import yaml
+from dooers.protocol.agents import AgentManifest
+
+MANIFEST_FILENAME = "dooers.yaml"
+
+
+def read_manifest(directory: Path | None = None) -> AgentManifest | None:
+    """Read and validate dooers.yaml from `directory` (default: cwd).
+
+    Returns None if missing. Raises pydantic.ValidationError on schema violations.
+    """
+    target = (directory or Path.cwd()) / MANIFEST_FILENAME
+    if not target.exists():
+        return None
+    raw = yaml.safe_load(target.read_text()) or {}
+    return AgentManifest.model_validate(raw)
+
+
+def write_manifest(manifest: AgentManifest, directory: Path | None = None) -> Path:
+    """Write `manifest` to `directory/dooers.yaml`. Returns the path written."""
+    target = (directory or Path.cwd()) / MANIFEST_FILENAME
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(yaml.safe_dump(manifest.model_dump(mode="json"), sort_keys=False))
+    return target

dooers_cli-0.5.0/src/dooers/cli/core_client.py

@@ -0,0 +1,105 @@
+"""HTTP client for Dooers core v2 (better-auth OTP + agents)."""
+
+import time
+
+import httpx
+from dooers.protocol.auth import WhoamiResponse
+
+ACCESS_TOKEN_FALLBACK_TTL = 60 * 60 * 24 * 7  # 7d if core doesn't tell us
+
+
+class CoreClientError(RuntimeError):
+    """CLI-friendly error."""
+
+
+def _data(resp: httpx.Response) -> dict:
+    body = resp.json()
+    if isinstance(body, dict) and body.get("success") is False:
+        raise CoreClientError(body.get("error", {}).get("message", f"HTTP {resp.status_code}"))
+    if resp.status_code >= 400:
+        raise CoreClientError(f"HTTP {resp.status_code}")
+    return body.get("data", body) if isinstance(body, dict) else body
+
+
+class CoreClient:
+    def __init__(self, base_url: str, token: str | None = None, timeout: float = 15.0) -> None:
+        self.api = base_url.rstrip("/") + "/api/v2"
+        self.token = token
+        self._timeout = timeout
+
+    def _headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self.token}"} if self.token else {}
+
+    # ---- auth ----
+    def auth_method(self) -> str:
+        try:
+            r = httpx.get(f"{self.api}/identity/auth-method", timeout=self._timeout)
+            return _data(r).get("method", "otp")
+        except httpx.HTTPError as e:
+            raise CoreClientError(f"auth-method failed: {e}") from e
+
+    def send_otp(self, email: str) -> None:
+        try:
+            r = httpx.post(
+                f"{self.api}/auth/email-otp/send-verification-otp",
+                json={"email": email, "type": "sign-in"},
+                timeout=self._timeout,
+            )
+            _data(r)
+        except httpx.HTTPError as e:
+            raise CoreClientError(f"failed to send code: {e}") from e
+
+    def verify_otp(self, email: str, code: str) -> tuple[str, int]:
+        """Returns (bearer_token, expires_at_epoch)."""
+        try:
+            r = httpx.post(
+                f"{self.api}/auth/sign-in/email-otp",
+                json={"email": email, "otp": code},
+                timeout=self._timeout,
+            )
+            _data(r)  # raises on error envelope
+            token = r.headers.get("set-auth-token")
+            if not token:
+                # fallback: mint via /identity/token using the session cookie just set
+                tr = httpx.post(
+                    f"{self.api}/identity/token", cookies=r.cookies, timeout=self._timeout
+                )
+                d = _data(tr)
+                token = d.get("accessToken")
+                if not token:
+                    raise CoreClientError("core returned no access token")
+                return token, int(time.time()) + int(d.get("expiresIn", ACCESS_TOKEN_FALLBACK_TTL))
+            return token, int(time.time()) + ACCESS_TOKEN_FALLBACK_TTL
+        except httpx.HTTPError as e:
+            raise CoreClientError(f"failed to verify code: {e}") from e
+
+    def me(self) -> WhoamiResponse:
+        try:
+            r = httpx.get(f"{self.api}/identity/me", headers=self._headers(), timeout=self._timeout)
+            d = _data(r)
+            # core v2 /identity/me → data.user.{id,email}; tolerate a flat shape too.
+            user = d.get("user", d)
+            return WhoamiResponse(
+                user_id=user.get("id") or user.get("userId") or "",
+                email=user.get("email", ""),
+            )
+        except httpx.HTTPError as e:
+            raise CoreClientError(f"me failed: {e}") from e
+
+    def revoke(self) -> None:
+        try:
+            httpx.post(
+                f"{self.api}/identity/revoke", headers=self._headers(), timeout=self._timeout
+            )
+        except httpx.HTTPError:
+            pass  # best-effort
+
+    def list_organizations(self) -> list[dict]:
+        try:
+            r = httpx.get(
+                f"{self.api}/organizations", headers=self._headers(), timeout=self._timeout
+            )
+            result = _data(r)
+            return list(result) if isinstance(result, list) else []
+        except httpx.HTTPError as e:
+            raise CoreClientError(f"list organizations failed: {e}") from e