dooers-cli 0.8.0__tar.gz → 0.8.2__tar.gz

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dooers-cli
-Version: 0.8.0
+Version: 0.8.2
 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>

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dooers-cli"
-version = "0.8.0"
+version = "0.8.2"
 description = "Dooers CLI — push agents to Dooers, manage agent records, authenticate from the terminal"
 readme = "README.md"
 license = "MIT"

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/src/dooers/cli/agents.py

@@ -57,7 +57,7 @@ def create(
             name=rec.name,
             organization_id=rec.organization_id or organization_id,
             description=description,
-            message_path="/",
+            message_path="/ws",
             message_scheme="wss",
             whatsapp=WhatsAppConfig(enabled=False, path=None),
             profile=ProfileConfig(),
@@ -76,10 +76,73 @@ def create(
             err=True,
         )
     typer.echo(
-        "Edit dooers.yaml (message_path, whatsapp, profile, database) then run dooers push."
+        "Edit dooers.yaml (profile, tools, whatsapp, database) then "
+        "`dooers push` to deploy, or `dooers agents update` to sync config only."
     )
 
 
+@app.command()
+def update(ctx: typer.Context) -> None:
+    """Apply dooers.yaml settings to the core agent record (no deploy).
+
+    Syncs description, profile (capabilities/tools), UI, WhatsApp, and
+    serverConfig.apiMessagesUrl derived from message_path + the agent's
+    existing hostUrl. Requires a prior successful prod push so hostUrl is set.
+    """
+    store, _, _ = _store(ctx)
+    try:
+        manifest = config.read_manifest()
+    except Exception as e:  # noqa: BLE001 — pydantic ValidationError etc.
+        typer.echo(f"Invalid {config.MANIFEST_FILENAME}: {e}", err=True)
+        raise typer.Exit(code=1) from e
+    if manifest is None:
+        typer.echo(
+            f"Missing {config.MANIFEST_FILENAME}. Run `dooers agents create` first.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        rec = store.get(manifest.agent_id)
+    except KeyError:
+        typer.echo(f"Agent {manifest.agent_id} not found in core.", err=True)
+        raise typer.Exit(code=1)
+    except AgentStoreError as e:
+        typer.echo(f"update failed: {e}", err=True)
+        raise typer.Exit(code=1) from e
+
+    if not rec.host_url:
+        typer.echo(
+            "Agent has no hostUrl yet. Run `dooers push` once to deploy, "
+            "then `dooers agents update` to sync config.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    from dooers.cli.manifest_sync import build_agent_patch
+
+    patch = build_agent_patch(manifest, rec.host_url)
+    if not patch:
+        typer.echo("Nothing to sync from dooers.yaml.")
+        return
+
+    try:
+        updated = store.update(manifest.agent_id, patch)
+    except AgentStoreError as e:
+        typer.echo(f"update failed: {e}", err=True)
+        raise typer.Exit(code=1) from e
+
+    typer.echo(f"Updated agent {updated.agent_id} from {config.MANIFEST_FILENAME}.")
+    if "serverConfig" in patch:
+        typer.echo(f"  apiMessagesUrl: {patch['serverConfig'].get('apiMessagesUrl')}")
+    if "description" in patch:
+        typer.echo(f"  description: {patch['description']}")
+    if "profile" in patch:
+        typer.echo(f"  profile keys: {', '.join(patch['profile'])}")
+    if "settings" in patch:
+        typer.echo(f"  settings keys: {', '.join(patch['settings'])}")
+
+
 @app.command("rotate-key")
 def rotate_key(
     ctx: typer.Context,

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/src/dooers/cli/cli.py

@@ -41,7 +41,7 @@ app.command(name="logout", help="Clear local credentials.")(auth.logout)
 app.add_typer(
     agents.app,
     name="agents",
-    help="Manage agents — subcommands: list | create | rotate-key | show | delete.",
+    help="Manage agents — subcommands: list | create | update | rotate-key | show | delete.",
 )
 app.add_typer(org.app, name="org", help="Manage organization — subcommands: list | use.")
 app.command(

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/src/dooers/cli/config.py

@@ -16,7 +16,7 @@ def read_manifest(directory: Path | None = None) -> AgentManifest | None:
     target = (directory or Path.cwd()) / MANIFEST_FILENAME
     if not target.exists():
         return None
-    raw = yaml.safe_load(target.read_text()) or {}
+    raw = yaml.safe_load(target.read_text(encoding="utf-8")) or {}
     return AgentManifest.model_validate(raw)
 
 
@@ -24,5 +24,8 @@ def write_manifest(manifest: AgentManifest, directory: Path | None = None) -> Pa
     """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))
+    target.write_text(
+        yaml.safe_dump(manifest.model_dump(mode="json"), sort_keys=False),
+        encoding="utf-8",
+    )
     return target

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/src/dooers/cli/ignore.py

@@ -33,7 +33,7 @@ def load_ignore_patterns(directory: Path | None = None) -> list[str]:
     patterns = list(DEFAULT_IGNORE_PATTERNS)
     ignore_file = directory / ".dooersignore"
     if ignore_file.exists():
-        for raw in ignore_file.read_text().splitlines():
+        for raw in ignore_file.read_text(encoding="utf-8", errors="replace").splitlines():
             line = raw.strip()
             if not line or line.startswith("#"):
                 continue

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/src/dooers/cli/token_store.py

@@ -15,7 +15,7 @@ class TokenStore:
         if not self.path.exists():
             return {}
         try:
-            return json.loads(self.path.read_text())
+            return json.loads(self.path.read_text(encoding="utf-8"))
         except (OSError, ValueError):
             return {}
 
@@ -27,7 +27,9 @@ class TokenStore:
 
     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.write_text(
+            json.dumps({"token": token, "expires_at": expires_at}), encoding="utf-8"
+        )
         self.path.chmod(0o600)
 
     def clear(self) -> None:

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/src/dooers/cli/user_config.py

@@ -14,7 +14,7 @@ class UserConfig:
         if not self.path.exists():
             return {}
         try:
-            return json.loads(self.path.read_text())
+            return json.loads(self.path.read_text(encoding="utf-8"))
         except (OSError, ValueError):
             return {}
 
@@ -25,4 +25,4 @@ class UserConfig:
         data = self._read()
         data["default_org"] = org_id
         self.path.parent.mkdir(parents=True, exist_ok=True)
-        self.path.write_text(json.dumps(data))
+        self.path.write_text(json.dumps(data), encoding="utf-8")

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/src/dooers/cli/validate.py

@@ -1,4 +1,11 @@
-"""Pre-push validation for agent projects (`dooers validate`)."""
+"""Pre-push validation for agent projects (`dooers validate`).
+
+Every file read here belongs to the user, so its bytes are not ours to trust. They are
+decoded as UTF-8 explicitly — never via the platform locale, which is cp1252 on Windows
+and raises UnicodeDecodeError on any source file with accents or emoji — and undecodable
+bytes are replaced rather than fatal: every pattern matched below is ASCII, so U+FFFD
+cannot mask a hit, and validation must never abort over an oddly-encoded file.
+"""
 
 from __future__ import annotations
 
@@ -56,7 +63,7 @@ def collect_issues(root: Path | None = None) -> list[ValidationIssue]:
     if not pyproject.exists():
         issues.append(ValidationIssue("warning", "missing pyproject.toml"))
     else:
-        text = pyproject.read_text()
+        text = pyproject.read_text(encoding="utf-8", errors="replace")
         if _LEGACY_SDK_DEP.search(text):
             issues.append(
                 ValidationIssue(
@@ -83,7 +90,7 @@ def collect_issues(root: Path | None = None) -> list[ValidationIssue]:
         if path in seen or ".venv" in path.parts:
             continue
         seen.add(path)
-        if _LEGACY_IMPORT.search(path.read_text()):
+        if _LEGACY_IMPORT.search(path.read_text(encoding="utf-8", errors="replace")):
             rel = path.relative_to(base)
             issues.append(
                 ValidationIssue(
@@ -102,7 +109,7 @@ def collect_issues(root: Path | None = None) -> list[ValidationIssue]:
         for env_path in [base / ".env", *base.glob("env.*")]:
             if not env_path.is_file():
                 continue
-            for raw in env_path.read_text().splitlines():
+            for raw in env_path.read_text(encoding="utf-8", errors="replace").splitlines():
                 line = raw.strip()
                 if not line or line.startswith("#") or "=" not in line:
                     continue

dooers_cli-0.8.2/tests/test_agents_update.py

@@ -0,0 +1,115 @@
+"""`dooers agents update` — sync dooers.yaml to core without deploying."""
+
+import json
+from pathlib import Path
+
+import httpx
+import respx
+import yaml
+from typer.testing import CliRunner
+
+from dooers.cli.cli import app
+from dooers.cli.config import MANIFEST_FILENAME
+
+runner = CliRunner()
+
+CORE = "https://core.test"
+PUSH = "https://push.test"
+A = "550e8400-e29b-41d4-a716-446655440000"
+HOST = f"https://agents.dooers.ai/{A}"
+ROOT = ["--core-url", CORE, "--push-url", PUSH, "--env", "prod"]
+
+
+def _auth(monkeypatch):
+    class _Tok:
+        def load(self):
+            return "tok"
+
+    monkeypatch.setattr("dooers.cli.agents.TokenStore", _Tok)
+    monkeypatch.setattr("dooers.cli.agents.is_token_expired", lambda token, store: False)
+
+
+def _write_manifest(tmp_path: Path, **extra) -> Path:
+    body = {
+        "protocol_version": "0.7.0",
+        "agent_id": A,
+        "name": "revisor",
+        "organization_id": "o1",
+        "message_path": "/ws",
+        "message_scheme": "wss",
+        "description": "Azure DevOps reviewer",
+        "profile": {
+            "summary": "Reviews PRs",
+            "capabilities": ["code-review"],
+            "tools": ["ado"],
+        },
+        **extra,
+    }
+    path = tmp_path / MANIFEST_FILENAME
+    path.write_text(yaml.safe_dump(body, sort_keys=False))
+    return path
+
+
+def _agent_get(*, host_url: str | None = HOST):
+    data = {
+        "agentId": A,
+        "name": "revisor",
+        "organizationId": "o1",
+        "hostUrl": host_url,
+    }
+    return httpx.Response(200, json={"success": True, "data": data})
+
+
+@respx.mock
+def test_update_patches_core_from_manifest(monkeypatch, tmp_path):
+    _auth(monkeypatch)
+    _write_manifest(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    get_route = respx.get(f"{CORE}/api/v2/agents/{A}").mock(return_value=_agent_get())
+    patch_route = respx.patch(f"{CORE}/api/v2/agents/{A}").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "success": True,
+                "data": {
+                    "agentId": A,
+                    "name": "revisor",
+                    "organizationId": "o1",
+                    "hostUrl": HOST,
+                },
+            },
+        )
+    )
+
+    result = runner.invoke(app, [*ROOT, "agents", "update"])
+    assert result.exit_code == 0, result.output
+    assert get_route.called
+    assert patch_route.called
+    body = json.loads(patch_route.calls.last.request.content)
+    assert body["hostUrl"] == HOST
+    assert body["description"] == "Azure DevOps reviewer"
+    assert body["serverConfig"]["apiMessagesUrl"] == f"wss://agents.dooers.ai/{A}/ws"
+    assert body["profile"]["capabilities"] == ["code-review"]
+    assert body["profile"]["tools"] == ["ado"]
+    assert "Updated agent" in result.output
+
+
+@respx.mock
+def test_update_requires_host_url(monkeypatch, tmp_path):
+    _auth(monkeypatch)
+    _write_manifest(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    respx.get(f"{CORE}/api/v2/agents/{A}").mock(return_value=_agent_get(host_url=None))
+
+    result = runner.invoke(app, [*ROOT, "agents", "update"])
+    assert result.exit_code == 1
+    assert "hostUrl" in result.output
+    assert "dooers push" in result.output
+
+
+def test_update_requires_manifest(monkeypatch, tmp_path):
+    _auth(monkeypatch)
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, [*ROOT, "agents", "update"])
+    assert result.exit_code == 1
+    assert MANIFEST_FILENAME in result.output

dooers_cli-0.8.2/tests/test_encoding.py

@@ -0,0 +1,191 @@
+"""Text I/O must be UTF-8 regardless of the platform's locale encoding.
+
+`Path.read_text()` / `Path.write_text()` / `open()` without an explicit `encoding`
+fall back to `locale.getpreferredencoding(False)`. That is UTF-8 on most Linux/macOS
+setups but the ANSI codepage on Windows (cp1252 in pt-BR/en-US), so any UTF-8 source
+file with accented characters or emoji blows up with `UnicodeDecodeError` there while
+passing everywhere else.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import NamedTuple
+
+import pytest
+
+import dooers.cli
+
+SRC_ROOT = Path(dooers.cli.__file__).parent
+
+# Force a non-UTF-8 default encoding so the locale-dependent path is exercised on
+# CI. On POSIX this yields ASCII, which fails on the same bytes Windows cp1252 does.
+_NON_UTF8_ENV = {
+    "LC_ALL": "C",
+    "LANG": "C",
+    "LC_CTYPE": "C",
+    "PYTHONUTF8": "0",
+    "PYTHONCOERCECLOCALE": "0",
+}
+
+_ACCENTED_SOURCE = "# configuração do modelo 🚀\nfrom dooers.agents.server import AgentServer\n"
+
+
+def _write_utf8(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(content.encode("utf-8"))
+
+
+class _Run(NamedTuple):
+    returncode: int
+    stdout: bytes
+    stderr: str
+
+
+def _run_in_non_utf8_locale(code: str, *args: str) -> _Run:
+    """Run `code` in a child process whose default encoding is not UTF-8.
+
+    Output is captured as bytes and decoded explicitly: text mode would decode using
+    the *parent's* locale, which is itself cp1252 on Windows and would corrupt the
+    comparison this module exists to make. The child's command line is decoded by the
+    child using that same non-UTF-8 locale, so `code` and `args` must stay ASCII.
+    """
+    proc = subprocess.run(
+        [sys.executable, "-c", code, *args],
+        env={**os.environ, **_NON_UTF8_ENV},
+        capture_output=True,
+    )
+    return _Run(proc.returncode, proc.stdout, proc.stderr.decode("utf-8", errors="replace"))
+
+
+def _make_agent_project(root: Path) -> None:
+    _write_utf8(
+        root / "dooers.yaml",
+        'protocol_version: "2"\n'
+        'agent_id: "550e8400-e29b-41d4-a716-446655440000"\n'
+        "name: test\n"
+        'organization_id: "org_1"\n'
+        "description: agente de gestão de tarefas 🚀\n",
+    )
+    _write_utf8(root / "Dockerfile", "FROM python:3.12-slim\n")
+    _write_utf8(
+        root / "pyproject.toml",
+        '[project]\ndependencies = ["dooers-agents-server>=0.12.0"]\n',
+    )
+    _write_utf8(root / "src" / "modules" / "llm" / "factory.py", _ACCENTED_SOURCE)
+
+
+@pytest.fixture
+def non_utf8_locale_available() -> None:
+    probe = _run_in_non_utf8_locale(
+        "import locale, sys; sys.stdout.write(locale.getpreferredencoding(False))"
+    )
+    encoding = probe.stdout.decode("ascii", errors="replace").strip().lower()
+    if encoding.replace("-", "").replace("_", "") in {"utf8", ""}:
+        pytest.skip(f"cannot force a non-UTF-8 locale here (got {encoding!r})")
+
+
+@pytest.mark.usefixtures("non_utf8_locale_available")
+def test_validate_reads_utf8_sources_under_non_utf8_locale(tmp_path: Path) -> None:
+    """`dooers validate` must not crash on a .py file with accents/emoji."""
+    _make_agent_project(tmp_path)
+
+    result = _run_in_non_utf8_locale(
+        "import sys;"
+        "from dooers.cli.validate import collect_issues;"
+        "issues = collect_issues(__import__('pathlib').Path(sys.argv[1]));"
+        "sys.stdout.write(repr([i.message for i in issues if i.level == 'error']))",
+        str(tmp_path),
+    )
+
+    assert result.returncode == 0, f"validate crashed under a non-UTF-8 locale:\n{result.stderr}"
+    assert result.stdout.strip() == b"[]", f"unexpected errors: {result.stdout!r}"
+
+
+@pytest.mark.usefixtures("non_utf8_locale_available")
+def test_manifest_roundtrip_under_non_utf8_locale(tmp_path: Path) -> None:
+    """dooers.yaml with non-ASCII text must read back byte-identical."""
+    _make_agent_project(tmp_path)
+
+    result = _run_in_non_utf8_locale(
+        "import sys, pathlib;"
+        "from dooers.cli.config import read_manifest, write_manifest;"
+        "d = pathlib.Path(sys.argv[1]);"
+        "m = read_manifest(directory=d);"
+        "write_manifest(m, directory=d);"
+        "sys.stdout.buffer.write((read_manifest(directory=d).description or '').encode('utf-8'))",
+        str(tmp_path),
+    )
+
+    assert result.returncode == 0, f"manifest roundtrip crashed:\n{result.stderr}"
+    assert result.stdout == "agente de gestão de tarefas 🚀".encode()
+
+
+@pytest.mark.usefixtures("non_utf8_locale_available")
+def test_dooersignore_read_under_non_utf8_locale(tmp_path: Path) -> None:
+    """.dooersignore may contain non-ASCII paths."""
+    _write_utf8(tmp_path / ".dooersignore", "# ignorar anotações\nrelatórios/\n")
+
+    # The child's command line is itself decoded with the C locale, so it must stay
+    # pure ASCII — the non-ASCII pattern goes in as an escape sequence.
+    result = _run_in_non_utf8_locale(
+        "import sys, pathlib;"
+        "from dooers.cli.ignore import load_ignore_patterns;"
+        "pats = load_ignore_patterns(pathlib.Path(sys.argv[1]));"
+        "sys.stdout.buffer.write(b'OK' if 'relat\\u00f3rios/' in pats else b'MISSING')",
+        str(tmp_path),
+    )
+
+    assert result.returncode == 0, f"load_ignore_patterns crashed:\n{result.stderr}"
+    assert result.stdout == b"OK"
+
+
+def _text_io_calls_without_encoding(tree: ast.AST) -> list[tuple[str, int]]:
+    """Find text-mode I/O calls that rely on the platform's default encoding."""
+    offenders: list[tuple[str, int]] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+
+        if isinstance(func, ast.Attribute):
+            name = func.attr
+            # tarfile.open() takes no `encoding` in the text sense — it is an archive.
+            if isinstance(func.value, ast.Name) and func.value.id == "tarfile":
+                continue
+        elif isinstance(func, ast.Name):
+            name = func.id
+        else:
+            continue
+
+        if name not in {"read_text", "write_text", "open"}:
+            continue
+
+        # Binary mode has no encoding to specify.
+        mode = next(
+            (a for a in node.args if isinstance(a, ast.Constant) and isinstance(a.value, str)),
+            None,
+        )
+        if name == "open" and mode is not None and "b" in mode.value:
+            continue
+
+        if not any(kw.arg == "encoding" for kw in node.keywords):
+            offenders.append((name, node.lineno))
+    return offenders
+
+
+def test_no_text_io_relies_on_platform_default_encoding() -> None:
+    """Regression guard: every text read/write in the CLI pins encoding explicitly."""
+    failures: list[str] = []
+    for path in sorted(SRC_ROOT.rglob("*.py")):
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+        for name, lineno in _text_io_calls_without_encoding(tree):
+            failures.append(f"{path.relative_to(SRC_ROOT.parent.parent)}:{lineno}: {name}()")
+
+    assert not failures, "text I/O without encoding='utf-8' (breaks on Windows cp1252):\n" + (
+        "\n".join(failures)
+    )

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/tests/test_manifest_sync.py

@@ -56,6 +56,12 @@ def test_message_path_root_slash():
     assert url == "wss://agents.dooers.ai/ag-x"
 
 
+def test_message_path_ws_default_convention():
+    m = _manifest(message_path="/ws")
+    patch = build_agent_patch(m, DEPLOYED)
+    assert patch["serverConfig"]["apiMessagesUrl"] == "wss://agents.dooers.ai/ag-x/ws"
+
+
 def test_no_message_path_no_server_config():
     m = _manifest()
     patch = build_agent_patch(m, DEPLOYED)

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/tests/test_smoke.py

@@ -24,7 +24,7 @@ def test_login_help_has_positional_email() -> None:
 def test_agents_help() -> None:
     result = runner.invoke(app, ["agents", "--help"])
     assert result.exit_code == 0
-    for cmd in ("list", "create", "show"):
+    for cmd in ("list", "create", "update", "show"):
         assert cmd in result.stdout
 
 

{dooers_cli-0.8.0 → dooers_cli-0.8.2}/uv.lock

@@ -232,7 +232,7 @@ toml = [
 
 [[package]]
 name = "dooers-cli"
-version = "0.8.0"
+version = "0.8.2"
 source = { editable = "." }
 dependencies = [
     { name = "dooers-protocol" },