benchops 0.1.0__py3-none-any.whl

benchops/auth.py

@@ -0,0 +1,24 @@
+"""Authentication and credential management for benchops."""
+
+import keyring
+
+SERVICE_NAME = "benchops"
+
+
+class AuthManager:
+    """Securely stores and retrieves server passwords via the system keyring."""
+
+    def set_password(self, server_alias: str, password: str) -> None:
+        """Store the password for a server in the system credential store."""
+        keyring.set_password(SERVICE_NAME, server_alias, password)
+
+    def get_password(self, server_alias: str) -> str | None:
+        """Return the stored password for a server, or None if not set."""
+        return keyring.get_password(SERVICE_NAME, server_alias)
+
+    def delete_password(self, server_alias: str) -> None:
+        """Delete the stored password for a server if one exists."""
+        try:
+            keyring.delete_password(SERVICE_NAME, server_alias)
+        except keyring.errors.PasswordDeleteError:
+            pass

benchops/cli.py

@@ -0,0 +1,177 @@
+"""CLI entry point for benchops."""
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from benchops.auth import AuthManager
+from benchops.config import ConfigManager
+from benchops.runner import LocalRunner, RemoteConnectionError, RemoteRunner
+from benchops.sync import create_tarball, extract_and_cleanup, transfer_tarball
+
+app = typer.Typer(
+    name="benchops",
+    help="A CLI tool to synchronize local Frappe development environments with remote servers.",
+    no_args_is_help=True,
+)
+server_app = typer.Typer(help="Manage configured remote servers.")
+app.add_typer(server_app, name="server")
+
+console = Console()
+
+
+def _resolve_app_dir(app_name: str) -> Path:
+    cwd = Path.cwd()
+    for candidate in (cwd / "apps" / app_name, Path(app_name)):
+        if candidate.is_dir():
+            return candidate
+    raise FileNotFoundError(
+        f"Local app directory '{app_name}' not found (looked in '{cwd / 'apps'}' and '{cwd}')."
+    )
+
+
+@app.command()
+def init() -> None:
+    """Initialize the benchops configuration."""
+    ConfigManager().init_config()
+    console.print("[green]benchops initialized successfully.[/green]")
+
+
+@server_app.command("add")
+def add_server(
+    alias: str = typer.Option(..., prompt="Server alias", help="Alias for the server."),
+    host: str = typer.Option(..., prompt="Server host", help="Hostname or IP address."),
+    port: int = typer.Option(22, prompt="SSH port", help="SSH port (default: 22)."),
+    user: str = typer.Option(..., prompt="SSH user", help="SSH username."),
+    bench_path: str = typer.Option(..., prompt="Remote bench path", help="Path to the bench directory on the server."),
+) -> None:
+    """Add or update a configured server."""
+    ConfigManager().add_server(alias, host, port, user, bench_path)
+    console.print(f"[green]Server '{alias}' saved to configuration.[/green]")
+
+
+@server_app.command("list")
+def list_servers() -> None:
+    """List all configured servers."""
+    servers = ConfigManager().list_servers()
+    if not servers:
+        console.print("[yellow]No servers configured yet. Run 'benchops server add' to add one.[/yellow]")
+        return
+    table = Table(title="Configured Servers")
+    table.add_column("Alias", style="bold cyan", no_wrap=True)
+    table.add_column("Host")
+    table.add_column("Port")
+    table.add_column("User")
+    table.add_column("Bench Path")
+    for alias, config in sorted(servers.items()):
+        table.add_row(
+            alias,
+            config["host"],
+            str(config["port"]),
+            config["user"],
+            config["bench_path"],
+        )
+    console.print(table)
+
+
+@server_app.command("set-auth")
+def set_auth(
+    alias: str = typer.Argument(..., help="Alias of the configured server."),
+) -> None:
+    """Set authentication credentials (password or SSH key) for a server."""
+    config = ConfigManager()
+    if config.get_server(alias) is None:
+        console.print(f"[red]Error: No server found with alias '{alias}'.[/red]")
+        raise typer.Exit(1)
+
+    while True:
+        auth_type = typer.prompt("Authentication type [password/key]").strip().lower()
+        if auth_type in ("password", "key"):
+            break
+        console.print("[red]Invalid choice. Enter 'password' or 'key'.[/red]")
+
+    if auth_type == "password":
+        password = typer.prompt("Password", hide_input=True, confirmation_prompt=True)
+        try:
+            AuthManager().set_password(alias, password)
+        except Exception as exc:
+            console.print(f"[red]Error: Failed to save password: {exc}[/red]")
+            raise typer.Exit(1)
+        console.print(f"[green]Password saved for server '{alias}'.[/green]")
+    else:
+        key_path = typer.prompt("Absolute path to the SSH private key", default="~/.ssh/id_rsa")
+        try:
+            config.update_server_key(alias, key_path)
+        except ValueError as exc:
+            console.print(f"[red]Error: {exc}[/red]")
+            raise typer.Exit(1)
+        console.print(f"[green]Private key path saved for server '{alias}'.[/green]")
+
+
+@app.command("deploy")
+def deploy(
+    app_name: str = typer.Argument(..., help="Name of the local Frappe app directory to sync."),
+    server_alias: str = typer.Argument(..., help="Alias of the target server."),
+) -> None:
+    """Deploy a local Frappe app to a remote server."""
+    config = ConfigManager().get_server(server_alias)
+    if config is None:
+        console.print(f"[red]Error: Server '{server_alias}' not found in configuration.[/red]")
+        raise typer.Exit(1)
+
+    try:
+        password = AuthManager().get_password(server_alias)
+    except Exception:
+        password = None
+    key_path = config.get("private_key_path")
+
+    if not password and not key_path:
+        console.print(
+            f"[red]Error: No authentication configured for server '{server_alias}'. "
+            "Run 'benchops server set-auth' first.[/red]"
+        )
+        raise typer.Exit(1)
+
+    remote_runner = RemoteRunner(
+        host=config["host"],
+        port=int(config["port"]),
+        user=config["user"],
+        password=password,
+        key_path=key_path,
+    )
+    local_runner = LocalRunner()
+
+    try:
+        app_dir = _resolve_app_dir(app_name)
+        console.print("[yellow]Starting local builds...[/yellow]")
+        local_runner.run(["bench", "build", "--app", app_name], cwd=str(app_dir.parent))
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tarball = create_tarball(str(app_dir), os.path.join(tmp_dir, f"{app_name}.tar.gz"))
+            console.print(f"[green]Created tarball: {tarball}[/green]")
+
+            console.print(
+                f"[yellow]Connecting to {config['user']}@{config['host']}:{config['port']}...[/yellow]"
+            )
+            remote_dest_dir = f"{config['bench_path']}/apps"
+            remote_tar_path = transfer_tarball(remote_runner, tarball, remote_dest_dir)
+            console.print(f"[green]Transferred tarball to {remote_tar_path}[/green]")
+
+            extract_and_cleanup(remote_runner, remote_tar_path, remote_dest_dir)
+            console.print("[green]Extracted on remote server.[/green]")
+
+        console.print("[yellow]Starting remote operations...[/yellow]")
+        remote_runner.run("bench --site all migrate", cwd=config["bench_path"])
+        remote_runner.run("bench clear-cache", cwd=config["bench_path"])
+
+        console.print(f"[green]Successfully deployed '{app_name}' to '{server_alias}'.[/green]")
+    except (subprocess.CalledProcessError, RemoteConnectionError, FileNotFoundError) as exc:
+        console.print(f"[red]Deployment failed: {exc}[/red]")
+        raise typer.Exit(1)
+    finally:
+        remote_runner.close()

