odoo-plugin-manager 0.1.0__py3-none-any.whl

odoo_plugin_manager-0.1.0.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: odoo-plugin-manager
+Version: 0.1.0
+Summary: OPM - Plugin Manager for Odoo (CLI)
+Author: Ahmet Atakan
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://example.com/opm
+Project-URL: Source, https://example.com/opm/repo
+Project-URL: Issues, https://example.com/opm/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12.3
+Requires-Dist: rich>=13.7.1
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: watchdog>=4.0.2
+Requires-Dist: requests>=2.32.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
+
+# 🧩 OPM — Odoo Plugin Manager (CLI)
+
+**OPM** is a modern and lightweight command-line tool for Odoo developers.
+It streamlines development and testing by providing smart automation for cache refreshes,
+module testing, and environment management — without restarting Odoo.
+
+Designed for developers who want to work faster and cleaner with **Odoo 14 → 17+**.
+
+---
+
+## ⚙️ Installation
+
+Install from PyPI:
+
+```bash
+pip install opm
+```
+
+---
+
+## 📁 Configuration
+
+When you first run OPM, it automatically creates an `opm.yaml` configuration file in your working directory.
+This file defines your Odoo connection details and development environment.
+
+Example:
+
+```yaml
+runtime:
+  odoo_url: "http://localhost:10017"
+  db: "main"
+  user: "admin"
+  pass: "admin"
+  addons:
+    - "/path/to/odoo/addons"
+  container: "odoo17"
+```
+
+> OPM automatically reads this file for every command.
+> No manual setup or environment variables required.
+
+---
+
+## 🚀 Commands
+
+### 🪄 `opm init`
+
+Initializes a new OPM project by generating a sample `opm.yaml` configuration file.
+You can edit this file to match your Odoo environment (URL, DB, user, etc.).
+
+```bash
+opm init
+```
+
+Example output:
+
+```
+[opm] Creating opm.yaml configuration...
+[opm] ✅ Configuration created successfully at ./opm.yaml
+```
+
+After running `opm init`, you can immediately start developing with:
+
+```bash
+opm dev
+```
+
+---
+
+### 🔧 `opm dev`
+
+Starts **development mode**, watching your Odoo addons directory for changes.
+Whenever you modify an XML, JS, or QWeb file, OPM triggers an automatic cache flush through RPC —
+instantly reflecting UI and view updates without restarting Odoo.
+
+```bash
+opm dev
+```
+
+Example output:
+
+```
+[opm] Connected to Odoo environment 'runtime'
+[opm] Watching for changes in: /addons
+[opm] Asset/template changed: queue_job/views/menu.xml → flush caches
+```
+
+> ⚠️ Note: This is **not full hot reload** — Python code changes still require a manual reload.
+> XML, QWeb, and JS updates are applied live through Odoo’s cache system.
+
+---
+
+### 🧪 `opm test <module>`
+
+Runs tests for the specified Odoo module.
+If the module is not yet installed, OPM automatically installs or upgrades it before running tests.
+
+```bash
+opm test my_module
+```
+
+Example:
+
+```
+[opm] Odoo binary detected: /usr/bin/odoo
+[opm] Running tests for module: my_module
+✅ Tests finished successfully.
+```
+
+If something goes wrong:
+
+```
+❌ Tests failed. See .opm/artifacts/test_last.log for details.
+```
+
+All test outputs and logs are automatically saved to:
+
+```
+.opm/artifacts/
+```
+
+> The test command is ideal for CI/CD pipelines or quick module validation
+> without manually launching Odoo.
+
+---
+
+### 🩺 `opm diagnose`
+
+Runs a quick environment diagnostic to ensure OPM and Odoo are properly connected.
+
+```bash
+opm diagnose
+```
+
+Example output:
+
+```
+[opm] 🔍 Running environment diagnostics...
+[opm] Docker CLI: ✅ Found
+[opm] Odoo binary: ✅ Found (/usr/bin/odoo)
+[opm] Testing Odoo URL: http://localhost:10017
+[opm] ✅ Odoo instance reachable.
+[opm] 🏁 Diagnose complete.
+```
+
+---
+
+## 🧩 Features
+
+| Feature                        | Description                                                         |
+| ------------------------------ | ------------------------------------------------------------------- |
+| ⚙️ **Automatic Cache Refresh** | Detects XML, QWeb, or JS changes and flushes Odoo caches instantly. |
+| 🧪 **Module Install/Upgrade**  | Automatically installs or upgrades modules before running tests.    |
+| 🗱 **Docker Integration**      | Detects and executes inside Odoo containers automatically.          |
+| 📦 **Artifact Logging**        | Saves logs and test outputs under `.opm/artifacts/`.                |
+| ⚡ **YAML Config System**       | Uses a single `opm.yaml` file for all environment details.          |
+| 🧠 **RPC-Based Architecture**  | Works with Odoo via XML-RPC — no code injection or patching needed. |
+
+---
+
+## 🔮 Future Roadmap
+
+These are upcoming features currently under development:
+
+* 🔁 **Hot Reload** — true live reload support for Odoo front-end assets
+* 🧩 **Advanced Helper Addon (`opm_dev_helper`)** — deeper cache and UI refresh controls
+* 📊 **Improved Test Reporting** — detailed test result summaries and coverage integration
+
+---
+
+## 🧠 Technical Overview
+
+| Key                    | Details                                             |
+| ---------------------- | --------------------------------------------------- |
+| **Language**           | Python 3.10+                                        |
+| **Dependencies**       | typer, rich, watchdog, requests, pyyaml, websockets |
+| **Odoo Compatibility** | 14 → 17+                                            |
+| **Platforms**          | macOS / Linux                                       |
+| **Configuration File** | `opm.yaml` (auto-created on first run)              |
+
+---
+
+## 🦦 Example Workflow
+
+A simple developer workflow might look like this:
+
+```bash
+# 1️⃣ Initialize config
+opm init
+
+# 2️⃣ Check your setup
+opm diagnose
+
+# 3️⃣ Start development mode (watch for file changes)
+opm dev
+
+# 4️⃣ Run tests for your module
+opm test my_module
+```
+
+This setup keeps your Odoo instance responsive
+and your local development cycle short — no manual restarts needed.
+
+---
+
+## 📜 License
+
+Licensed under the **GNU General Public License v3 (GPL-3.0-or-later)**.
+The OPM CLI is open source.
+Future Odoo-specific helper addons may be released under a separate commercial license.
+
+---
+
+© 2025 Ahmet Atakan — Crafted for real Odoo developers who build faster, smarter, and cleaner.

