kctl-vendure 0.6.2__py3-none-any.whl

kctl_vendure/__init__.py

@@ -0,0 +1,3 @@
+"""kctl-vendure: Kodemeio Vendure e-commerce CLI."""
+
+__version__ = "0.6.2"

kctl_vendure/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m kctl_vendure."""
+
+from kctl_vendure.cli import _run
+
+_run()

kctl_vendure/cli.py

@@ -0,0 +1,101 @@
+"""Main CLI entry point for kctl-vendure."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib import KctlError, handle_cli_error
+
+from kctl_vendure import __version__
+from kctl_vendure.commands.assets import app as assets_app
+from kctl_vendure.commands.config_cmd import app as config_app
+from kctl_vendure.commands.customers import app as customers_app
+from kctl_vendure.commands.doctor import app as doctor_app
+from kctl_vendure.commands.orders import app as orders_app
+from kctl_vendure.commands.payments import app as payments_app
+from kctl_vendure.commands.products import app as products_app
+from kctl_vendure.core.callbacks import AppContext
+from kctl_lib.self_update import notify_if_outdated
+from kctl_lib.tui import add_tui_command
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-vendure {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-vendure",
+    help="Kodemeio Vendure CLI - manage your Vendure e-commerce instance.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON (shortcut for --format json)")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    output_format: Annotated[
+        str, typer.Option("--format", "-f", help="Output format: pretty, json, csv, yaml")
+    ] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Omit headers in CSV output")] = False,
+    debug: Annotated[bool, typer.Option("--debug", help="Enable debug logging")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    url: Annotated[str | None, typer.Option("--url", help="API URL override")] = None,
+    username: Annotated[str | None, typer.Option("--username", "-u", help="Admin username override")] = None,
+    password: Annotated[str | None, typer.Option("--password", help="Admin password override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio Vendure e-commerce CLI."""
+    import os
+
+    if debug:
+        os.environ["KCTL_DEBUG"] = "1"
+
+    effective_format = "json" if json_output else output_format
+
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output or effective_format == "json",
+        quiet=quiet,
+        format=effective_format,
+        no_header=no_header,
+        debug=debug,
+        profile=profile,
+        url_override=url,
+        username_override=username,
+        password_override=password,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-vendure", __version__)
+
+
+# ---------------------------------------------------------------------------
+# Command groups
+# ---------------------------------------------------------------------------
+app.add_typer(config_app, name="config")
+app.add_typer(products_app, name="products")
+app.add_typer(orders_app, name="orders")
+app.add_typer(customers_app, name="customers")
+app.add_typer(assets_app, name="assets")
+app.add_typer(payments_app, name="payments")
+app.add_typer(doctor_app, name="doctor")
+add_tui_command(app, service_key="vendure", version=__version__)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_vendure/commands/assets.py

@@ -0,0 +1,90 @@
+"""Asset management commands for Vendure e-commerce."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_vendure.core.callbacks import AppContext
+
+app = typer.Typer(help="Manage Vendure assets.")
+
+# ---------------------------------------------------------------------------
+# GraphQL Operations
+# ---------------------------------------------------------------------------
+
+ASSETS_LIST_QUERY = """
+query GetAssets($options: AssetListOptions) {
+    assets(options: $options) {
+        items {
+            id
+            name
+            type
+            fileSize
+            mimeType
+            source
+            preview
+        }
+        totalItems
+    }
+}
+"""
+
+DELETE_ASSET_MUTATION = """
+mutation DeleteAsset($input: DeleteAssetInput!) {
+    deleteAsset(input: $input) {
+        result
+        message
+    }
+}
+"""
+
+
+@app.command("list")
+def list_cmd(
+    ctx: typer.Context,
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Number of assets to return")] = 10,
+    skip: Annotated[int, typer.Option("--skip", help="Number of assets to skip")] = 0,
+) -> None:
+    """List assets."""
+    c: AppContext = ctx.obj
+    out = c.output
+    variables = {"options": {"take": limit, "skip": skip}}
+    data = c.client.query(ASSETS_LIST_QUERY, variables)
+    assets_data = data.get("assets", {})
+    items = assets_data.get("items", [])
+    total = assets_data.get("totalItems", 0)
+
+    if c.json_mode:
+        out.raw_json({"items": items, "totalItems": total})
+    else:
+        out.info(f"Assets ({total} total)")
+        out.table(items, columns=["id", "name", "type", "fileSize", "mimeType"], title="Assets")
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    asset_id: Annotated[str, typer.Argument(help="Asset ID")],
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation and force delete")] = False,
+) -> None:
+    """Delete an asset."""
+    c: AppContext = ctx.obj
+    out = c.output
+
+    if not force:
+        typer.confirm(f"Delete asset {asset_id}?", abort=True)
+
+    variables = {"input": {"assetId": asset_id, "force": force}}
+    data = c.client.mutate(DELETE_ASSET_MUTATION, variables)
+    result = data.get("deleteAsset", {})
+
+    if c.json_mode:
+        out.raw_json(result)
+    else:
+        if result.get("result") == "DELETED":
+            out.success(f"Asset {asset_id} deleted")
+        else:
+            out.error(f"Delete failed: {result.get('message', 'Unknown error')}")
+            raise typer.Exit(1)

kctl_vendure/commands/config_cmd.py

@@ -0,0 +1,108 @@
+"""Configuration management commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_vendure.core.callbacks import AppContext
+from kctl_vendure.core.config import (
+    CONFIG_FILE,
+    SERVICE_KEY,
+    ServiceConfig,
+    get_all_services_in_profile,
+    get_default_profile,
+    get_profile_names,
+    resolve_active_profile_name,
+    set_default_profile,
+    set_service_config,
+)
+
+app = typer.Typer(help="Manage CLI configuration and profiles.")
+
+
+def _mask(val: str) -> str:
+    if not val:
+        return "[dim]not set[/dim]"
+    return f"{val[:4]}{'*' * max(0, len(val) - 8)}{val[-4:]}" if len(val) > 10 else "****"
+
+
+@app.command()
+def init(
+    ctx: typer.Context,
+    url: Annotated[str | None, typer.Option("--url")] = None,
+    username: Annotated[str | None, typer.Option("--username", "-u")] = None,
+    password: Annotated[str | None, typer.Option("--password")] = None,
+    name: Annotated[str | None, typer.Option("--name", "-n")] = None,
+) -> None:
+    """Initialize CLI configuration."""
+    c: AppContext = ctx.obj
+    out = c.output
+    profile_name = name or typer.prompt("Profile name", default="kodemeio")
+    api_url = url or typer.prompt("Vendure URL (e.g. https://shop.example.com)")
+    admin_user = username or typer.prompt("Admin username", default="superadmin")
+    admin_pass = password or typer.prompt("Admin password", hide_input=True)
+
+    svc = ServiceConfig(url=api_url, admin_username=admin_user, admin_password=admin_pass)
+    set_service_config(profile_name, svc)
+    if len(get_profile_names()) <= 1:
+        set_default_profile(profile_name)
+    out.success(f"Configuration saved to {CONFIG_FILE}")
+    out.kv("Profile", profile_name)
+    out.kv("URL", api_url)
+    out.kv("Username", admin_user)
+    out.kv("Password", _mask(admin_pass))
+
+
+@app.command()
+def show(ctx: typer.Context) -> None:
+    """Show configuration (passwords masked)."""
+    c: AppContext = ctx.obj
+    out = c.output
+    default = get_default_profile()
+    sections = [
+        (
+            "General",
+            [
+                ("Config file", str(CONFIG_FILE)),
+                ("Default profile", default),
+                ("Service key", SERVICE_KEY),
+            ],
+        )
+    ]
+    for pname in get_profile_names():
+        marker = " [green](default)[/green]" if pname == default else ""
+        services = get_all_services_in_profile(pname)
+        kvs = []
+        for svc_name, svc_data in services.items():
+            if not isinstance(svc_data, dict):
+                continue
+            indicator = "[green]●[/green]" if svc_name == SERVICE_KEY else "[dim]○[/dim]"
+            kvs.append(
+                (
+                    f"{indicator} {svc_name}",
+                    f"{svc_data.get('url', '')}  user: {svc_data.get('admin_username', '')}  pass: {_mask(svc_data.get('admin_password', ''))}",
+                )
+            )
+        sections.append((f"Profile: {pname}{marker}", kvs or [("(empty)", "")]))
+    out.detail("Configuration", sections)
+
+
+@app.command()
+def test(ctx: typer.Context) -> None:
+    """Test API connection."""
+    c: AppContext = ctx.obj
+    out = c.output
+    active = resolve_active_profile_name(c.profile)
+    out.info(f"Testing profile '{active}' -> {SERVICE_KEY}")
+    try:
+        status = c.client.check_health()
+        if status == 200:
+            out.success("Connected to Vendure API")
+        else:
+            out.error(f"Connection failed: HTTP {status}")
+            raise typer.Exit(1)
+    except Exception as e:
+        out.error(f"Connection failed: {e}")
+        raise typer.Exit(1) from e

kctl_vendure/commands/customers.py

@@ -0,0 +1,104 @@
+"""Customer management commands for Vendure e-commerce."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_vendure.core.callbacks import AppContext
+
+app = typer.Typer(help="Manage Vendure customers.")
+
+# ---------------------------------------------------------------------------
+# GraphQL Operations
+# ---------------------------------------------------------------------------
+
+CUSTOMERS_LIST_QUERY = """
+query GetCustomers($options: CustomerListOptions) {
+    customers(options: $options) {
+        items {
+            id
+            firstName
+            lastName
+            emailAddress
+            createdAt
+        }
+        totalItems
+    }
+}
+"""
+
+CUSTOMER_GET_QUERY = """
+query GetCustomer($id: ID!) {
+    customer(id: $id) {
+        id
+        firstName
+        lastName
+        emailAddress
+        phoneNumber
+        createdAt
+        orders {
+            items {
+                id
+                code
+                state
+                totalWithTax
+            }
+            totalItems
+        }
+    }
+}
+"""
+
+
+@app.command("list")
+def list_cmd(
+    ctx: typer.Context,
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Number of customers to return")] = 10,
+    skip: Annotated[int, typer.Option("--skip", help="Number of customers to skip")] = 0,
+) -> None:
+    """List customers."""
+    c: AppContext = ctx.obj
+    out = c.output
+    variables = {"options": {"take": limit, "skip": skip}}
+    data = c.client.query(CUSTOMERS_LIST_QUERY, variables)
+    customers_data = data.get("customers", {})
+    items = customers_data.get("items", [])
+    total = customers_data.get("totalItems", 0)
+
+    if c.json_mode:
+        out.raw_json({"items": items, "totalItems": total})
+    else:
+        out.info(f"Customers ({total} total)")
+        out.table(items, columns=["id", "firstName", "lastName", "emailAddress", "createdAt"], title="Customers")
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    customer_id: Annotated[str, typer.Argument(help="Customer ID")],
+) -> None:
+    """Get a single customer with order history."""
+    c: AppContext = ctx.obj
+    out = c.output
+    data = c.client.query(CUSTOMER_GET_QUERY, {"id": customer_id})
+    customer = data.get("customer")
+
+    if not customer:
+        out.error(f"Customer {customer_id} not found")
+        raise typer.Exit(1)
+
+    if c.json_mode:
+        out.raw_json(customer)
+    else:
+        out.kv("ID", customer["id"])
+        out.kv("Name", f"{customer['firstName']} {customer['lastName']}")
+        out.kv("Email", customer["emailAddress"])
+        out.kv("Phone", customer.get("phoneNumber", ""))
+        out.kv("Created", customer.get("createdAt", ""))
+        orders = customer.get("orders", {})
+        order_items = orders.get("items", [])
+        if order_items:
+            out.info(f"Orders ({orders.get('totalItems', 0)} total)")
+            out.table(order_items, columns=["id", "code", "state", "totalWithTax"], title="Orders")

kctl_vendure/commands/doctor.py

@@ -0,0 +1,83 @@
+"""Doctor diagnostic checks for kctl-vendure."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import typer
+from kctl_lib.doctor_base import CheckResult, DoctorCheck, run_doctor
+
+from kctl_vendure.core.callbacks import AppContext
+
+
+@dataclass
+class APIConnectivityCheck:
+    """Check that the configured API endpoint is reachable."""
+
+    name: str = "API Connectivity"
+
+    def run(self) -> CheckResult:
+        try:
+            from kctl_vendure.core.config import get_service_config, resolve_active_profile_name
+
+            profile = resolve_active_profile_name()
+            cfg = get_service_config(profile)
+            url = cfg.url or ""
+            if not url:
+                return CheckResult(
+                    name=self.name,
+                    status="fail",
+                    message="No URL configured",
+                    fix_command="kctl-vendure config init",
+                )
+            return CheckResult(name=self.name, status="ok", message=f"URL: {url}")
+        except Exception as e:
+            return CheckResult(name=self.name, status="warn", message=str(e))
+
+
+@dataclass
+class AuthCheck:
+    """Check that authentication credentials are configured."""
+
+    name: str = "Authentication"
+
+    def run(self) -> CheckResult:
+        try:
+            from kctl_vendure.core.config import get_service_config, resolve_active_profile_name
+
+            profile = resolve_active_profile_name()
+            cfg = get_service_config(profile)
+            username = cfg.admin_username or ""
+            password = cfg.admin_password or ""
+            if not username or not password:
+                return CheckResult(
+                    name=self.name,
+                    status="fail",
+                    message="Admin credentials not configured",
+                    fix_command="kctl-vendure config init",
+                )
+            masked = password[:4] + "****" + password[-4:] if len(password) > 8 else "****"
+            return CheckResult(name=self.name, status="ok", message=f"User: {username}, password: {masked}")
+        except Exception as e:
+            return CheckResult(name=self.name, status="warn", message=str(e))
+
+
+app = typer.Typer(help="Run diagnostic checks.", no_args_is_help=False, invoke_without_command=True)
+
+
+@app.callback(invoke_without_command=True)
+def doctor(ctx: typer.Context) -> None:
+    """Run all diagnostic checks."""
+    if ctx.invoked_subcommand is not None:
+        return
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    checks: list[DoctorCheck] = [
+        APIConnectivityCheck(),
+        AuthCheck(),
+    ]
+
+    all_passed = run_doctor(checks, out)  # type: ignore[arg-type]
+    if not all_passed:
+        raise typer.Exit(code=1)