benchops/config.py

@@ -0,0 +1,77 @@
+"""Configuration management for benchops."""
+
+from pathlib import Path
+
+import tomlkit
+from tomlkit.toml_file import TOMLFile
+
+CONFIG_PATH = Path.home() / ".benchops" / "config.toml"
+
+
+class ConfigManager:
+    """Reads and writes the local benchops TOML configuration file."""
+
+    def __init__(self, config_path: Path = CONFIG_PATH) -> None:
+        self.config_path = config_path
+        self.config_dir = self.config_path.parent
+
+    def init_config(self) -> None:
+        """Create the config directory and file with a [servers] table."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        if self.config_path.exists():
+            return
+        doc = tomlkit.document()
+        doc["servers"] = tomlkit.table()
+        TOMLFile(self.config_path).write(doc)
+
+    def _read(self) -> tomlkit.TOMLDocument:
+        return TOMLFile(self.config_path).read()
+
+    def add_server(
+        self,
+        alias: str,
+        host: str,
+        port: int,
+        user: str,
+        bench_path: str,
+        private_key_path: str | None = None,
+    ) -> None:
+        """Add or update a server, preserving existing comments and formatting."""
+        self.init_config()
+        doc = self._read()
+        if "servers" not in doc:
+            doc["servers"] = tomlkit.table()
+        entry = tomlkit.inline_table()
+        entry["host"] = host
+        entry["port"] = port
+        entry["user"] = user
+        entry["bench_path"] = bench_path
+        if private_key_path is not None:
+            entry["private_key_path"] = private_key_path
+        doc["servers"][alias] = entry
+        TOMLFile(self.config_path).write(doc)
+
+    def update_server_key(self, alias: str, private_key_path: str) -> None:
+        """Add or update the private key path for an existing server."""
+        self.init_config()
+        doc = self._read()
+        servers = doc.get("servers")
+        if servers is None or alias not in servers:
+            raise ValueError(f"Server '{alias}' not found in configuration.")
+        servers[alias]["private_key_path"] = private_key_path
+        TOMLFile(self.config_path).write(doc)
+
+    def get_server(self, alias: str) -> dict | None:
+        """Return the configuration for a specific server alias."""
+        return self.list_servers().get(alias)
+
+    def list_servers(self) -> dict:
+        """Return all configured servers keyed by alias."""
+        try:
+            doc = self._read()
+        except FileNotFoundError:
+            return {}
+        servers = doc.get("servers")
+        if servers is None:
+            return {}
+        return {str(alias): dict(config) for alias, config in servers.items()}

benchops/runner.py

@@ -0,0 +1,74 @@
+"""Execution engine: local subprocess and remote SSH command runners."""
+
+import subprocess
+
+import paramiko
+from fabric import Connection
+
+
+class RemoteConnectionError(Exception):
+    """Raised when an SSH connection to a remote host cannot be established."""
+
+
+class LocalRunner:
+    """Runs commands locally, streaming output to the terminal in real-time."""
+
+    def run(self, command: list[str], cwd: str | None = None) -> None:
+        """Run a command locally, streaming stdout and stderr to the console."""
+        proc = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            cwd=cwd,
+        )
+        assert proc.stdout is not None
+        for line in iter(proc.stdout.readline, ""):
+            print(line, end="")
+        returncode = proc.wait()
+        if returncode != 0:
+            raise subprocess.CalledProcessError(returncode, command)
+
+
+class RemoteRunner:
+    """Runs commands on a remote host over SSH, streaming output in real-time."""
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        user: str,
+        password: str | None = None,
+        key_path: str | None = None,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.user = user
+        connect_kwargs: dict = {}
+        if password:
+            connect_kwargs["password"] = password
+        if key_path:
+            connect_kwargs["key_filename"] = key_path
+        self.connection = Connection(
+            host=host,
+            port=port,
+            user=user,
+            connect_kwargs=connect_kwargs,
+        )
+
+    def run(self, command: str, cwd: str | None = None) -> None:
+        """Run a command on the remote host, streaming output to the terminal."""
+        try:
+            if cwd:
+                with self.connection.cd(cwd):
+                    self.connection.run(command, hide=False)
+            else:
+                self.connection.run(command, hide=False)
+        except (paramiko.ssh_exception.SSHException, OSError) as exc:
+            raise RemoteConnectionError(
+                f"Failed to connect to {self.user}@{self.host}:{self.port}: {exc}"
+            ) from exc
+
+    def close(self) -> None:
+        """Close the SSH connection."""
+        self.connection.close()

benchops/sync.py

@@ -0,0 +1,39 @@
+"""Sync engine: local compression, SFTP transfer, and remote extraction."""
+
+import tarfile
+from pathlib import Path
+
+from benchops.runner import RemoteRunner
+
+
+def _tar_filter(tarinfo: tarfile.TarInfo) -> tarfile.TarInfo | None:
+    parts = tarinfo.name.split("/")
+    if any(part in (".git", "__pycache__", "node_modules") for part in parts):
+        return None
+    if tarinfo.name.endswith(".pyc"):
+        return None
+    return tarinfo
+
+
+def create_tarball(app_path: str, output_path: str) -> str:
+    """Create a .tar.gz archive of a local directory, excluding common junk."""
+    src = Path(app_path)
+    if not src.is_dir():
+        raise FileNotFoundError(f"Application directory not found: {app_path}")
+    out = Path(output_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(out, mode="w:gz") as tar:
+        tar.add(src, arcname=src.name, filter=_tar_filter)
+    return str(out.resolve())
+
+
+def transfer_tarball(runner: RemoteRunner, local_path: str, remote_dest_dir: str) -> str:
+    """Transfer a local tarball to a remote directory over SFTP."""
+    runner.connection.put(local_path, remote_dest_dir)
+    return f"{remote_dest_dir.rstrip('/')}/{Path(local_path).name}"
+
+
+def extract_and_cleanup(runner: RemoteRunner, remote_tar_path: str, remote_extract_dir: str) -> None:
+    """Extract a remote tarball and remove it afterwards."""
+    runner.run(f"tar -xzf {remote_tar_path} -C {remote_extract_dir}")
+    runner.run(f"rm {remote_tar_path}")

benchops-0.1.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.5
+Name: benchops
+Version: 0.1.0
+Summary: A CLI tool to synchronize local Frappe development environments with remote servers.
+Author-email: Mohammad <your.email@example.com>
+Keywords: cli,deployment,erpnext,frappe,sync
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.14.6
+Requires-Dist: fabric>=3.2.3
+Requires-Dist: keyring>=25.7.0
+Requires-Dist: paramiko>=5.0.0
+Requires-Dist: rich>=15.0.0
+Requires-Dist: tomlkit>=0.15.1
+Requires-Dist: typer>=0.27.1
+Description-Content-Type: text/markdown
+
+# benchops
+
+A cross-platform CLI tool that synchronizes local Frappe development
+environments with remote servers.
+
+`benchops` automates the repetitive "ship my app to the server" workflow: it
+builds your app locally, packages it into a compressed archive, uploads it to
+the target server over SSH, extracts it into the remote bench, and runs the
+Frappe housekeeping commands to apply the changes — all with output streamed to
+your terminal in real time.
+
+## Features
+
+- **Server management** — define remote servers in a local TOML config
+  (`~/.benchops/config.toml`) with a friendly interactive CLI.
+- **Secure authentication** — store server passwords in your OS credential
+  store (`keyring`) or use an SSH private key.
+- **Real-time streaming** — every local and remote command streams its stdout
+  and stderr to your terminal as it runs.
+- **Lean transfers** — source tarballs exclude `.git`, `__pycache__`,
+  `node_modules`, and `*.pyc` to keep uploads small.
+- **One-command deploy** — build, archive, upload, extract, migrate, and clear
+  cache with a single invocation.
+
+## Requirements
+
+- Python `>= 3.14.6`
+- [uv](https://docs.astral.sh/uv/) (recommended) or `pip`
+- SSH access to the target server (password or key)
+
+## Installation
+
+```bash
+git clone <your-repo-url> benchops
+cd benchops
+uv sync
+```
+
+Install the CLI into your environment so the `benchops` command is available:
+
+```bash
+uv run pip install -e .
+# or, if you built a distribution:
+uv build && uv pip install --python .venv/bin/python dist/benchops-0.1.0-py3-none-any.whl
+```
+
+Verify it works:
+
+```bash
+benchops --help
+```
+
+## Quick start
+
+### 1. Initialize the configuration
+
+```bash
+benchops init
+```
+
+This creates `~/.benchops/config.toml` with an empty `[servers]` table.
+
+### 2. Register a server
+
+```bash
+benchops server add
+```
+
+You will be prompted for:
+
+| Field       | Description                              |
+| ----------- | ---------------------------------------- |
+| `alias`     | Short name used to reference the server  |
+| `host`      | Hostname or IP address                   |
+| `port`      | SSH port (default: `22`)                 |
+| `user`      | SSH username                             |
+| `bench_path`| Remote path to the bench directory       |
+
+You can also pass everything non-interactively:
+
+```bash
+benchops server add --alias dev1 --host 192.168.1.10 --port 22 --user frappe --bench-path /home/frappe/bench
+```
+
+List your configured servers:
+
+```bash
+benchops server list
+```
+
+### 3. Configure authentication
+
+```bash
+benchops server set-auth dev1
+```
+
+You will be asked to choose between:
+
+- **`password`** — prompted securely (hidden input, double confirmation) and
+  stored in your system keyring.
+- **`key`** — path to your SSH private key (default `~/.ssh/id_rsa`), stored in
+  the server's configuration.
+
+### 4. Deploy
+
+Run `benchops deploy` from the directory that contains your app (either inside
+the local bench's `apps/` folder or directly):
+
+```bash
+benchops deploy <app_name> <server_alias>
+```
+
+For example:
+
+```bash
+benchops deploy myapp dev1
+```
+
+The deploy pipeline:
+
+1. **Config & auth** — loads the server settings and its credentials.
+2. **Local build** — runs `bench build --app <app_name>` in the app's parent
+   directory.
+3. **Archive** — compresses `<app_name>` into a `.tar.gz` (excluding `.git`,
+   `__pycache__`, `node_modules`, and `*.pyc`) in a temporary directory.
+4. **Connect** — opens an SSH connection to the server.
+5. **Transfer & extract** — uploads the tarball and extracts it into
+   `{bench_path}/apps`.
+6. **Remote operations** — runs `bench --site all migrate` and
+   `bench clear-cache` inside `{bench_path}`.
+7. **Cleanup** — closes the connection and reports success.
+
+## Configuration
+
+All server definitions live in `~/.benchops/config.toml`:
+
+```toml
+[servers]
+dev1 = {host = "192.168.1.10", port = 22, user = "frappe", bench_path = "/home/frappe/bench", private_key_path = "/home/mohammad/.ssh/id_rsa"}
+staging = {host = "staging.example.com", port = 22, user = "deploy", bench_path = "/srv/bench"}
+```
+
+Passwords are **not** stored in this file — they are kept in the operating
+system's credential store via `keyring`.
+
+## Development
+
+```bash
+uv sync            # install dependencies
+uv build           # build wheel + sdist
+uv publish         # upload to PyPI (set UV_PUBLISH_TOKEN first)
+```
+
+## License
+
+MIT

benchops-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+benchops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+benchops/auth.py,sha256=uJ73ws12ZY5QmcyBqEW_JJgNhQ9I22CK_aAsAOYfsCU,896
+benchops/cli.py,sha256=gLmY3E8aXZNmA6GloV3aEmorK_u7dHcEt_kVTzAA5a4,6760
+benchops/config.py,sha256=TCEEZ3KA8b6IqyeXLhudta3wT_8fVp8YcQ3qRlxlgAc,2645
+benchops/runner.py,sha256=IwWeN03S5yDj09NQ0tNNKPw1EO1O6-iM8G-pjDDtnx4,2330
+benchops/sync.py,sha256=id-nFwin70xI5aeJNlC4sEOB_gI5xn_0i9BlzQSMzl0,1487
+benchops-0.1.0.dist-info/METADATA,sha256=BXdq84bJ8-3CobVR_Mci08cDcSuCRISBr7hwjjBcYt8,5078
+benchops-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+benchops-0.1.0.dist-info/entry_points.txt,sha256=G9fj6wj9SOj_kyvaJSd2XX_107-QAakTuk-7b9LdxdM,46
+benchops-0.1.0.dist-info/RECORD,,

benchops-0.1.0.dist-info/WHEEL

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

benchops-0.1.0.dist-info/entry_points.txt

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