dooers-cli 0.5.0__py3-none-any.whl

dooers/cli/__init__.py

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

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/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/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/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/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/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

dooers/cli/ignore.py

@@ -0,0 +1,89 @@
+"""`.dooersignore` parsing + cwd archiving with default ignore patterns.
+
+Ported from v1 cli.py — refactored into pure functions for testability.
+Reference: ../../../deploy-service/cli/dooers/cli.py
+"""
+
+import fnmatch
+import os
+import tarfile
+import tempfile
+from pathlib import Path
+
+DEFAULT_IGNORE_PATTERNS: list[str] = [
+    ".git/",
+    ".gitignore",
+    ".venv/",
+    "venv/",
+    "node_modules/",
+    "__pycache__/",
+    "*.pyc",
+    ".DS_Store",
+    "dist/",
+    "build/",
+    "*.log",
+]
+
+
+def load_ignore_patterns(directory: Path | None = None) -> list[str]:
+    """Return default patterns merged with any from `.dooersignore`."""
+    directory = directory or Path.cwd()
+    patterns = list(DEFAULT_IGNORE_PATTERNS)
+    ignore_file = directory / ".dooersignore"
+    if ignore_file.exists():
+        for raw in ignore_file.read_text().splitlines():
+            line = raw.strip()
+            if not line or line.startswith("#"):
+                continue
+            patterns.append(line)
+    return patterns
+
+
+def is_ignored(rel_path: str, patterns: list[str]) -> bool:
+    """Check whether `rel_path` matches any pattern (gitignore-style)."""
+    posix_path = rel_path.replace(os.sep, "/")
+    for pat in patterns:
+        pat = pat.strip()
+        if not pat:
+            continue
+        if pat.endswith("/"):
+            prefix = pat[:-1]
+            if posix_path == prefix or posix_path.startswith(prefix + "/"):
+                return True
+        if pat.startswith("/"):
+            if fnmatch.fnmatch(posix_path, pat.lstrip("/")):
+                return True
+        if fnmatch.fnmatch(posix_path, pat):
+            return True
+        if "/" not in pat and pat in posix_path.split("/"):
+            return True
+    return False
+
+
+def make_archive(directory: str = ".") -> str:
+    """Create a temp .tar.gz of `directory` respecting ignore patterns.
+
+    Returns the absolute path to the temp archive (caller is responsible
+    for cleanup).
+    """
+    patterns = load_ignore_patterns(Path(directory))
+    tmpfd, tmppath = tempfile.mkstemp(suffix=".tar.gz", prefix="dooers-")
+    os.close(tmpfd)
+    with tarfile.open(tmppath, "w:gz") as tar:
+        for root, dirs, files in os.walk(directory):
+            relroot = os.path.relpath(root, directory)
+            if relroot == ".":
+                relroot = ""
+            # prune ignored dirs in-place
+            pruned = [
+                d for d in dirs
+                if is_ignored((os.path.join(relroot, d) if relroot else d) + "/", patterns)
+            ]
+            for d in pruned:
+                dirs.remove(d)
+            for name in files:
+                rel = os.path.join(relroot, name) if relroot else name
+                if is_ignored(rel, patterns):
+                    continue
+                tar.add(os.path.join(root, name), arcname=rel)
+    return tmppath

dooers/cli/manifest_sync.py

