doploy-cli 0.2.0__tar.gz

doploy_cli-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 doploy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

doploy_cli-0.2.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: doploy-cli
+Version: 0.2.0
+Summary: doploy CLI: watch builds, read logs, and drive Odoo deployments from a terminal or CI
+License: MIT
+Project-URL: Homepage, https://doploy.io
+Project-URL: Documentation, https://docs.doploy.io
+Project-URL: Dashboard, https://cloud.doploy.io
+Keywords: doploy,odoo,deploy,ci,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Dynamic: license-file
+
+# doploy CLI
+
+Watch builds, read logs, and drive your Odoo deployments on [doploy](https://doploy.io)
+from a terminal or a CI pipeline.
+
+```bash
+pipx install doploy-cli
+doploy login          # opens your browser; no tokens to paste
+doploy projects
+doploy builds <project-id> --type production
+doploy logs <build-id> --source test -f
+doploy update-modules <build-id> --wait
+```
+
+## Auth
+
+`doploy login` signs you in with your doploy account (OAuth, PKCE, loopback
+callback). Tokens refresh themselves and live in `~/.config/doploy/config.json`
+(mode 0600). Whether the CLI may deploy is controlled per app in
+Settings > Connected apps.
+
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `projects` | List your projects |
+| `builds <project>` | Recent builds, filter with `--type` |
+| `build <id>` | One build in full |
+| `tests <build>` | Test failures, `--details` for tracebacks |
+| `logs <build>` | Tail logs; `--source build\|test\|odoo`, `-f` to follow |
+| `branch create <project> <name>` | Fork a dev branch and queue its build |
+| `rebuild <build>` | Queue a rebuild |
+| `restart <build>` | Restart the Odoo service |
+| `update-modules <build> [modules]` | Run `odoo-bin -u`; `--theme`, `--wait` |
+| `backup <build>` | Start a backup; `--wait` |
+| `task <id>` | Poll a queued task |
+| `logout` | Forget saved credentials |
+
+Production targets always need `--confirm`. Destructive operations
+(deletes, restores) are not exposed.

doploy_cli-0.2.0/README.md

@@ -0,0 +1,41 @@
+# doploy CLI
+
+Watch builds, read logs, and drive your Odoo deployments on [doploy](https://doploy.io)
+from a terminal or a CI pipeline.
+
+```bash
+pipx install doploy-cli
+doploy login          # opens your browser; no tokens to paste
+doploy projects
+doploy builds <project-id> --type production
+doploy logs <build-id> --source test -f
+doploy update-modules <build-id> --wait
+```
+
+## Auth
+
+`doploy login` signs you in with your doploy account (OAuth, PKCE, loopback
+callback). Tokens refresh themselves and live in `~/.config/doploy/config.json`
+(mode 0600). Whether the CLI may deploy is controlled per app in
+Settings > Connected apps.
+
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `projects` | List your projects |
+| `builds <project>` | Recent builds, filter with `--type` |
+| `build <id>` | One build in full |
+| `tests <build>` | Test failures, `--details` for tracebacks |
+| `logs <build>` | Tail logs; `--source build\|test\|odoo`, `-f` to follow |
+| `branch create <project> <name>` | Fork a dev branch and queue its build |
+| `rebuild <build>` | Queue a rebuild |
+| `restart <build>` | Restart the Odoo service |
+| `update-modules <build> [modules]` | Run `odoo-bin -u`; `--theme`, `--wait` |
+| `backup <build>` | Start a backup; `--wait` |
+| `task <id>` | Poll a queued task |
+| `logout` | Forget saved credentials |
+
+Production targets always need `--confirm`. Destructive operations
+(deletes, restores) are not exposed.

doploy_cli-0.2.0/doploy_cli/main.py

@@ -0,0 +1,553 @@
+"""doploy CLI: thin client over the platform API (/api/platform/v1).
+
+Auth: `doploy login` opens the browser and signs you in with your doploy
+account (OAuth, PKCE, loopback callback); tokens refresh themselves. Config
+lives at ~/.config/doploy/config.json. DOPLOY_TOKEN / --token accept a
+platform API token for unattended use; deliberately undocumented.
+
+Same API surface the MCP tools use, so agent/human/CI parity is automatic.
+"""
+import argparse
+import base64
+import hashlib
+import http.server
+import json
+import os
+import secrets
+import socket
+import threading
+import webbrowser
+import stat
+import sys
+import time
+from pathlib import Path
+
+from typing import Optional
+
+import httpx
+
+DEFAULT_BASE = 'https://cloud.doploy.io'
+CONFIG_PATH = Path(os.environ.get(
+    'DOPLOY_CONFIG', Path.home() / '.config' / 'doploy' / 'config.json'))
+
+
+def _load_config() -> dict:
+    try:
+        return json.loads(CONFIG_PATH.read_text())
+    except Exception:
+        return {}
+
+
+def _save_config(cfg: dict) -> None:
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(cfg, indent=2) + '\n')
+    CONFIG_PATH.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 0600: token inside
+
+
+class Client:
+    def __init__(self, base: str, token: str, refresh: Optional[dict] = None):
+        self.base = base.rstrip('/')
+        self.token = token
+        # OAuth session (from `doploy login`): {'refresh_token', 'client_id',
+        # 'expires_at'}. When set, an expired/rejected access token is
+        # refreshed once and the new pair is saved to the config file.
+        self.refresh = refresh
+
+    def _refresh_access_token(self) -> bool:
+        if not self.refresh or not self.refresh.get('refresh_token'):
+            return False
+        r = _oauth_token_request(self.base, {
+            'grant_type': 'refresh_token',
+            'refresh_token': self.refresh['refresh_token'],
+            'client_id': self.refresh['client_id'],
+        })
+        if r is None:
+            return False
+        self.token = r['access_token']
+        self.refresh['refresh_token'] = r['refresh_token']
+        self.refresh['expires_at'] = time.time() + int(r.get('expires_in') or 3600)
+        cfg = _load_config()
+        cfg.update(access_token=self.token, refresh_token=self.refresh['refresh_token'],
+                   expires_at=self.refresh['expires_at'])
+        _save_config(cfg)
+        return True
+
+    def request(self, method: str, path: str, **kw):
+        if self.refresh and self.refresh.get('expires_at', 0) < time.time() + 30:
+            self._refresh_access_token()
+        r = self._send(method, path, **kw)
+        if r.status_code == 401 and self._refresh_access_token():
+            r = self._send(method, path, **kw)
+        if r.status_code >= 400:
+            try:
+                detail = r.json().get('error', r.text)
+            except Exception:
+                detail = r.text[:300]
+            if r.status_code == 401:
+                detail += ' (run `doploy login`)'
+            _fail(f'{r.status_code}: {detail}')
+        return r.json()
+
+    def _send(self, method: str, path: str, **kw):
+        url = f'{self.base}/api/platform/v1{path}'
+        headers = {'Authorization': f'Bearer {self.token}'}
+        with httpx.Client(timeout=60.0, follow_redirects=True) as c:
+            return c.request(method, url, headers=headers, **kw)
+
+
+def _oauth_token_request(base: str, data: dict) -> Optional[dict]:
+    with httpx.Client(timeout=30.0, follow_redirects=True) as c:
+        r = c.post(f'{base.rstrip("/")}/oauth/mcp/token', data=data)
+    if r.status_code >= 400:
+        return None
+    return r.json()
+
+
+def _fail(msg: str) -> None:
+    print(f'error: {msg}', file=sys.stderr)
+    sys.exit(1)
+
+
+def _client(args) -> Client:
+    cfg = _load_config()
+    base = args.base or os.environ.get('DOPLOY_BASE') or cfg.get('base') or DEFAULT_BASE
+    # Precedence: --token, DOPLOY_TOKEN (CI), saved PAT, saved OAuth session.
+    token = args.token or os.environ.get('DOPLOY_TOKEN') or cfg.get('token')
+    if token:
+        return Client(base, token)
+    if cfg.get('refresh_token'):
+        return Client(base, cfg.get('access_token') or '', refresh={
+            'refresh_token': cfg['refresh_token'],
+            'client_id': cfg.get('client_id'),
+            'expires_at': cfg.get('expires_at', 0),
+        })
+    _fail('not logged in; run `doploy login`')
+
+
+def _table(rows: list[dict], columns: list[str]) -> None:
+    if not rows:
+        print('(none)')
+        return
+    widths = {c: max(len(c), *(len(str(r.get(c, ''))) for r in rows)) for c in columns}
+    print('  '.join(c.upper().ljust(widths[c]) for c in columns))
+    for r in rows:
+        print('  '.join(str(r.get(c, '') if r.get(c) is not None else '')
+                        .ljust(widths[c]) for c in columns))
+
+
+# --- commands ---------------------------------------------------------------
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(('127.0.0.1', 0))
+        return s.getsockname()[1]
+
+
+def _wait_for_callback(port: int, state: str, timeout: float = 300.0) -> str:
+    """Serve one loopback request and return the OAuth `code` it carried."""
+    from urllib.parse import parse_qs, urlparse
+    result: dict = {}
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802
+            q = parse_qs(urlparse(self.path).query)
+            if q.get('state', [''])[0] != state:
+                body, result['error'] = 'State mismatch. Close this tab and retry.', 'state mismatch'
+            elif q.get('error'):
+                body, result['error'] = 'Login cancelled. You can close this tab.', q['error'][0]
+            else:
+                body, result['code'] = 'Logged in to doploy. You can close this tab.', q.get('code', [''])[0]
+            self.send_response(200)
+            self.send_header('Content-Type', 'text/html')
+            self.end_headers()
+            self.wfile.write(f'<html><body style="font-family:sans-serif"><p>{body}</p></body></html>'.encode())
+
+        def log_message(self, *a):  # silence
+            pass
+
+    server = http.server.HTTPServer(('127.0.0.1', port), Handler)
+    server.timeout = timeout
+    t = threading.Thread(target=server.handle_request, daemon=True)
+    t.start()
+    t.join(timeout)
+    server.server_close()
+    if result.get('error'):
+        _fail(f'login failed: {result["error"]}')
+    if not result.get('code'):
+        _fail('login timed out waiting for the browser')
+    return result['code']
+
+
+def _browser_login(base: str) -> None:
+    issuer = f'{base.rstrip("/")}/oauth/mcp'
+    port = _free_port()
+    redirect_uri = f'http://127.0.0.1:{port}/callback'
+    with httpx.Client(timeout=30.0, follow_redirects=True) as c:
+        r = c.post(f'{issuer}/register', json={
+            'client_name': 'doploy CLI', 'redirect_uris': [redirect_uri]})
+    if r.status_code >= 400:
+        _fail(f'could not register with {issuer}: {r.text[:200]}')
+    client_id = r.json()['client_id']
+
+    verifier = secrets.token_urlsafe(48)
+    challenge = base64.urlsafe_b64encode(
+        hashlib.sha256(verifier.encode()).digest()).decode().rstrip('=')
+    state = secrets.token_urlsafe(16)
+    from urllib.parse import urlencode
+    url = f'{issuer}/authorize?' + urlencode({
+        'response_type': 'code', 'client_id': client_id, 'redirect_uri': redirect_uri,
+        'state': state, 'scope': 'doploy.platform',
+        'code_challenge': challenge, 'code_challenge_method': 'S256'})
+    print('Opening your browser to sign in to doploy. If it does not open, visit:')
+    print(f'  {url}')
+    webbrowser.open(url)
+    code = _wait_for_callback(port, state)
+
+    tok = _oauth_token_request(base, {
+        'grant_type': 'authorization_code', 'code': code, 'redirect_uri': redirect_uri,
+        'client_id': client_id, 'code_verifier': verifier})
+    if tok is None:
+        _fail('token exchange failed')
+    cfg = _load_config()
+    cfg.pop('token', None)  # an OAuth login replaces any saved PAT
+    cfg.update(base=base, client_id=client_id, access_token=tok['access_token'],
+               refresh_token=tok['refresh_token'],
+               expires_at=time.time() + int(tok.get('expires_in') or 3600))
+    _save_config(cfg)
+
+
+def cmd_login(args):
+    base = args.base or os.environ.get('DOPLOY_BASE') or DEFAULT_BASE
+    if args.token_value or args.with_token:
+        token = args.token_value or input('Platform API token (dppat_...): ').strip()
+        if not token.startswith('dppat_'):
+            _fail("that doesn't look like a doploy platform token (dppat_...)")
+        Client(base, token).request('GET', '/projects')  # validate before saving
+        cfg = _load_config()
+        for k in ('access_token', 'refresh_token', 'client_id', 'expires_at'):
+            cfg.pop(k, None)
+        cfg.update(token=token, base=base)
+        _save_config(cfg)
+    else:
+        _browser_login(base)
+    projects = _client(argparse.Namespace(token=None, base=base)).request('GET', '/projects')
+    print(f'logged in; {len(projects["projects"])} project(s) visible; config saved to {CONFIG_PATH}')
+    print('Deploy actions: toggle "Allow deploy actions" in Settings > MCP Connections.')
+
+
+def cmd_logout(args):
+    cfg = _load_config()
+    for k in ('token', 'access_token', 'refresh_token', 'client_id', 'expires_at'):
+        cfg.pop(k, None)
+    _save_config(cfg)
+    print('logged out (revoke the grant in Settings > MCP Connections to kill the session server-side)')
+
+
+def cmd_projects(args):
+    data = _client(args).request('GET', '/projects')
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return
+    _table(data['projects'], ['id', 'name', 'odoo_version'])
+
+
+def cmd_builds(args):
+    params = {'limit': str(args.limit)}
+    if args.type:
+        params['type'] = args.type
+    data = _client(args).request('GET', f'/projects/{args.project}/builds', params=params)
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return
+    _table(data['builds'], ['id', 'type', 'status', 'fqdn', 'commit_sha', 'created'])
+
+
+def cmd_build(args):
+    data = _client(args).request('GET', f'/builds/{args.build_id}')
+    print(json.dumps(data['build'], indent=2))
+
+
+def cmd_tests(args):
+    data = _client(args).request('GET', f'/builds/{args.build_id}/test-results')
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return
+    c = data['counts']
+    print(f"build {data['build_id']} [{data['build_status']}] — "
+          f"{c['error']} errors, {c['fail']} failures, {c['warning']} warnings")
+    for r in data['results']:
+        if r['error_type'] == 'WARNING' and not args.warnings:
+            continue
+        print(f"\n[{r['error_type']}] {r['module']}.{r['test']}")
+        if args.details:
+            print(r['details'])
+
+
+def cmd_rebuild(args):
+    data = _client(args).request(
+        'POST', f'/builds/{args.build_id}/rebuild',
+        json={'confirm': args.confirm})
+    print(f"rebuild queued: new build {data['new_build_id']} ({data['fqdn']})")
+
+
+def cmd_restart(args):
+    data = _client(args).request(
+        'POST', f'/builds/{args.build_id}/restart',
+        json={'confirm': args.confirm})
+    print(data.get('message', 'restart queued'))
+
+
+def _new_lines(previous: list[str], current: list[str]) -> list[str]:
+    """Lines in `current` not yet printed, given the last tail `previous`.
+
+    Both are tails of the same growing log, so the longest suffix of
+    `previous` that is a prefix of `current` is the overlap; everything after
+    it is new. An empty overlap means the log rotated or grew past the window,
+    in which case the whole window is new.
+    """
+    if not previous:
+        return current
+    max_overlap = min(len(previous), len(current))
+    for size in range(max_overlap, 0, -1):
+        if previous[-size:] == current[:size]:
+            return current[size:]
+    return current
+
+
+_TERMINAL_BUILD_STATUSES = {'success', 'error', 'warning', 'active error', 'cancelled', 'deleted'}
+
+
+def cmd_logs(args):
+    client = _client(args)
+    params = {'source': args.source, 'lines': str(args.lines)}
+    if args.filter:
+        params['filter'] = args.filter
+    data = client.request('GET', f'/builds/{args.build_id}/logs', params=params)
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return
+    if args.source == 'build':
+        if data.get('error_summary'):
+            print(f"error summary: {data['error_summary']}\n")
+        for t in data.get('tasks') or []:
+            print(f"task {t['id']} [{t['status']}] {t['title']}")
+        if data.get('tasks'):
+            print()
+    shown = data['lines']
+    for ln in shown:
+        print(ln)
+    if not args.follow:
+        if data.get('truncated'):
+            print(f"... (showing last {len(shown)} lines; use --lines to see more)", file=sys.stderr)
+        return
+    # Follow: poll and print only what is new. Build and test logs end when
+    # the build settles; the odoo source is a running container's stdout, so
+    # it follows until Ctrl-C (like `docker logs -f`). Each odoo poll runs a
+    # small playbook on the host, so it is polled no faster than every 15s.
+    interval = max(args.interval, 15.0) if args.source == 'odoo' else args.interval
+    if args.source == 'odoo':
+        print(f'following container logs every {interval:.0f}s; Ctrl-C to stop', file=sys.stderr)
+    previous = shown
+    try:
+        while True:
+            time.sleep(interval)
+            data = client.request('GET', f'/builds/{args.build_id}/logs', params=params)
+            current = data['lines']
+            for ln in _new_lines(previous, current):
+                print(ln, flush=True)
+            previous = current
+            if args.source != 'odoo' and \
+                    (data.get('build_status') or '').lower() in _TERMINAL_BUILD_STATUSES:
+                print(f"build {args.build_id} is {data['build_status']}", file=sys.stderr)
+                return
+    except KeyboardInterrupt:
+        print('', file=sys.stderr)
+        return
+
+
+def cmd_branch_create(args):
+    body = {'name': args.name}
+    if args.base_branch is not None:
+        body['base_branch_id'] = args.base_branch
+    data = _client(args).request('POST', f'/projects/{args.project}/branches', json=body)
+    b = data['branch']
+    print(f"branch {b['name']} (id {b['id']}) created from {b['base_branch']}; "
+          f"build {data['build_id']} queued at {data['fqdn']}")
+
+
+def cmd_update_modules(args):
+    body = {'confirm': args.confirm, 'include_reverse_deps': args.reverse_deps}
+    if args.modules:
+        body['modules'] = [m for chunk in args.modules for m in chunk.split(',') if m]
+    if args.theme is not None:
+        body['install_theme'] = args.theme
+    data = _client(args).request('POST', f'/builds/{args.build_id}/update-modules', json=body)
+    theme = ' with INSTALL_THEME=1' if data.get('install_theme') else ''
+    print(f"update queued (task {data['task_id']}): {', '.join(data['modules'])}{theme}")
+    if not args.wait:
+        print(f"poll with: doploy task {data['task_id']}")
+        return
+    task = _wait_for_task(_client(args), data['task_id'], args.interval)
+    _print_task(task)
+    if task['status'] != 'completed' or (task.get('result') or {}).get('ok') is False:
+        sys.exit(1)
+
+
+def _wait_for_task(client: Client, task_id: int, interval: float) -> dict:
+    while True:
+        task = client.request('GET', f'/tasks/{task_id}')['task']
+        if task['status'] in ('completed', 'failed', 'cancelled'):
+            return task
+        time.sleep(interval)
+
+
+def _print_task(task: dict) -> None:
+    print(f"task {task['id']} [{task['status']}] {task['title']}")
+    result = task.get('result')
+    if result:
+        if 'exit_code' in result:
+            print(f"exit code: {result['exit_code']}")
+        if result.get('error'):
+            print(f"error: {result['error']}")
+        if result.get('output'):
+            print(result['output'])
+
+
+def cmd_task(args):
+    client = _client(args)
+    task = _wait_for_task(client, args.task_id, args.interval) if args.wait \
+        else client.request('GET', f'/tasks/{args.task_id}')['task']
+    if args.json:
+        print(json.dumps(task, indent=2))
+        return
+    _print_task(task)
+
+
+def cmd_backup(args):
+    body = {'confirm': args.confirm}
+    if args.comment:
+        body['comment'] = args.comment
+    client = _client(args)
+    data = client.request('POST', f'/builds/{args.build_id}/backup', json=body)
+    backup = data['backup']
+    print(f"backup {backup['id']} started ({backup['status']})")
+    if not args.wait:
+        return
+    while backup['status'] == 'running':
+        time.sleep(args.interval)
+        backup = client.request('GET', f"/backups/{backup['id']}")['backup']
+    print(f"backup {backup['id']} {backup['status']}"
+          + (f", {backup['size_mb']} MB" if backup.get('size_mb') else ''))
+    if backup['status'] != 'completed':
+        sys.exit(1)
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog='doploy', description=__doc__.splitlines()[0])
+    p.add_argument('--token', help=argparse.SUPPRESS)
+    p.add_argument('--base', help=f'API base URL (default {DEFAULT_BASE})')
+    sub = p.add_subparsers(dest='command', required=True)
+
+    sp = sub.add_parser('login', help='sign in with your browser')
+    sp.add_argument('token_value', nargs='?', help=argparse.SUPPRESS)
+    sp.add_argument('--with-token', action='store_true', help=argparse.SUPPRESS)
+    sp.set_defaults(func=cmd_login)
+
+    sp = sub.add_parser('logout', help='forget saved credentials')
+    sp.set_defaults(func=cmd_logout)
+
+    sp = sub.add_parser('projects', help='list your projects')
+    sp.add_argument('--json', action='store_true')
+    sp.set_defaults(func=cmd_projects)
+
+    sp = sub.add_parser('builds', help='list builds for a project')
+    sp.add_argument('project', help='project id (from `doploy projects`)')
+    sp.add_argument('--type', choices=['development', 'staging', 'production'])
+    sp.add_argument('--limit', type=int, default=20)
+    sp.add_argument('--json', action='store_true')
+    sp.set_defaults(func=cmd_builds)
+
+    sp = sub.add_parser('build', help='show one build')
+    sp.add_argument('build_id', type=int)
+    sp.set_defaults(func=cmd_build)
+
+    sp = sub.add_parser('tests', help='test results for a build')
+    sp.add_argument('build_id', type=int)
+    sp.add_argument('--details', action='store_true', help='print failure details')
+    sp.add_argument('--warnings', action='store_true', help='include warnings')
+    sp.add_argument('--json', action='store_true')
+    sp.set_defaults(func=cmd_tests)
+
+    sp = sub.add_parser('rebuild', help='queue a rebuild (deploy scope)')
+    sp.add_argument('build_id', type=int)
+    sp.add_argument('--confirm', action='store_true',
+                    help='required when targeting production')
+    sp.set_defaults(func=cmd_rebuild)
+
+    sp = sub.add_parser('restart', help='restart the Odoo service (deploy scope)')
+    sp.add_argument('build_id', type=int)
+    sp.add_argument('--confirm', action='store_true',
+                    help='required when targeting production')
+    sp.set_defaults(func=cmd_restart)
+
+    sp = sub.add_parser('logs', help='tail build logs (build, test or odoo source)')
+    sp.add_argument('build_id', type=int)
+    sp.add_argument('--source', choices=['build', 'test', 'odoo'], default='build')
+    sp.add_argument('--lines', type=int, default=200, help='tail length (max 2000)')
+    sp.add_argument('--filter', help='only lines containing this text')
+    sp.add_argument('-f', '--follow', action='store_true',
+                    help='keep printing new lines: build/test until the build settles, '
+                         'odoo until Ctrl-C')
+    sp.add_argument('--interval', type=float, default=5.0,
+                    help='poll seconds for --follow (odoo source: minimum 15)')
+    sp.add_argument('--json', action='store_true')
+    sp.set_defaults(func=cmd_logs)
+
+    sp = sub.add_parser('branch', help='branch operations')
+    bsub = sp.add_subparsers(dest='branch_command', required=True)
+    bp = bsub.add_parser('create', help='fork a dev branch and queue its build (deploy scope)')
+    bp.add_argument('project', help='project id')
+    bp.add_argument('name', help='new branch name')
+    bp.add_argument('--from', dest='base_branch', type=int,
+                    help='base branch id (default: production branch)')
+    bp.set_defaults(func=cmd_branch_create)
+
+    sp = sub.add_parser('update-modules',
+                        help='run odoo-bin -u on a deployment (deploy scope)')
+    sp.add_argument('build_id', type=int)
+    sp.add_argument('modules', nargs='*',
+                    help='module names (default: modules doploy detected as changed)')
+    sp.add_argument('--reverse-deps', action='store_true',
+                    help='also update detected reverse-dependency modules')
+    sp.add_argument('--theme', dest='theme', action='store_true', default=None,
+                    help='rebuild theme assets (INSTALL_THEME=1); default: doploy decides')
+    sp.add_argument('--no-theme', dest='theme', action='store_false',
+                    help='never rebuild theme assets')
+    sp.add_argument('--confirm', action='store_true',
+                    help='required when targeting production')
+    sp.add_argument('--wait', action='store_true', help='block until the update finishes')
+    sp.add_argument('--interval', type=float, default=10.0, help='poll seconds for --wait')
+    sp.set_defaults(func=cmd_update_modules)
+
+    sp = sub.add_parser('task', help='show a queued task (module update)')
+    sp.add_argument('task_id', type=int)
+    sp.add_argument('--wait', action='store_true', help='block until it finishes')
+    sp.add_argument('--interval', type=float, default=10.0)
+    sp.add_argument('--json', action='store_true')
+    sp.set_defaults(func=cmd_task)
+
+    sp = sub.add_parser('backup', help='start a backup of a deployment (deploy scope)')
+    sp.add_argument('build_id', type=int)
+    sp.add_argument('--comment')
+    sp.add_argument('--confirm', action='store_true',
+                    help='required when targeting production')
+    sp.add_argument('--wait', action='store_true', help='block until the backup finishes')
+    sp.add_argument('--interval', type=float, default=15.0)
+    sp.set_defaults(func=cmd_backup)
+
+    args = p.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == '__main__':
+    main()