odoo_plugin_manager-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+odoo_plugin_manager-0.1.0.dist-info/licenses/LICENSE,sha256=MqaRH5XS93afus-UL_96hNFoj7RD-_xF9cHcpwap0MM,1919
+opm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opm/cli/__main__.py,sha256=ws0v0182aT9ydoJ50aIoOkz2OkgQ4Pyre_yE9r3TrSc,405
+opm/cli/commands/dev.py,sha256=xDileiSHQKj3OBrHoMEYwav9L8vAKld_XypZvrafArU,7241
+opm/cli/commands/diagnose.py,sha256=hwUVJSDYzQv8Y7P0Akpcaps-zeASSCY5RJ32lYxH4lw,3164
+opm/cli/commands/init.py,sha256=QyyE04JVZKaLz8Fgho2q3FwMKWFdRtqad9xCNpc6nd0,1006
+opm/cli/commands/test.py,sha256=1ByhEJHTO1uiFMj3ywgyHY1BJT3-To-4-Hd5DYC43pQ,6416
+opm/core/docker.py,sha256=_LwmSdEgza5rZAQx1ZZuSbqeL43l4wei_4cAKSdFkJs,1516
+opm/core/env.py,sha256=e0ZxpgHwSSNqlWIqGhvtPe8Zl_CYprdxRMAEEQtHi5U,4020
+opm/core/env_cmds.py,sha256=WpT7zA1o5YrLqBJ6fAzwRMEYrZ1Z8APW-4mCeANKEg4,1082
+opm/core/odoo_rpc.py,sha256=cqH-B1GX2802U4Z7npLrCPY59-E_RLdExmiw6rJ9M_I,838
+opm/core/state.py,sha256=URQvvMtoYYbAU8P5i3dlnDP4jwpxrigBwBuojh0uKAE,1130
+opm/core/utils.py,sha256=BUff88_sdvvVtS8fFkjtYV9qPJCrRDiAxcMne5abyYc,636
+odoo_plugin_manager-0.1.0.dist-info/METADATA,sha256=ei0GvG30b5UmPJkxYW0b5WtMKkxtb_4nQNvKEZnXpsc,6769
+odoo_plugin_manager-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+odoo_plugin_manager-0.1.0.dist-info/entry_points.txt,sha256=pXesOOkH4A05Z3PT-HzhE7x6lZ9Maxcko_1CpJjqE1E,45
+odoo_plugin_manager-0.1.0.dist-info/top_level.txt,sha256=uRgSfi0ap7tsRORXPej5HOWFJ2slgVMIuzb00w-v43w,4
+odoo_plugin_manager-0.1.0.dist-info/RECORD,,

odoo_plugin_manager-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

odoo_plugin_manager-0.1.0.dist-info/entry_points.txt

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

odoo_plugin_manager-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,23 @@
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2025 Ahmet Atakan
+
+Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
+
+Preamble
+
+The GNU General Public License is a free, copyleft license for software and other kinds of works.
+
+The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program–to make sure it remains free software for all its users.
+
+When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.
+
+For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.
+
+For the full text of the GNU General Public License v3, please see:
+https://www.gnu.org/licenses/gpl-3.0.en.html