@@ -0,0 +1,73 @@
+"""Build the core PATCH body from a manifest + the deployed URL."""
+
+from dooers.protocol.agents import AgentManifest
+
+
+def _host_and_seg(deployed_url: str) -> str:
+    """'https://agents.dooers.ai/ag-x' -> 'agents.dooers.ai/ag-x' (no scheme, no trailing /)."""
+    return deployed_url.split("://", 1)[-1].rstrip("/")
+
+
+def _norm_path(p: str) -> str:
+    return p if p.startswith("/") else "/" + p
+
+
+def build_agent_patch(manifest: AgentManifest, deployed_url: str) -> dict:
+    """Map the declarative manifest to a core v2 PATCH /agents/:id body.
+
+    Derives serverConfig.apiMessagesUrl (and whatsapp inbound) from the
+    deployed host + the declared paths. Only includes keys the creator set.
+    """
+    host = _host_and_seg(deployed_url)
+    patch: dict = {}
+
+    # Only sync a non-empty description. An empty/absent one means "leave as-is"
+    # — never send null, which would wipe a description set elsewhere (e.g. Studio).
+    if manifest.description:
+        patch["description"] = manifest.description
+
+    if manifest.message_path:
+        path = _norm_path(manifest.message_path)
+        url = f"{manifest.message_scheme}://{host}{path}".rstrip("/")
+        patch["serverConfig"] = {"apiMessagesUrl": url}
+
+    if manifest.whatsapp and manifest.whatsapp.enabled:
+        wpath = _norm_path(manifest.whatsapp.path or "/whatsapp/inbound")
+        patch.setdefault("settings", {}).setdefault("integration_settings", {})["whatsapp"] = {
+            "enabled": True,
+            "inbound_http_url": f"https://{host}{wpath}",
+        }
+
+    if manifest.profile:
+        prof: dict = {}
+        p = manifest.profile
+        if p.summary is not None:
+            prof["summary"] = p.summary or None
+        if p.image_url is not None:
+            prof["imageUrl"] = p.image_url or None
+        if p.capabilities:
+            prof["capabilities"] = p.capabilities
+        if p.tools:
+            prof["tools"] = p.tools
+        if p.usage_limits:
+            prof["usageLimits"] = p.usage_limits
+        if prof:
+            patch["profile"] = prof
+
+    if manifest.ui:
+        ui: dict = {}
+        u = manifest.ui
+        if u.hide_mic is not None:
+            ui["hide_mic"] = u.hide_mic
+        if u.hide_textinput is not None:
+            ui["hide_textinput"] = u.hide_textinput
+        if u.hide_attachments is not None:
+            ui["hide_attachments"] = u.hide_attachments
+        if u.suggested_prompts:
+            ui["suggested_prompts"] = [
+                {"title": sp.title, "prompt": sp.prompt} for sp in u.suggested_prompts
+            ]
+        if ui:
+            patch.setdefault("settings", {})["dooersUi_settings"] = ui
+
+    return patch

dooers/cli/org.py

@@ -0,0 +1,82 @@
+"""Org resolution + `dooers org list|use`."""
+
+from collections.abc import Callable
+
+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
+from dooers.cli.user_config import UserConfig
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def resolve_org(
+    *,
+    orgs: list[dict],
+    explicit: str | None,
+    default: str | None,
+    prompt: Callable[[list[dict]], str],
+) -> str:
+    """Precedence: explicit flag > saved default > single-org auto > prompt."""
+    if explicit:
+        return explicit
+    ids = {o["organizationId"] for o in orgs}
+    if default and default in ids:
+        return default
+    if len(orgs) == 1:
+        return orgs[0]["organizationId"]
+    return prompt(orgs)
+
+
+def _token(settings: Settings) -> str:
+    store = TokenStore()
+    token = store.load()
+    if not token or is_token_expired(token, store=store):
+        typer.echo("Not authenticated. Run `dooers login`.", err=True)
+        raise typer.Exit(code=1)
+    return token
+
+
+def resolve_org_for_cli(settings: Settings, explicit: str | None) -> str:
+    """Fetch orgs, apply precedence, persist the chosen default when prompting."""
+    token = _token(settings)
+    try:
+        orgs = CoreClient(base_url=settings.core_url, token=token).list_organizations()
+    except CoreClientError as e:
+        typer.echo(f"could not list organizations: {e}", err=True)
+        raise typer.Exit(code=1) from e
+    if not orgs:
+        typer.echo("You don't belong to any organization.", err=True)
+        raise typer.Exit(code=1)
+    cfg = UserConfig()
+
+    def _prompt(options: list[dict]) -> str:
+        typer.echo("Multiple organizations — choose one:")
+        for i, o in enumerate(options, 1):
+            typer.echo(f"  {i}. {o.get('name', o['organizationId'])} ({o['organizationId']})")
+        idx = typer.prompt("Number", type=int)
+        chosen = options[idx - 1]["organizationId"]
+        cfg.set_default_org(chosen)
+        typer.echo(f"Saved default org: {chosen}")
+        return chosen
+
+    return resolve_org(orgs=orgs, explicit=explicit, default=cfg.get_default_org(), prompt=_prompt)
+
+
+@app.command(name="list")
+def list_orgs(ctx: typer.Context) -> None:
+    settings: Settings = ctx.obj
+    token = _token(settings)
+    orgs = CoreClient(base_url=settings.core_url, token=token).list_organizations()
+    default = UserConfig().get_default_org()
+    for o in orgs:
+        mark = " (default)" if o["organizationId"] == default else ""
+        typer.echo(f"{o['organizationId']}  {o.get('name', '')}{mark}")
+
+
+@app.command()
+def use(ctx: typer.Context, organization_id: str = typer.Argument(...)) -> None:
+    UserConfig().set_default_org(organization_id)
+    typer.echo(f"Default org set to {organization_id}")