doploy_cli-0.2.0/doploy_cli.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: doploy-cli
+Version: 0.2.0
+Summary: doploy CLI: watch builds, read logs, and drive Odoo deployments from a terminal or CI
+License: MIT
+Project-URL: Homepage, https://doploy.io
+Project-URL: Documentation, https://docs.doploy.io
+Project-URL: Dashboard, https://cloud.doploy.io
+Keywords: doploy,odoo,deploy,ci,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Dynamic: license-file
+
+# doploy CLI
+
+Watch builds, read logs, and drive your Odoo deployments on [doploy](https://doploy.io)
+from a terminal or a CI pipeline.
+
+```bash
+pipx install doploy-cli
+doploy login          # opens your browser; no tokens to paste
+doploy projects
+doploy builds <project-id> --type production
+doploy logs <build-id> --source test -f
+doploy update-modules <build-id> --wait
+```
+
+## Auth
+
+`doploy login` signs you in with your doploy account (OAuth, PKCE, loopback
+callback). Tokens refresh themselves and live in `~/.config/doploy/config.json`
+(mode 0600). Whether the CLI may deploy is controlled per app in
+Settings > Connected apps.
+
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `projects` | List your projects |
+| `builds <project>` | Recent builds, filter with `--type` |
+| `build <id>` | One build in full |
+| `tests <build>` | Test failures, `--details` for tracebacks |
+| `logs <build>` | Tail logs; `--source build\|test\|odoo`, `-f` to follow |
+| `branch create <project> <name>` | Fork a dev branch and queue its build |
+| `rebuild <build>` | Queue a rebuild |
+| `restart <build>` | Restart the Odoo service |
+| `update-modules <build> [modules]` | Run `odoo-bin -u`; `--theme`, `--wait` |
+| `backup <build>` | Start a backup; `--wait` |
+| `task <id>` | Poll a queued task |
+| `logout` | Forget saved credentials |
+
+Production targets always need `--confirm`. Destructive operations
+(deletes, restores) are not exposed.

doploy_cli-0.2.0/doploy_cli.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+doploy_cli/__init__.py
+doploy_cli/main.py
+doploy_cli.egg-info/PKG-INFO
+doploy_cli.egg-info/SOURCES.txt
+doploy_cli.egg-info/dependency_links.txt
+doploy_cli.egg-info/entry_points.txt
+doploy_cli.egg-info/requires.txt
+doploy_cli.egg-info/top_level.txt

doploy_cli-0.2.0/doploy_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

doploy_cli-0.2.0/doploy_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+doploy = doploy_cli.main:main

doploy_cli-0.2.0/doploy_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.27

doploy_cli-0.2.0/doploy_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+doploy_cli

doploy_cli-0.2.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "doploy-cli"
+version = "0.2.0"
+description = "doploy CLI: watch builds, read logs, and drive Odoo deployments from a terminal or CI"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = ["httpx>=0.27"]
+keywords = ["doploy", "odoo", "deploy", "ci", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Build Tools",
+]
+
+[project.urls]
+Homepage = "https://doploy.io"
+Documentation = "https://docs.doploy.io"
+Dashboard = "https://cloud.doploy.io"
+
+[project.scripts]
+doploy = "doploy_cli.main:main"
+
+[tool.setuptools.packages.find]
+include = ["doploy_cli*"]

doploy_cli-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+