odoo_plugin_manager-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+opm

opm/cli/__main__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+import typer
+from rich import print
+from .commands.dev import dev
+from .commands.test import test
+from .commands.init import init
+from .commands.diagnose import diagnose
+
+app = typer.Typer(add_completion=False, help="OPM - Plugin Manager for Odoo")
+
+app.command()(init)
+app.command()(diagnose)
+app.command()(dev)
+app.command()(test)
+
+if __name__ == "__main__":
+    app()

opm/cli/commands/dev.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+import time
+from pathlib import Path
+from typing import Optional
+import asyncio
+import threading
+try:
+    import websockets  # type: ignore
+except Exception:  # pragma: no cover
+    websockets = None
+
+import typer
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+from ...core.env import load_config
+from ...core.odoo_rpc import OdooRPC
+from ...core.utils import info
+
+
+class _WSBus:
+    def __init__(self):
+        self.clients = set()
+
+    async def handler(self, ws):
+        self.clients.add(ws)
+        try:
+            async for _ in ws:
+                pass
+        finally:
+            self.clients.discard(ws)
+
+    async def broadcast(self, msg: str):
+        if not self.clients:
+            return
+        await asyncio.gather(*(c.send(msg) for c in list(self.clients)), return_exceptions=True)
+
+
+def _start_ws_server(host: str, port: int):
+    """Start a lightweight WS server in a background thread.
+    Returns (broadcast_sync, stop_sync). If websockets is unavailable, both are no-ops.
+    """
+    if websockets is None:
+        def _noop(*_a, **_k):
+            return None
+        return _noop, _noop
+
+    bus = _WSBus()
+    loop = asyncio.new_event_loop()
+    ready = threading.Event()
+    stopped = {"flag": False}
+
+    async def _main():
+        async with websockets.serve(bus.handler, host, port):
+            ready.set()
+            while not stopped["flag"]:
+                await asyncio.sleep(0.25)
+
+    def _runner():
+        try:
+            loop.run_until_complete(_main())
+        finally:
+            try:
+                loop.stop()
+            except Exception:
+                pass
+            loop.close()
+
+    t = threading.Thread(target=_runner, daemon=True)
+    t.start()
+    ready.wait()
+
+    def broadcast_sync(msg: str):
+        if loop.is_closed():
+            return
+        try:
+            asyncio.run_coroutine_threadsafe(bus.broadcast(msg), loop)
+        except Exception:
+            pass
+
+    def stop_sync():
+        stopped["flag"] = True
+
+    return broadcast_sync, stop_sync
+
+
+class _WatchHandler(FileSystemEventHandler):
+    def __init__(self, on_change):
+        super().__init__()
+        self.on_change = on_change
+
+    def on_modified(self, event):
+        if event.is_directory:
+            return
+        self.on_change(Path(event.src_path))
+
+
+def dev(
+    env: Optional[str] = typer.Option(
+        None, "--env", "-e",
+        help="Environment name (from opm.yaml 'environments'); if not provided, uses default runtime"
+    ),
+    config: str = typer.Option(None, help="Path to opm.yaml"),
+    addons: Optional[str] = typer.Option("./addons", help="Watch path for addons"),
+    module: Optional[str] = typer.Option(None, help="Only target this module for quick upgrades"),
+):
+    """
+    Watch files and trigger RPC-powered hot-reload-like actions.
+    """
+    cfg = load_config(config)
+
+    # Decide which environment to use
+    if env:
+        # If user asked for an env, we MUST use it (no silent fallback)
+        if not hasattr(cfg, "resolve_env"):
+            raise typer.BadParameter("Your config does not support 'environments'.")
+        try:
+            resolved = cfg.resolve_env(env)
+        except Exception as e:
+            raise typer.BadParameter(f"Environment '{env}' not found/invalid in opm.yaml: {e}")
+        if getattr(resolved, "kind", "runtime") != "runtime":
+            raise typer.BadParameter(f"'dev' requires kind=runtime, got kind={resolved.kind!r}")
+        data = resolved.data
+        info(f"Using environment '{env}' → URL: {data.get('odoo_url')}")
+    else:
+        # Explicit message when falling back to runtime
+        info("No environment provided, using default runtime configuration.")
+        data = {
+            "odoo_url": cfg.get("runtime", "odoo_url"),
+            "db":       cfg.get("runtime", "db"),
+            "user":     cfg.get("runtime", "user"),
+            "pass":     cfg.get("runtime", "pass"),
+        }
+
+    # Resolve addons path (env → runtime → ./addons) if not explicitly provided
+    if not addons or addons == "./addons":
+        candidate = None
+        if env:
+            env_addons = (data.get("addons") or [])
+            if isinstance(env_addons, list) and env_addons:
+                candidate = env_addons[0]
+        if not candidate:
+            rt_addons = (cfg.get("runtime", "addons") or [])
+            if isinstance(rt_addons, list) and rt_addons:
+                candidate = rt_addons[0]
+        if not candidate and Path("./addons").exists():
+            candidate = "./addons"
+        addons = candidate
+        if addons:
+            info(f"No --addons provided, using resolved addons path: {addons}")
+        else:
+            raise typer.BadParameter("No addons path resolved. Pass --addons or define addons in env/runtime or create ./addons")
+
+    # Validate addons path exists and is a directory
+    addons_path = Path(addons).expanduser()
+    if not addons_path.exists():
+        raise typer.BadParameter(f"Addons path does not exist: {addons_path}")
+    if not addons_path.is_dir():
+        raise typer.BadParameter(f"Addons path is not a directory: {addons_path}")
+
+    rpc = OdooRPC(data["odoo_url"], data["db"], data["user"], data["pass"])
+    rpc.login()
+    info(f"Connected to Odoo environment '{env or 'runtime'}'. Watching for changes in: {addons_path}")
+
+    # Start WS server for live-reload notifications
+    ws_host = (cfg.get("runtime", "ws_host") or "127.0.0.1")
+    try:
+        ws_port = int(cfg.get("runtime", "ws_port") or 8765)
+    except Exception:
+        ws_port = 8765
+    broadcast, stop_ws = _start_ws_server(ws_host, ws_port)
+    if websockets is None:
+        info("[opm] websockets package not installed; live-reload WS disabled (pip install websockets)")
+        # Fallback no-ops
+        def broadcast(_msg: str):
+            return None
+        def stop_ws():
+            return None
+    else:
+        info(f"[opm] WebSocket listening on ws://{ws_host}:{ws_port}")
+
+    def on_change(path: Path):
+        p = str(path)
+        if p.endswith((".xml", ".scss", ".js")):
+            info(f"Asset/template changed: {p} → flush caches")
+            try:
+                rpc.call("opm.dev.tools", "flush_caches")
+                broadcast("reload")
+            except Exception as e:
+                info(f"flush error: {e}")
+        elif p.endswith(".py") or p.endswith("__manifest__.py"):
+            target_module = module or Path(p).parts[-2]
+            info(f"Python/manifest changed: {p} → quick upgrade {target_module}")
+            try:
+                rpc.call("opm.dev.tools", "quick_upgrade", target_module)
+                broadcast(f"reload:{target_module}")
+            except Exception as e:
+                info(f"upgrade error: {e}")
+        else:
+            info(f"Changed: {p} (no action)")
+
+    handler = _WatchHandler(on_change)
+    observer = Observer()
+    observer.schedule(handler, path=str(addons_path), recursive=True)
+    observer.start()
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+        try:
+            stop_ws()
+        except Exception:
+            pass
+    observer.join()