dooers/cli/push.py

@@ -0,0 +1,139 @@
+"""`dooers push` — archive cwd and POST to dooers-push."""
+
+import os
+import sys
+import threading
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+import typer
+from dooers.protocol.push import format_push_failure
+
+from dooers.cli import config, ignore
+from dooers.cli.manifest_sync import build_agent_patch
+from dooers.cli.push_client import PushClient, PushClientError
+from dooers.cli.settings import Settings
+from dooers.cli.token_store import TokenStore, is_token_expired
+
+
+def _spinner(message: str) -> Callable[[], None]:
+    """Background spinner on stderr. Returns a stopper function."""
+    stop = threading.Event()
+    frames = "|/-\\"
+
+    def run() -> None:
+        i = 0
+        while not stop.is_set():
+            sys.stderr.write(f"\r{message} {frames[i % 4]}")
+            sys.stderr.flush()
+            i += 1
+            time.sleep(0.1)
+        sys.stderr.write("\r" + " " * (len(message) + 4) + "\r")
+        sys.stderr.flush()
+
+    t = threading.Thread(target=run, daemon=True)
+    t.start()
+
+    def cancel() -> None:
+        stop.set()
+        t.join(timeout=1)
+
+    return cancel
+
+
+def push(
+    ctx: typer.Context,
+    agent_id: str | None = typer.Argument(
+        None,
+        help="Agent ID. If omitted, reads agent_id from ./dooers.yaml.",
+    ),
+    tag: str = typer.Option("latest", help="Docker image tag."),
+    env: str | None = typer.Option(
+        None, help="Target environment: prod | stg | dev (overrides --env on the root)."
+    ),
+) -> None:
+    """Push the current directory as a new build of an agent."""
+    settings: Settings = ctx.obj
+    target_env = env or settings.env
+
+    # Resolve agent_id from arg or manifest.
+    manifest = config.read_manifest()
+    if agent_id is None:
+        if manifest is None:
+            typer.echo(
+                f"Missing {config.MANIFEST_FILENAME}. Run `dooers agents create` first "
+                f"or pass an agent_id explicitly.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+        agent_id = manifest.agent_id
+
+    # Client-side hosting guard. The dooers-push server is the authoritative
+    # gate (it checks the org's hosting plan feature); this is a fast local
+    # check so `hosting: false` in dooers.yaml never even uploads.
+    if manifest is not None and not manifest.hosting:
+        typer.echo(
+            "hosting is disabled in dooers.yaml (hosting: false). Aborting push.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    # Auth.
+    store = TokenStore()
+    token = store.load()
+    if not token or is_token_expired(token, store=store):
+        typer.echo("Not authenticated. Run `dooers login`.", err=True)
+        raise typer.Exit(code=1)
+
+    # Archive cwd.
+    typer.echo("Archiving …")
+    archive_path = Path(ignore.make_archive("."))
+    size_mb = archive_path.stat().st_size / (1024 * 1024)
+    typer.echo(f"Archive: {archive_path.name} ({size_mb:.1f} MB)")
+
+    # Push.
+    client = PushClient(base_url=settings.push_url, token=token)
+    cancel_spinner = _spinner(f"Pushing {agent_id} (this can take 3-5 min)")
+    try:
+        resp = client.push(agent_id=agent_id, archive_path=archive_path, tag=tag, env=target_env)
+    except PushClientError as e:
+        cancel_spinner()
+        typer.echo(f"Push failed: {e}", err=True)
+        raise typer.Exit(code=1) from e
+    finally:
+        cancel_spinner()
+        os.unlink(archive_path)
+
+    # Report.
+    if resp.audit and resp.audit.required_infra.detected_endpoints:
+        endpoints = resp.audit.required_infra.detected_endpoints
+        typer.echo(f"\nAudit: {len(endpoints)} endpoint(s) detected:")
+        for ep in endpoints[:10]:
+            typer.echo(f"  - {ep}")
+        if len(endpoints) > 10:
+            typer.echo(f"  … and {len(endpoints) - 10} more")
+    elif resp.audit:
+        typer.echo("\nAudit: 0 endpoints detected.")
+    if resp.status.value == "succeeded" and resp.url:
+        typer.echo(f"\nLive at: {resp.url}")
+        if target_env == "prod":
+            try:
+                manifest = config.read_manifest()
+                if manifest is not None:
+                    patch = build_agent_patch(manifest, resp.url)
+                    if patch:
+                        from dooers.cli.agent_store import HTTPCoreAgentStore
+
+                        HTTPCoreAgentStore(settings.core_url, token).update(
+                            manifest.agent_id, patch
+                        )
+                        typer.echo("Synced agent config to core.")
+            except Exception as e:  # noqa: BLE001 — non-fatal: agent is live, sync is best-effort
+                typer.echo(f"Warning: could not sync agent config: {e}", err=True)
+    elif resp.status.value == "failed":
+        typer.echo(f"\n{format_push_failure(resp)}", err=True)
+        raise typer.Exit(code=1)
+    else:
+        typer.echo(f"\nStatus: {resp.status.value}")
+        raise typer.Exit(code=0)

dooers/cli/push_client.py

@@ -0,0 +1,52 @@
+"""HTTP client for dooers-push (multipart upload + synchronous wait)."""
+
+from pathlib import Path
+
+import httpx
+from dooers.protocol.errors import ErrorEnvelope
+from dooers.protocol.push import PushResponse
+
+
+class PushClientError(RuntimeError):
+    def __init__(self, message: str, envelope: ErrorEnvelope | None = None) -> None:
+        super().__init__(message)
+        self.envelope = envelope
+
+
+class PushClient:
+    def __init__(self, base_url: str, token: str, timeout: float = 600.0) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self._timeout = timeout
+
+    def push(
+        self,
+        agent_id: str,
+        archive_path: Path,
+        tag: str = "latest",
+        env: str = "prod",
+    ) -> PushResponse:
+        url = f"{self.base_url}/v1/push/{agent_id}"
+        headers = {"Authorization": f"Bearer {self.token}"}
+        params = {"tag": tag, "env": env}
+        with archive_path.open("rb") as f:
+            files = {"archive": (archive_path.name, f, "application/gzip")}
+            try:
+                r = httpx.post(
+                    url,
+                    headers=headers,
+                    params=params,
+                    files=files,
+                    timeout=self._timeout,
+                )
+            except httpx.HTTPError as e:
+                raise PushClientError(f"push request failed: {e}") from e
+
+        if r.status_code >= 400:
+            try:
+                envelope = ErrorEnvelope.model_validate(r.json())
+                raise PushClientError(envelope.message, envelope=envelope)
+            except (ValueError, TypeError):
+                raise PushClientError(f"push failed (HTTP {r.status_code}): {r.text}")
+
+        return PushResponse.model_validate(r.json())

dooers/cli/settings.py

@@ -0,0 +1,29 @@
+"""Global CLI configuration: core URL, push URL, env.
+
+Precedence: explicit CLI flag > env var > built-in default.
+The top-level Typer callback resolves this once and stashes it on the
+Typer context so every subcommand sees the same values.
+"""
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Settings:
+    core_url: str
+    push_url: str
+    env: str
+
+    @classmethod
+    def resolve(
+        cls,
+        core_url: str | None = None,
+        push_url: str | None = None,
+        env: str | None = None,
+    ) -> "Settings":
+        return cls(
+            core_url=(core_url or os.environ.get("DOOERS_CORE_URL") or "https://api.dooers.ai").rstrip("/"),
+            push_url=(push_url or os.environ.get("DOOERS_PUSH_URL") or "https://host.dooers.ai").rstrip("/"),
+            env=(env or os.environ.get("DOOERS_ENV") or "prod"),
+        )

dooers/cli/token_store.py

@@ -0,0 +1,46 @@
+"""Persisted auth token at ~/.dooers/token.json (0600). Stores token + expiry."""
+
+import json
+import time
+from pathlib import Path
+
+DEFAULT_TOKEN_PATH = Path.home() / ".dooers" / "token.json"
+
+
+class TokenStore:
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path or DEFAULT_TOKEN_PATH
+
+    def _read(self) -> dict:
+        if not self.path.exists():
+            return {}
+        try:
+            return json.loads(self.path.read_text())
+        except (OSError, ValueError):
+            return {}
+
+    def load(self) -> str | None:
+        return self._read().get("token") or None
+
+    def expires_at(self) -> int:
+        return int(self._read().get("expires_at", 0))
+
+    def save(self, token: str, expires_at: int) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps({"token": token, "expires_at": expires_at}))
+        self.path.chmod(0o600)
+
+    def clear(self) -> None:
+        try:
+            self.path.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def is_token_expired(token: str | None, store: "TokenStore | None" = None) -> bool:
+    """True if no token or the stored expiry has passed."""
+    if not token:
+        return True
+    store = store or TokenStore()
+    exp = store.expires_at()
+    return exp == 0 or time.time() >= exp

dooers/cli/user_config.py

@@ -0,0 +1,28 @@
+"""~/.dooers/config.json — non-secret CLI prefs (default org)."""
+
+import json
+from pathlib import Path
+
+DEFAULT_CONFIG_PATH = Path.home() / ".dooers" / "config.json"
+
+
+class UserConfig:
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path or DEFAULT_CONFIG_PATH
+
+    def _read(self) -> dict:
+        if not self.path.exists():
+            return {}
+        try:
+            return json.loads(self.path.read_text())
+        except (OSError, ValueError):
+            return {}
+
+    def get_default_org(self) -> str | None:
+        return self._read().get("default_org")
+
+    def set_default_org(self, org_id: str) -> None:
+        data = self._read()
+        data["default_org"] = org_id
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(data))

