xcorecli 1.0.0__py3-none-any.whl

xcli/_run.py

@@ -0,0 +1,14 @@
+"""Shared utilities for calling xcore handlers."""
+import asyncio
+from argparse import Namespace
+from typing import Any, Callable, Coroutine
+
+
+def ns(**kwargs) -> Namespace:
+    """Build an argparse-compatible Namespace with config=None by default."""
+    kwargs.setdefault("config", None)
+    return Namespace(**kwargs)
+
+
+def run(coro: Coroutine[Any, Any, Any]) -> None:
+    asyncio.run(coro)

xcli/_xcore.py

@@ -0,0 +1,56 @@
+"""
+Shared helpers to boot xcore in standalone mode (no FastAPI/HTTP).
+Used by CLI commands that need direct access to the plugin system.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import yaml
+from rich.console import Console
+
+if TYPE_CHECKING:
+    from xcore import Xcore
+
+console = Console()
+
+_CONFIG_CANDIDATES = [
+    "integration.yaml", "integration.json",
+    "config/integration.yaml", "config/integration.json",
+]
+
+
+def _require_config() -> Path:
+    for c in _CONFIG_CANDIDATES:
+        if Path(c).exists():
+            return Path(c)
+    console.print("[yellow]⚠[/yellow] No integration.yaml — run [cyan]xcli init[/cyan] first.")
+    sys.exit(1)
+
+
+def load_raw_config() -> dict:
+    path = _require_config()
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+
+async def boot() -> "Xcore":
+    """Boot xcore in standalone mode (no FastAPI). Reads integration.yaml automatically."""
+    from xcore import Xcore
+    _require_config()
+    xcore = Xcore()
+    await xcore.boot()
+    return xcore
+
+
+class _NullEvents:
+    """Minimal event bus for sandbox subprocess without a full xcore boot."""
+    def emit_sync(self, *a, **kw): pass
+    async def emit(self, *a, **kw): pass
+    def subscribe(self, *a, **kw): pass
+
+
+class _NullCtx:
+    """Minimal context for SandboxProcessManager without booting xcore."""
+    _events = _NullEvents()

xcli/init/cli.py

@@ -0,0 +1,11 @@
+from typer import Typer
+
+from .manager import _app
+
+app = Typer()
+
+
+@app.command()
+def init() -> None:
+    """Initialize a new xcore project — generates integration.yaml."""
+    _app()

xcli/init/manager.py

@@ -0,0 +1,141 @@
+from pathlib import Path
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+console = Console()
+
+# ── YAML template (comments preserved) ───────────────────────
+
+_TEMPLATE = """\
+app:
+  name: {name}
+  env: {env}
+  debug: {debug}
+  secret_key: "{secret_key}"
+  plugin_prefix: "/app"
+  plugin_tags: []
+  server_key: "{server_key}"
+  server_key_iterations: 100000
+
+  fastapi:
+    title: "{name}"
+    version: "0.1.0"
+    docs_url: "/docs"
+    redoc_url: "/redoc"
+    openapi_url: "/openapi.json"
+    redirect_slashes: true
+
+  server:
+    host: "0.0.0.0"
+    port: 8000
+    workers: 1
+    reload: {reload}
+    log_level: "{log_level}"
+    proxy_headers: true
+    forwarded_allow_ips: "*"
+
+plugins:
+  directory: {plugins_dir}
+  secret_key: "{server_key}"
+  strict_trusted: false
+  interval: 10
+  entry_point: src/main.py
+
+services:
+  databases:
+    default:
+      type: {db_type}
+      url: {db_url}
+      echo: false
+
+  cache:
+    backend: memory
+    ttl: 300
+    max_size: 1000
+
+  scheduler:
+    enabled: false
+    backend: memory
+    timezone: UTC
+
+observability:
+  logging:
+    level: {log_level}
+    format: "%(asctime)s [%(levelname)s] [%(name)s] %(message)s"
+    file: log/app.log
+    max_bytes: 10485760
+    backup_count: 5
+  metrics:
+    enabled: false
+    backend: memory
+    prefix: {name}
+  tracing:
+    enabled: false
+    backend: noop
+    service_name: {name}
+    endpoint: null
+
+security:
+  allowed_imports:
+    - fastapi
+    - json
+    - re
+    - math
+    - datetime
+    - typing
+    - dataclasses
+    - enum
+    - functools
+    - collections
+    - hashlib
+    - base64
+    - asyncio
+    - logging
+    - uuid
+  forbidden_imports: []
+  rate_limit_default:
+    calls: 100
+    period_seconds: 60
+"""
+
+_DB_URL_DEFAULTS = {
+    "sqlite":     "sqlite:///./xcore.db",
+    "sqlasync":   "sqlite+aiosqlite:///./xcore.db",
+    "postgresql": "postgresql+asyncpg://user:pass@localhost:5432/dbname",
+    "mysql":      "mysql+aiomysql://user:pass@localhost:3306/dbname",
+    "mongodb":    "mongodb://localhost:27017",
+    "redis":      "redis://localhost:6379/0",
+}
+
+
+def _app() -> None:
+    console.print("\n[bold]xcli init[/bold]  [dim]— Enter to keep defaults[/dim]\n")
+
+    name       = Prompt.ask("App name",      default="xcore-app")
+    env        = Prompt.ask("Environment",   choices=["development", "production"], default="development")
+    secret_key = Prompt.ask("Secret key",    default="change-me-in-production", password=True)
+    server_key = Prompt.ask("Server key",    default="change-me-in-production", password=True)
+    db_type    = Prompt.ask("Database type", choices=list(_DB_URL_DEFAULTS), default="sqlasync")
+    db_url     = Prompt.ask("Database URL",  default=_DB_URL_DEFAULTS[db_type])
+    plugins_dir = Prompt.ask("Plugins dir",  default="./app")
+
+    is_dev  = env == "development"
+    content = _TEMPLATE.format(
+        name=name,
+        env=env,
+        debug="true" if is_dev else "false",
+        secret_key=secret_key,
+        server_key=server_key,
+        reload="true" if is_dev else "false",
+        log_level="DEBUG" if is_dev else "INFO",
+        plugins_dir=plugins_dir,
+        db_type=db_type,
+        db_url=db_url,
+    )
+
+    filename = Prompt.ask("\nSave as", default="integration")
+    path = Path(filename.split(".")[0] + ".yaml")
+    path.write_text(content, encoding="utf-8")
+
+    console.print(f"\n[green]✓[/green] [cyan]{path}[/cyan] created.")

xcli/init/upgrade.py

@@ -0,0 +1,198 @@
+"""
+upgrade.py — Migrate an existing integration.yaml to the latest schema.
+
+Strategy: deep-merge defaults → existing values win, missing keys are added.
+The original file is backed up as integration.yaml.bak before writing.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+from rich.console import Console
+from rich.markup import escape
+from rich.table import Table
+
+console = Console()
+
+# Full default schema — every key that xcli/xcore understands
+_DEFAULTS: dict = {
+    "app": {
+        "name": "xcore-app",
+        "env": "development",
+        "debug": False,
+        "secret_key": "change-me-in-production",
+        "plugin_prefix": "/app",
+        "plugin_tags": [],
+        "server_key": "change-me-in-production",
+        "server_key_iterations": 100000,
+        "fastapi": {
+            "title": "xcore-app",
+            "version": "0.1.0",
+            "docs_url": "/docs",
+            "redoc_url": "/redoc",
+            "openapi_url": "/openapi.json",
+            "redirect_slashes": True,
+        },
+        "server": {
+            "host": "0.0.0.0",
+            "port": 8000,
+            "workers": 1,
+            "reload": True,
+            "log_level": "DEBUG",
+            "proxy_headers": True,
+            "forwarded_allow_ips": "*",
+        },
+    },
+    "plugins": {
+        "directory": "./app",
+        "secret_key": "change-me-in-production",
+        "strict_trusted": False,
+        "interval": 10,
+        "entry_point": "src/main.py",
+    },
+    "services": {
+        "databases": {
+            "default": {
+                "type": "sqlasync",
+                "url": "sqlite+aiosqlite:///./xcore.db",
+                "echo": False,
+            }
+        },
+        "cache": {
+            "backend": "memory",
+            "ttl": 300,
+            "max_size": 1000,
+        },
+        "scheduler": {
+            "enabled": False,
+            "backend": "memory",
+            "timezone": "UTC",
+        },
+    },
+    "observability": {
+        "logging": {
+            "level": "DEBUG",
+            "format": "%(asctime)s [%(levelname)s] [%(name)s] %(message)s",
+            "file": "log/app.log",
+            "max_bytes": 10485760,
+            "backup_count": 5,
+        },
+        "metrics": {
+            "enabled": False,
+            "backend": "memory",
+            "prefix": "xcore",
+        },
+        "tracing": {
+            "enabled": False,
+            "backend": "noop",
+            "service_name": "xcore-app",
+            "endpoint": None,
+        },
+    },
+    "security": {
+        "allowed_imports": [
+            "fastapi", "json", "re", "math", "datetime", "typing",
+            "dataclasses", "enum", "functools", "collections",
+            "hashlib", "base64", "asyncio", "logging", "uuid",
+        ],
+        "forbidden_imports": [],
+        "rate_limit_default": {
+            "calls": 100,
+            "period_seconds": 60,
+        },
+    },
+    "marketplace": {
+        "url": "https://marketplace.xcore.dev",
+        "api_key": "",
+        "timeout": 10,
+        "cache_ttl": 300,
+    },
+}
+
+
+def _deep_merge(defaults: dict, existing: dict) -> tuple[dict, list[str]]:
+    """
+    Returns (merged, added_keys) where:
+    - existing values always win
+    - missing keys from defaults are injected
+    - added_keys lists the dotted paths of every key that was added
+    """
+    result = dict(existing)
+    added: list[str] = []
+
+    def _merge(base: dict, src: dict, target: dict, path: str) -> None:
+        for key, default_val in base.items():
+            full = f"{path}.{key}" if path else key
+            if key not in src:
+                target[key] = default_val
+                added.append(full)
+            elif isinstance(default_val, dict) and isinstance(src[key], dict):
+                target[key] = dict(src[key])
+                _merge(default_val, src[key], target[key], full)
+            # else: existing value wins, already in target
+
+    _merge(defaults, existing, result, "")
+    return result, added
+
+
+_CONFIG_CANDIDATES = [
+    "integration.yaml", "integration.json",
+    "config/integration.yaml", "config/integration.json",
+]
+
+
+def run_upgrade() -> None:
+    # Find config file
+    config_path: Path | None = None
+    for c in _CONFIG_CANDIDATES:
+        p = Path(c)
+        if p.exists():
+            config_path = p
+            break
+
+    if config_path is None:
+        console.print("[yellow]⚠[/yellow] No integration.yaml found — run [cyan]xcli init[/cyan] first.")
+        return
+
+    console.print(f"\n[bold]xcli upgrade[/bold]  [dim]{config_path}[/dim]\n")
+
+    existing = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    merged, added = _deep_merge(_DEFAULTS, existing)
+
+    if not added:
+        console.print("[green]✓[/green] Already up to date — no missing keys found.")
+        return
+
+    # Show what will be added
+    table = Table(title=f"{len(added)} key(s) will be added")
+    table.add_column("Key", style="cyan")
+    table.add_column("Default value", style="dim")
+
+    def _get_nested(d: dict, dotted: str):
+        parts = dotted.split(".")
+        for p in parts:
+            if isinstance(d, dict):
+                d = d.get(p)
+            else:
+                return None
+        return d
+
+    for key in added:
+        val = _get_nested(_DEFAULTS, key)
+        table.add_row(key, escape(str(val)))
+
+    console.print(table)
+
+    # Backup
+    bak = config_path.with_suffix(".yaml.bak")
+    bak.write_text(config_path.read_text(encoding="utf-8"), encoding="utf-8")
+    console.print(f"\n[dim]Backup → {bak}[/dim]")
+
+    # Write merged config
+    config_path.write_text(
+        yaml.dump(merged, default_flow_style=False, allow_unicode=True, sort_keys=False),
+        encoding="utf-8",
+    )
+    console.print(f"[green]✓[/green] [cyan]{config_path}[/cyan] upgraded — {len(added)} key(s) added.")