opm/cli/commands/diagnose.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+import subprocess
+import typer
+import requests
+
+from ...core.utils import which, info
+from ...core.env import load_config
+from ...core.odoo_rpc import OdooRPC
+
+
+def _check(cmd: str) -> str:
+    path = which(cmd)
+    return f"✅ Found ({path})" if path else "❌ Not found"
+
+
+def diagnose(
+    env: str | None = typer.Option(None, "--env", "-e", help="Environment name (from opm.yaml 'environments'); if not provided, uses runtime"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show extra details"),
+    check_auth: bool = typer.Option(False, "--check-auth", help="Attempt XML-RPC authentication using configured DB/user/pass"),
+):
+    """Check Docker, Odoo reachability, and optional XML-RPC authentication."""
+    cfg = load_config()
+
+    info("🔍 Running environment diagnostics...")
+    info(f"Docker CLI: {_check('docker')}")
+
+    # Check local Odoo binary only if relevant (local profile) or when verbose
+    profile = getattr(cfg, 'profile', cfg.data.get('profile', 'docker'))
+    if verbose or profile == 'local':
+        od = which('odoo')
+        if od:
+            info(f"Odoo binary: ✅ Found ({od})")
+        else:
+            od2 = which('odoo-bin')
+            info(f"Odoo binary: {'✅ Found ('+od2+')' if od2 else '❌ Not found'}")
+
+    # Resolve environment or fallback to runtime
+    used_env = env or 'runtime'
+    data = None
+    if env and hasattr(cfg, 'resolve_env'):
+        try:
+            resolved = cfg.resolve_env(env)
+            data = resolved.data
+        except Exception as e:
+            raise typer.BadParameter(f"Environment '{env}' not found/invalid in opm.yaml: {e}")
+    if data is None:
+        data = {
+            "odoo_url": cfg.get("runtime", "odoo_url"),
+            "db": cfg.get("runtime", "db"),
+            "user": cfg.get("runtime", "user"),
+            "pass": cfg.get("runtime", "pass"),
+        }
+
+    url = data.get("odoo_url")
+    info(f"Using environment '{used_env}' → URL: {url} | DB: {data.get('db')}")
+
+    info(f"Testing Odoo URL: {url}")
+    try:
+        r = requests.get(url, timeout=3)
+        if r.status_code == 200:
+            info("✅ Odoo instance reachable.")
+        else:
+            info(f"⚠️  Odoo responded with status code: {r.status_code}")
+    except Exception as e:
+        info(f"❌ Could not reach Odoo: {e}")
+        return
+
+    if check_auth:
+        info("🔐 Checking XML-RPC authentication...")
+        rpc = OdooRPC(url, data.get("db"), data.get("user"), data.get("pass"))
+        try:
+            rpc.login()
+            info("✅ Authentication successful.")
+        except Exception as e:
+            info("❌ Authentication failed. Verify DB name, username/email, password, and dbfilter.")
+            info(f"   Details: {e}")
+
+    if verbose and which("docker"):
+        try:
+            cp = subprocess.run(["docker", "version", "--format", "{{.Server.Version}}"], capture_output=True, text=True, timeout=3)
+            if cp.returncode == 0:
+                info(f"ℹ️  Docker server version: {cp.stdout.strip()}")
+        except Exception:
+            pass
+
+    info("🏁 Diagnose complete.")

opm/cli/commands/init.py

@@ -0,0 +1,30 @@
+# src/opm/cli/commands/init.py
+from __future__ import annotations
+import typer, shutil
+from pathlib import Path
+from ...core.utils import info
+
+def init():
+    """
+    Initialize a new OPM project in the current directory.
+    """
+    root = Path(".")
+    example = root / "opm.example.yaml"
+    target = root / "opm.yaml"
+
+    if not target.exists():
+        if example.exists():
+            shutil.copy(example, target)
+            info("✅ Created opm.yaml configuration file.")
+        else:
+            info("⚠️  Missing opm.example.yaml — please create opm.yaml manually.")
+    else:
+        info("ℹ️  opm.yaml already exists, skipping creation.")
+
+    Path(".opm").mkdir(exist_ok=True)
+    Path("dist").mkdir(exist_ok=True)
+    info("✅ Created .opm/ and dist/ directories.")
+    info("🎉 Project initialized successfully.")
+    info("Next steps:")
+    info("  • Run `opm dev` to start watching for changes.")
+    info("  • Run `opm test <module>` to execute tests inside Docker.")

opm/cli/commands/test.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+import shlex
+from pathlib import Path
+import typer
+import os
+
+from datetime import datetime
+import time
+
+from ...core.env import load_config
+from ...core.utils import info, run
+
+def test(
+    module: str = typer.Argument(..., help="Module name (e.g. opm_dev_helper)"),
+    db: str = typer.Option(None, "--db", "-d", help="Database name (fallback: runtime.db)"),
+    container: str = typer.Option(None, "--container", "-c", help="Docker container name for Odoo (use `docker ps`)"),
+    addons: str = typer.Option(None, "--addons", help="Host addons path (fallback: runtime.addons[0])"),
+    extra_ports: bool = typer.Option(True, "--extra-ports/--no-extra-ports", help="Avoid port clashes by using 8070+"),
+    debug: bool = typer.Option(False, "--debug", help="Enable Odoo debug logging"),
+    no_tty: bool = typer.Option(False, "--no-tty", help="Disable TTY for docker exec (use -i instead of -it)"),
+):
+    cfg = load_config()
+    info("[opm] 🧪 Starting test run…")
+    container = container or cfg.get("runtime", "container")
+    db = db or cfg.get("runtime", "db") or "odoo"
+    
+    info(f"[opm] Target DB: {db}")
+    info(f"[opm] Target container: {container or 'LOCAL (odoo in PATH)'}")
+
+    db_host = cfg.get("runtime", "db_host") or ""
+    db_port = cfg.get("runtime", "db_port") or ""
+    db_user = cfg.get("runtime", "db_user") or ""
+    db_password = cfg.get("runtime", "db_password") or ""
+
+    db_args = []
+    if db_host:     db_args += [f"--db_host={db_host}"]
+    if db_port:     db_args += [f"--db_port={db_port}"]
+    if db_user:     db_args += [f"--db_user={db_user}"]
+    if db_password: db_args += [f"--db_password={db_password}"]
+
+    if db_host or db_port or db_user or db_password:
+        info(f"[opm] DB conn: host={db_host or '-'} port={db_port or '-'} user={db_user or '-'}")
+
+    # Resolve addons path (host)
+    host_addons = addons
+    if not host_addons:
+        rta = cfg.get("runtime", "addons") or []
+        if rta:
+            host_addons = str(Path(rta[0]).expanduser().resolve())
+
+    info(f"[opm] Host addons: {host_addons or '(not provided)'}")
+
+    # Build addons-path (inside container)
+    addons_path = "/usr/lib/python3/dist-packages/odoo/addons"
+    if host_addons:
+        # assumes your compose mounts host_addons -> /mnt/extra-addons
+        addons_path = f"{addons_path},/mnt/extra-addons"
+
+    info(f"[opm] In-container addons-path: {addons_path}")
+    info("[opm] Install/Upgrade mode: auto (-i & -u)")
+
+    if container:
+        info("[opm] Detecting Odoo binary inside the container…")
+        # Detect odoo binary inside the container (odoo or odoo-bin)
+        code, out, err = run([
+            "bash", "-lc",
+            f"docker exec -i {shlex.quote(container)} sh -lc 'command -v odoo || command -v odoo-bin'",
+        ])
+        if code != 0 or not (out or "").strip():
+            info(f"❌ No 'odoo' or 'odoo-bin' found in container: {container}")
+            raise typer.Exit(1)
+        odoo_bin = (out or "").strip()
+        info(f"[opm] Odoo binary: {odoo_bin}")
+
+        # Ports: Odoo 17+ doesn't support xmlrpc flags; http/longpolling only if desired
+        if extra_ports:
+            ports = "--http-port=8070 --longpolling-port=8071"
+            info("[opm] Extra ports enabled: http=8070, longpolling=8071")
+        else:
+            ports = ""
+            info("[opm] Extra ports disabled (using container defaults)")
+
+        tty_flag = "-i" if no_tty else "-it"
+        log_flag = "--log-level=debug" if debug else ""
+        # Always force Odoo to write to STDOUT so we can capture logs reliably
+        log_file_flag = "--logfile=-"
+        container_log = f"/tmp/opm_test_{int(time.time())}.log"
+        # Force logfile to a container path we can copy back reliably
+        log_file_flag = f"--logfile={container_log}"
+
+        db_args_str = " ".join(db_args)
+        cmd = f"""docker exec {tty_flag} {shlex.quote(container)} {shlex.quote(odoo_bin)} -d {shlex.quote(db)} \
+                  -i {shlex.quote(module)} -u {shlex.quote(module)} --test-enable --stop-after-init \
+                  --addons-path={shlex.quote(addons_path)} {db_args_str} {ports} {log_flag} {log_file_flag}"""
+    else:
+        # bare-metal fallback (expects `odoo` in PATH)
+        db_args_str = " ".join(db_args)
+        extra_log = " --log-level=debug" if debug else ""
+        cmd = f"""stdbuf -oL -eL odoo -d {shlex.quote(db)} -i {shlex.quote(module)} -u {shlex.quote(module)} \
+                  --test-enable --stop-after-init --addons-path={shlex.quote(addons_path)} {db_args_str} --logfile=-{extra_log}"""
+
+    info("[opm] ▶️  Executing test command…")
+    info(f"[opm] Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    t0 = time.time()
+    # redacted preview (do not leak db password in logs)
+    redacted_cmd = cmd
+    if db_password:
+        redacted_cmd = redacted_cmd.replace(f"--db_password={db_password}", "--db_password=******")
+    # Uncomment the next line if you want to see the full command for debugging
+    # info(f"[opm] running: {redacted_cmd}")
+
+    if no_tty:
+        info("[opm] no-tty mode active (docker exec -i; stdout/stderr will be captured)")
+
+    # Ensure artifacts dir and wrap command to capture ALL output (stdout+stderr) to a host log file
+    artifacts_dir = Path(".opm/artifacts")
+    artifacts_dir.mkdir(parents=True, exist_ok=True)
+    host_log = artifacts_dir / "test_last.log"
+
+    # Use bash pipefail + tee so we both capture and persist logs; preserve real exit code via PIPESTATUS
+    wrapped = (
+        f"{cmd}; ec=$?; "
+        f"docker cp {shlex.quote(container)}:{shlex.quote(container_log)} {shlex.quote(str(host_log.resolve()))} >/dev/null 2>&1 || true; "
+        f"exit $ec"
+    )
+
+    code, out, err = run(["bash", "-lc", wrapped])
+    info(f"[opm] ⏱️  Duration: {time.time() - t0:.1f}s")
+    if code == 0:
+        info("✅ Tests finished successfully.")
+    else:
+        info("❌ Tests failed. Command (redacted):")
+        print(redacted_cmd)
+        info("Last lines:")
+        tail = (out or err or "").splitlines()[-80:]
+        if not tail and host_log.exists():
+            try:
+                tail = host_log.read_text(errors="ignore").splitlines()[-200:]
+            except Exception:
+                tail = []
+        print("\n".join(tail))
+        info(f"[opm] 📄 Full log: {host_log}")
+        raise typer.Exit(code)

opm/core/docker.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+from .env import Config
+from .utils import run, info
+from pathlib import Path
+import os, json, tempfile
+
+COMPOSE_TEMPLATE = """
+services:
+  db:
+    image: {pg_image}
+    environment:
+      POSTGRES_DB: odoo
+      POSTGRES_USER: odoo
+      POSTGRES_PASSWORD: odoo
+  odoo:
+    image: {odoo_image}
+    depends_on: [db]
+    environment:
+      HOST: db
+      USER: odoo
+      PASSWORD: odoo
+    command: ["odoo", "--test-enable", "--stop-after-init"]
+    volumes:
+{mounts}
+"""
+
+def _mounts_yaml(mounts):
+    lines = []
+    for m in mounts:
+        lines.append(f"      - {m}")
+    return "\n".join(lines) if lines else "      - ./addons:/mnt/extra-addons:ro"
+
+def compose_up_for_tests(cfg: Config) -> str:
+    pg_image = cfg.get("docker","postgres_image")
+    odoo_image = cfg.get("docker","odoo_image")
+    mounts = cfg.get("docker","mounts", default=[])
+    yml = COMPOSE_TEMPLATE.format(pg_image=pg_image, odoo_image=odoo_image, mounts=_mounts_yaml(mounts))
+    tmpdir = tempfile.mkdtemp(prefix="opm-")
+    compose_file = os.path.join(tmpdir, "docker-compose.yml")
+    with open(compose_file, "w", encoding="utf-8") as f:
+        f.write("version: '3.8'\n" + yml)
+    info(f"compose created at {compose_file}")
+    code, out, err = run(["docker","compose","-f",compose_file,"up","-d"])
+    if code != 0:
+        raise RuntimeError("docker compose up failed: " + err)
+    return compose_file
+
+def compose_down(compose_file: str):
+    run(["docker","compose","-f",compose_file,"down"])

opm/core/env.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+import os
+import yaml
+from pathlib import Path
+from typing import Any, Dict
+
+from dotenv import load_dotenv
+load_dotenv()
+
+def _expand_env_vars(value):
+    """Recursively expand ${VAR} from environment variables in strings of nested dict/list structures.
+    If a variable is missing, leave the placeholder as-is.
+    """
+    if isinstance(value, str):
+        # Simple ${VAR} expansion
+        import re
+        def repl(m):
+            var = m.group(1)
+            return os.getenv(var, m.group(0))
+        return re.sub(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}", repl, value)
+    elif isinstance(value, list):
+        return [_expand_env_vars(v) for v in value]
+    elif isinstance(value, dict):
+        return {k: _expand_env_vars(v) for k, v in value.items()}
+    return value
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    """Deep-merge two dictionaries without mutating inputs. override wins."""
+    out = dict(base or {})
+    for k, v in (override or {}).items():
+        if isinstance(v, dict) and isinstance(out.get(k), dict):
+            out[k] = _deep_merge(out[k], v)
+        else:
+            out[k] = v
+    return out
+
+DEFAULT_CONFIG = {
+    "profile": "docker",
+    "docker": {
+        "odoo_image": "odoo:17.0",
+        "postgres_image": "postgres:15",
+        "network": None,
+        "mounts": [],
+        "junit_path": ".opm/artifacts/junit.xml",
+        "parallel": 1,
+    },
+    "runtime": {
+        "odoo_url": "http://localhost:8069",
+        "db": "odoo",
+        "user": "admin",
+        "pass": "admin",
+        "addons": ["./addons"],
+        "vite_proxy": None,
+    }
+}
+
+class Config:
+    def __init__(self, data: Dict[str, Any]):
+        self.data = data
+
+    @property
+    def profile(self) -> str:
+        return self.data.get("profile", "docker")
+
+    def get(self, *path, default=None):
+        cur = self.data
+        for p in path:
+            if isinstance(cur, dict) and p in cur:
+                cur = cur[p]
+            else:
+                return default
+        return cur
+
+    def resolve_env(self, name: str):
+        """Return a lightweight environment object for the given name.
+        Supports optional `extends:` (e.g., extends: runtime or another env) and env var expansion.
+        """
+        envs = self.data.get("environments", {}) or {}
+        if name not in envs:
+            raise ValueError(f"Environment '{name}' not defined in opm.yaml")
+        entry = envs[name] or {}
+        base_name = entry.get("extends")
+
+        if base_name:
+            # base can be `runtime` or another env under `environments`
+            if base_name == "runtime":
+                base = self.data.get("runtime", {})
+            else:
+                base_env = envs.get(base_name)
+                if not base_env:
+                    raise ValueError(f"Environment '{name}' extends unknown base '{base_name}'")
+                base = base_env
+            merged = _deep_merge(base, entry)
+        else:
+            # If no extends, still provide fallback to runtime for missing auth fields
+            fallback = self.data.get("runtime", {})
+            merged = _deep_merge(fallback, entry)
+
+        kind = merged.get("kind", "runtime")
+        merged = _expand_env_vars(merged)
+        return type("Env", (), {"kind": kind, "data": merged})()
+
+def load_config(path: str|None = None) -> Config:
+    candidates = [path] if path else ["opm.yaml", "opm.yml"]
+    data = DEFAULT_CONFIG.copy()
+    for c in candidates:
+        p = Path(c)
+        if p.exists():
+            with open(p, "r", encoding="utf-8") as f:
+                loaded = yaml.safe_load(f) or {}
+            # shallow merge
+            def merge(a, b):
+                for k, v in b.items():
+                    if isinstance(v, dict) and isinstance(a.get(k), dict):
+                        merge(a[k], v)
+                    else:
+                        a[k] = v
+            merge(data, loaded)
+            break
+    data = _expand_env_vars(data)
+    return Config(data)

opm/core/env_cmds.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+import typer
+from ...core.env import load_config
+from ...core.state import set_default_env, get_default_env
+from ...core.utils import info
+
+app = typer.Typer(help="Manage OPM environments")
+
+@app.command("list")
+def list_envs():
+    cfg = load_config()
+    envs = (cfg.data.get("environments") or {}).keys()
+    cur = get_default_env()
+    for name in envs:
+        mark = " (current)" if name == cur else ""
+        info(f"- {name}{mark}")
+    if not envs:
+        info("No environments defined. Using 'runtime' by default.")
+
+@app.command("use")
+def use_env(name: str):
+    cfg = load_config()
+    envs = cfg.data.get("environments") or {}
+    if name not in envs:
+        raise typer.BadParameter(f"Environment '{name}' not defined in opm.yaml")
+    set_default_env(name)
+    info(f"Default environment set to '{name}'.")
+
+@app.command("current")
+def current_env():
+    cur = get_default_env()
+    if cur:
+        info(f"Current default environment: {cur}")
+    else:
+        info("No default environment selected. Using 'runtime' by default.")

opm/core/odoo_rpc.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+import xmlrpc.client
+
+class OdooRPC:
+    def __init__(self, url: str, db: str, user: str, password: str):
+        self.url = url.rstrip("/")
+        self.db = db
+        self.user = user
+        self.password = password
+        self.uid = None
+        self.common = xmlrpc.client.ServerProxy(f"{self.url}/xmlrpc/2/common")
+        self.models = xmlrpc.client.ServerProxy(f"{self.url}/xmlrpc/2/object")
+
+    def login(self):
+        self.uid = self.common.authenticate(self.db, self.user, self.password, {})
+        if not self.uid:
+            raise RuntimeError("Odoo login failed")
+
+    def call(self, model: str, method: str, *args, **kwargs):
+        if not self.uid:
+            self.login()
+        return self.models.execute_kw(self.db, self.uid, self.password, model, method, list(args), kwargs)

opm/core/state.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+import json
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+STATE_DIR = Path(".opm")
+STATE_FILE = STATE_DIR / "config.json"
+
+DEFAULT_STATE = {
+    "default_env": None,
+    "default_addons": None,
+}
+
+def load_state() -> Dict[str, Any]:
+    try:
+        if STATE_FILE.exists():
+            return {**DEFAULT_STATE, **json.loads(STATE_FILE.read_text(encoding="utf-8"))}
+    except Exception:
+        pass
+    return DEFAULT_STATE.copy()
+
+def save_state(updates: Dict[str, Any]) -> None:
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    state = load_state()
+    state.update({k: v for k, v in updates.items() if v is not None})
+    STATE_FILE.write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8")
+
+def get_default_env() -> Optional[str]:
+    return load_state().get("default_env")
+
+def set_default_env(name: Optional[str]) -> None:
+    save_state({"default_env": name})
+
+def get_default_addons() -> Optional[str]:
+    return load_state().get("default_addons")
+
+def set_default_addons(path: Optional[str]) -> None:
+    save_state({"default_addons": path})

opm/core/utils.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+import subprocess, shlex, os, sys
+from pathlib import Path
+from typing import List, Tuple
+
+def run(cmd: List[str], cwd: str|None=None, env: dict|None=None) -> Tuple[int, str, str]:
+    proc = subprocess.Popen(cmd, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    out, err = proc.communicate()
+    return proc.returncode, out, err
+
+def ensure_artifacts():
+    Path(".opm/artifacts").mkdir(parents=True, exist_ok=True)
+
+def info(msg: str):
+    print(f"[opm] {msg}")
+
+def which(bin_name: str) -> str|None:
+    from shutil import which as _which
+    return _which(bin_name)