dooers/cli/validate.py

@@ -0,0 +1,115 @@
+"""Pre-push validation for agent projects (`dooers validate`)."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+from pydantic import ValidationError
+
+from dooers.cli.config import MANIFEST_FILENAME, read_manifest
+
+_LEGACY_SDK_DEP = re.compile(r"dooers-agents(?!-server|-client)")
+_LEGACY_IMPORT = re.compile(
+    r"^\s*(?:"
+    r"from dooers_agents(?:\.|\s+import)|"
+    r"from dooers import|"
+    r"import dooers_agents(?:\s|$)|"
+    r"import dooers(?:\s|$)"
+    r")",
+    re.MULTILINE,
+)
+
+
+@dataclass(frozen=True)
+class ValidationIssue:
+    level: str  # "error" | "warning"
+    message: str
+
+
+def collect_issues(root: Path | None = None) -> list[ValidationIssue]:
+    """Return validation findings for an agent repo rooted at `root` (default: cwd)."""
+    base = root or Path.cwd()
+    issues: list[ValidationIssue] = []
+
+    manifest_path = base / MANIFEST_FILENAME
+    if not manifest_path.exists():
+        issues.append(
+            ValidationIssue(
+                "error",
+                f"missing {MANIFEST_FILENAME} — run `dooers agents create`",
+            )
+        )
+    else:
+        try:
+            read_manifest(directory=base)
+        except ValidationError as e:
+            issues.append(ValidationIssue("error", f"{MANIFEST_FILENAME} is invalid: {e}"))
+
+    dockerfile = base / "Dockerfile"
+    if not dockerfile.exists():
+        issues.append(ValidationIssue("error", "missing Dockerfile"))
+
+    pyproject = base / "pyproject.toml"
+    if not pyproject.exists():
+        issues.append(ValidationIssue("warning", "missing pyproject.toml"))
+    else:
+        text = pyproject.read_text()
+        if _LEGACY_SDK_DEP.search(text):
+            issues.append(
+                ValidationIssue(
+                    "error",
+                    "pyproject.toml still depends on legacy `dooers-agents` — "
+                    "use `dooers-agents-server` with `from dooers.agents.server import ...`",
+                )
+            )
+        elif "dooers-agents-server" not in text:
+            issues.append(
+                ValidationIssue(
+                    "warning",
+                    "pyproject.toml has no `dooers-agents-server` dependency — "
+                    "agent projects usually depend on the SDK",
+                )
+            )
+
+    scan_roots = [p for p in (base / "src", base) if p.is_dir()]
+    py_files: list[Path] = []
+    for scan_root in scan_roots:
+        py_files.extend(scan_root.rglob("*.py"))
+    seen: set[Path] = set()
+    for path in sorted(py_files):
+        if path in seen or ".venv" in path.parts:
+            continue
+        seen.add(path)
+        if _LEGACY_IMPORT.search(path.read_text()):
+            rel = path.relative_to(base)
+            issues.append(
+                ValidationIssue(
+                    "error",
+                    f"{rel} uses legacy SDK imports — "
+                    "update to `from dooers.agents.server import ...`",
+                )
+            )
+
+    return issues
+
+
+def validate(ctx: typer.Context) -> None:
+    """Validate dooers.yaml, Dockerfile, and SDK dependency/import conventions."""
+    _ = ctx
+    issues = collect_issues()
+    errors = [i for i in issues if i.level == "error"]
+    warnings = [i for i in issues if i.level == "warning"]
+
+    for issue in issues:
+        prefix = "Error" if issue.level == "error" else "Warning"
+        typer.echo(f"{prefix}: {issue.message}", err=issue.level == "error")
+
+    if errors:
+        raise typer.Exit(code=1)
+    if warnings:
+        typer.echo("Validation passed with warnings.")
+    else:
+        typer.echo("Validation passed.")

dooers_cli-0.5.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,21 @@
+dooers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dooers/cli/__init__.py,sha256=qAXc0sh11tQ5IrNt43LvhiFLequXFxczawSmimZnm3Y,56
+dooers/cli/agent_store.py,sha256=GCZ30pa7JkuWuAro5ZpH_7ko8J448Ku_Dg96IgakRmQ,2253
+dooers/cli/agents.py,sha256=R4FIAH2HLRTCAC2iDmf-8OBTCaxZ_FyyOaZ4E-m6E6A,3537
+dooers/cli/auth.py,sha256=CTldHElS05jmhbQYzR5fCTorXTrSMIqJjz_P1Z40LWA,2557
+dooers/cli/cli.py,sha256=sbui1MJEdtz3gHdnqxmjq__Y-nxRuT4JTrQF_Hl2kEc,1546
+dooers/cli/config.py,sha256=1JuYa1qR5r6WNaqjpmyxegZN4y-u4iFLRdHOODtvXxM,983
+dooers/cli/core_client.py,sha256=bO7fawkaXrF7X_bdvAY1RRb_GmmCy3dUw22HZBI-4WQ,4068
+dooers/cli/ignore.py,sha256=Mez7nW7ap7nz58aSQR0c9tBhkb7ByyTJ0DW1k4LrBqY,2853
+dooers/cli/manifest_sync.py,sha256=QaY2Y-xSuboo4_8mwQnlD1iAx-dOHKjbLDZeHSchFEc,2666
+dooers/cli/org.py,sha256=2AEeakY1NNUX1YyxLBLctDY_YG07kkKVvIIXwy8ZECU,2836
+dooers/cli/push.py,sha256=-qIWYcZWcJLqsm6YIKWsPTiPOSNRUIqXeYfkIy8en1g,4952
+dooers/cli/push_client.py,sha256=J0SpxN6_tUzyKbLW7DTu6yPBVdPwVhovDzVM0GsMuhQ,1770
+dooers/cli/settings.py,sha256=ZPwpcsRm679q9Thnd3Qj5GJYr5QO2N8a27lsvDce0FY,870
+dooers/cli/token_store.py,sha256=CigyeyFCMAZV_gkYlPsuLnX2KV0Af1aXi-PGyAK-7E0,1351
+dooers/cli/user_config.py,sha256=ek3H_rJ-Lvgu6My_1u5otw9BFn9h9ZL9__kRNcaCmJU,826
+dooers/cli/validate.py,sha256=jtXB4xSMxBWhd3ZkjwhjnOMJ9nDP8P7sA3EpicR3qV0,3666
+dooers_cli-0.5.0.dist-info/METADATA,sha256=j2psdjHIkzcPMp60cBZWURwQrw29pV9CLXG7rBAo60o,2221
+dooers_cli-0.5.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+dooers_cli-0.5.0.dist-info/entry_points.txt,sha256=2D_sdksnDQmQsoVZnnhrvthjPuxGZY4nsCr66ORq1Ao,46
+dooers_cli-0.5.0.dist-info/RECORD,,

dooers_cli-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

dooers_cli-0.5.0.dist-info/entry_points.txt

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