xcli/main.py

@@ -0,0 +1,64 @@
+from typer import Typer
+
+from xcli._run import ns, run
+from xcli.init.manager import _app as _init_wizard
+from xcli.init.upgrade import run_upgrade as _run_upgrade
+from xcli.manager.cli import app as manager_app
+from xcli.migrations.cli import app as migrations_app
+from xcli.plugin.cli import app as plugin_app
+from xcli.sandbox.cli import app as sandbox_app
+from xcli.worker.cli import app as worker_app
+
+_CTX = {"help_option_names": ["-h", "--help"]}
+
+app = Typer(help="xcli — xcore project manager.", context_settings=_CTX)
+
+
+# ── init ──────────────────────────────────────────────────────
+
+@app.command()
+def init() -> None:
+    """Generate integration.yaml for a new xcore project."""
+    _init_wizard()
+
+
+# ── upgrade ───────────────────────────────────────────────────
+
+@app.command()
+def upgrade() -> None:
+    """Migrate integration.yaml to the latest schema (adds missing keys, keeps existing values)."""
+    _run_upgrade()
+
+
+# ── health ────────────────────────────────────────────────────
+
+@app.command()
+def health() -> None:
+    """Global health-check of all xcore services."""
+    from xcore.cli.plugin_cmd import handle_health
+    run(handle_health(ns(json=False)))
+
+
+# ── services ──────────────────────────────────────────────────
+
+@app.command()
+def services() -> None:
+    """Show status of all xcore services."""
+    from xcore.cli.plugin_cmd import handle_services
+    run(handle_services(ns(subcommand="status", json=False)))
+
+
+# ── sub-apps ──────────────────────────────────────────────────
+
+app.add_typer(plugin_app,  name="plugin")
+app.add_typer(sandbox_app, name="sandbox")
+app.add_typer(worker_app,  name="worker")
+app.add_typer(manager_app, name="manager")
+app.add_typer(migrations_app, name="migration")
+
+# ── short aliases (hidden) ────────────────────────────────────
+app.add_typer(plugin_app,  name="p",  hidden=True)
+app.add_typer(sandbox_app, name="sb", hidden=True)
+app.add_typer(worker_app,  name="w",  hidden=True)
+app.add_typer(manager_app, name="m",  hidden=True)
+app.add_typer(migrations_app, name="mig", hidden=True)