synth-ai 0.2.8.dev4__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/cli/root.py

@@ -5,16 +5,54 @@ Canonical CLI entrypoint for Synth AI (moved from synth_ai/cli.py).
 
 from __future__ import annotations
 
+import contextlib
 import logging
 import os
 import shutil
 import signal
+import socket
 import subprocess
 import sys
+import tempfile
 import time
 
 import click
 
+# Set RUST_LOG to suppress noisy codex_otel logs by default
+# This suppresses verbose SSE event logs from Cursor's Rust logging
+if "RUST_LOG" not in os.environ:
+    os.environ["RUST_LOG"] = "codex_otel::otel_event_manager=warn"
+
+# Install log filter early to suppress noisy codex_otel logs
+try:
+    from synth_ai.utils.log_filter import install_log_filter
+    
+    # Only install if not already filtered (to avoid double-wrapping)
+    install_log_filter()
+except Exception:
+    # Silently fail if log filter can't be installed
+    pass
+
+try:
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _pkg_version
+
+    try:
+        __pkg_version__ = _pkg_version("synth-ai")
+    except PackageNotFoundError:
+        try:
+            from synth_ai import __version__ as __pkg_version__  # type: ignore
+        except Exception:
+            __pkg_version__ = "unknown"
+except Exception:
+    try:
+        from synth_ai import __version__ as __pkg_version__  # type: ignore
+    except Exception:
+        __pkg_version__ = "unknown"
+
+
+SQLD_VERSION = "v0.26.2"
+
 
 def find_sqld_binary() -> str | None:
     sqld_path = shutil.which("sqld")
@@ -25,6 +63,7 @@ def find_sqld_binary() -> str | None:
         "/usr/bin/sqld",
         os.path.expanduser("~/.local/bin/sqld"),
         os.path.expanduser("~/bin/sqld"),
+        os.path.expanduser("~/.turso/bin/sqld"),
     ]
     for path in common_paths:
         if os.path.exists(path) and os.access(path, os.X_OK):
@@ -33,124 +72,108 @@ def find_sqld_binary() -> str | None:
 
 
 def install_sqld() -> str:
-    click.echo("🔧 sqld not found. Installing...")
-    script = """#!/bin/bash
-set -e
-SQLD_VERSION="v0.26.2"
-OS=$(uname -s | tr '[:upper:]' '[:lower:]')
-ARCH=$(uname -m)
-case "$ARCH" in
-  x86_64) ARCH="x86_64" ;;
-  aarch64|arm64) ARCH="aarch64" ;;
-  *) echo "Unsupported architecture: $ARCH"; exit 1 ;;
-esac
-URL="https://github.com/tursodatabase/libsql/releases/download/libsql-server-${SQLD_VERSION}/sqld-${OS}-${ARCH}.tar.xz"
-TMP_DIR=$(mktemp -d)
-cd "$TMP_DIR"
-curl -L -o sqld.tar.xz "$URL"
-tar -xf sqld.tar.xz
-mkdir -p ~/.local/bin
-mv sqld ~/.local/bin/
-chmod +x ~/.local/bin/sqld
-cd -
-rm -rf "$TMP_DIR"
-"""
-    path = "/tmp/install_sqld.sh"
-    with open(path, "w") as f:
-        f.write(script)
-    subprocess.run(["bash", path], check=True)
-    os.unlink(path)
-    local_bin = os.path.expanduser("~/.local/bin")
-    if local_bin not in os.environ.get("PATH", ""):
-        os.environ["PATH"] = f"{local_bin}:{os.environ.get('PATH', '')}"
-    return os.path.expanduser("~/.local/bin/sqld")
-
-
-@click.group()
-def cli():
-    """Synth AI - Software for aiding the best and multiplying the will."""
+    """Install sqld via the Turso CLI, installing the CLI via Homebrew if needed."""
+
+    click.echo("🔧 sqld not found. Attempting automatic install...")
+
+    turso_cli_path = shutil.which("turso")
+    brew_path = shutil.which("brew")
 
+    if not turso_cli_path:
+        if not brew_path:
+            raise click.ClickException(
+                "Automatic install requires either Homebrew or an existing Turso CLI.\n"
+                "Install manually using one of:\n"
+                "  • brew install tursodatabase/tap/turso\n"
+                "  • curl -sSfL https://get.tur.so/install.sh | bash\n"
+                "Then run 'turso dev' once and re-run this command."
+            )
 
-# === Legacy demo command group (aliases new rl_demo implementation) ===
-@cli.group()
-def demo():
-    """Demo helpers (deploy, configure, run)."""
+        click.echo("🧰 Installing Turso CLI via Homebrew (tursodatabase/tap/turso)…")
+        try:
+            subprocess.run(
+                [brew_path, "install", "tursodatabase/tap/turso"],
+                check=True,
+            )
+        except subprocess.CalledProcessError as exc:
+            raise click.ClickException(
+                "Homebrew install failed. Please resolve brew errors and retry."
+            ) from exc
+
+        turso_cli_path = shutil.which("turso")
+        if not turso_cli_path:
+            raise click.ClickException(
+                "Homebrew reported success but the 'turso' binary is not on PATH."
+            )
 
+    click.echo("📥 Downloading sqld via 'turso dev' (this may take a few seconds)…")
 
-def _forward_to_demo(args: list[str]) -> None:
-    # Lazy import to avoid loading demo deps unless needed
+    with tempfile.NamedTemporaryFile(prefix="synth_sqld_", suffix=".db", delete=False) as temp_db:
+        temp_db_path = temp_db.name
+
+    env = os.environ.copy()
+    env.setdefault("TURSO_NONINTERACTIVE", "1")
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        port = sock.getsockname()[1]
+
+    cmd = [
+        turso_cli_path,
+        "dev",
+        f"--db-file={temp_db_path}",
+        f"--port={port}",
+    ]
+    proc: subprocess.Popen[str] | None = None
+    stdout_data = ""
+    stderr_data = ""
     try:
-        from synth_ai.demos.core import cli as demo_cli  # type: ignore
-    except Exception as e:  # pragma: no cover
-        click.echo(f"Failed to import demo CLI: {e}")
-        sys.exit(1)
-    rc = int(demo_cli.main(args) or 0)
-    if rc != 0:
-        sys.exit(rc)
-
-
-# (prepare command removed; handled by configure)
-
-
-@demo.command()
-@click.option("--local", is_flag=True, help="Run local FastAPI instead of Modal deploy")
-@click.option("--app", type=click.Path(), default=None, help="Path to Modal app.py for uv run modal deploy")
-@click.option("--name", type=str, default="synth-math-demo", help="Modal app name")
-@click.option("--script", type=click.Path(), default=None, help="Path to deploy_task_app.sh (optional legacy)")
-def deploy(local: bool, app: str | None, name: str, script: str | None):
-    """Deploy the Math Task App (Modal by default)."""
-    args: list[str] = ["rl_demo.deploy"]
-    if local:
-        args.append("--local")
-    if app:
-        args.extend(["--app", app])
-    if name:
-        args.extend(["--name", name])
-    if script:
-        args.extend(["--script", script])
-    _forward_to_demo(args)
-
-
-@demo.command()
-def configure():
-    """Print resolved environment and config path."""
-    _forward_to_demo(["rl_demo.configure"])
-
-
-@demo.command()
-def setup():
-    """Perform SDK handshake and write keys to .env."""
-    _forward_to_demo(["rl_demo.setup"])
-
-
-@demo.command()
-@click.option("--batch-size", type=int, default=None)
-@click.option("--group-size", type=int, default=None)
-@click.option("--model", type=str, default=None)
-@click.option("--timeout", type=int, default=600)
-def run(batch_size: int | None, group_size: int | None, model: str | None, timeout: int):
-    """Kick off a short RL job using the prepared TOML."""
-    args = ["rl_demo.run"]
-    if batch_size is not None:
-        args.extend(["--batch-size", str(batch_size)])
-    if group_size is not None:
-        args.extend(["--group-size", str(group_size)])
-    if model:
-        args.extend(["--model", model])
-    if timeout:
-        args.extend(["--timeout", str(timeout)])
-    _forward_to_demo(args)
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env=env,
+        )
+        try:
+            stdout_data, stderr_data = proc.communicate(timeout=10)
+        except subprocess.TimeoutExpired:
+            proc.terminate()
+            try:
+                stdout_data, stderr_data = proc.communicate(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                stdout_data, stderr_data = proc.communicate()
+    finally:
+        if proc and proc.returncode not in (0, None) and (stdout_data or stderr_data):
+            logging.getLogger(__name__).debug(
+                "turso dev stdout: %s\nstderr: %s", stdout_data, stderr_data
+            )
+        with contextlib.suppress(OSError):
+            os.unlink(temp_db_path)
 
+    sqld_path = find_sqld_binary()
+    if sqld_path:
+        click.echo(f"✅ sqld available at {sqld_path}")
+        return sqld_path
 
-@cli.command()
-def setup():
-    """Perform SDK handshake and write keys to .env."""
-    _forward_to_demo(["rl_demo.setup"])
+    raise click.ClickException(
+        "sqld download did not succeed. Run 'turso dev' manually once, "
+        "ensure it downloads sqld, and try again."
+    )
+
+
+@click.group(
+    help=f"Synth AI v{__pkg_version__}"
+)
+@click.version_option(version=__pkg_version__, prog_name="synth-ai")
+def cli():
+    """Top-level command group for Synth AI."""
 
 
 @cli.command()
 @click.option("--db-file", default="traces/v3/synth_ai.db", help="Database file path")
-@click.option("--sqld-port", default=8080, type=int, help="Port for sqld HTTP interface")
+@click.option("--sqld-port", default=8080, type=int, help="Port for sqld Hrana WebSocket interface (HTTP API will be port+1)")
 @click.option("--env-port", default=8901, type=int, help="Port for environment service")
 @click.option("--no-sqld", is_flag=True, help="Skip starting sqld daemon")
 @click.option("--no-env", is_flag=True, help="Skip starting environment service")
@@ -164,7 +187,7 @@ def setup():
     default=True,
     help="Kill any process already bound to --env-port without prompting",
 )
-def serve(
+def serve_deprecated(
     db_file: str,
     sqld_port: int,
     env_port: int,
@@ -174,6 +197,10 @@ def serve(
     force: bool,
 ):
     logging.basicConfig(level=logging.INFO, format="%(message)s")
+    click.echo(
+        "⚠️  'synth-ai serve' now targets task apps; use 'synth-ai serve' for task apps or 'synth-ai serve-deprecated' for this legacy service.",
+        err=True,
+    )
     processes = []
 
     def signal_handler(sig, frame):
@@ -192,21 +219,25 @@ def serve(
 
     if not no_sqld:
         try:
+            hrana_port = sqld_port
+            http_port = sqld_port + 1
             result = subprocess.run(
-                ["pgrep", "-f", f"sqld.*--http-listen-addr.*:{sqld_port}"],
+                ["pgrep", "-f", f"sqld.*(--hrana-listen-addr.*:{hrana_port}|--http-listen-addr.*:{http_port})"],
                 capture_output=True,
                 text=True,
             )
             if result.returncode != 0:
                 sqld_bin = find_sqld_binary() or install_sqld()
-                click.echo(f"🗄️  Starting sqld (local only) on port {sqld_port}")
+                click.echo(f"🗄️  Starting sqld (local only) on hrana port {hrana_port}, HTTP API port {http_port}")
                 proc = subprocess.Popen(
                     [
                         sqld_bin,
                         "--db-path",
                         db_file,
+                        "--hrana-listen-addr",
+                        f"127.0.0.1:{hrana_port}",
                         "--http-listen-addr",
-                        f"127.0.0.1:{sqld_port}",
+                        f"127.0.0.1:{http_port}",
                     ],
                     stdout=open("sqld.log", "w"),  # noqa: SIM115
                     stderr=subprocess.STDOUT,
@@ -262,7 +293,7 @@ def serve(
         click.echo(f"   Working directory: {os.getcwd()}")
         click.echo("")
         click.echo("🔄 Starting services...")
-        click.echo(f"   - sqld daemon: http://127.0.0.1:{sqld_port}")
+        click.echo(f"   - sqld daemon: libsql://127.0.0.1:{sqld_port} (HTTP API: http://127.0.0.1:{sqld_port + 1})")
         click.echo(f"   - Environment service: http://127.0.0.1:{env_port}")
         click.echo("")
         click.echo("💡 Tips:")

synth_ai/cli/serve/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .core import command, get_command
+from .errors import ServeCliError
+from .validation import validate_serve_options
+
+__all__ = [
+    "command",
+    "get_command",
+    "ServeCliError",
+    "validate_serve_options",
+]

synth_ai/cli/serve/core.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import click
+from synth_ai.cli.task_apps import task_app_group
+
+__all__ = ["command", "get_command"]
+
+command = task_app_group.commands.get("serve")
+
+
+def get_command() -> click.Command:
+    if command is None:
+        raise RuntimeError("Serve command is not registered on task_app_group")
+    return command

synth_ai/cli/serve/errors.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+
+class ServeCliError(RuntimeError):
+    """Base exception for serve CLI failures."""
+
+
+__all__ = ["ServeCliError"]

synth_ai/cli/serve/validation.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from collections.abc import MutableMapping
+from typing import Any
+
+__all__ = ["validate_serve_options"]
+
+
+def validate_serve_options(options: MutableMapping[str, Any]) -> MutableMapping[str, Any]:
+    """Validate parameters passed to the serve CLI command."""
+    return options

synth_ai/cli/setup.py

@@ -0,0 +1,49 @@
+import os
+import typing
+from typing import Literal
+
+import click
+from synth_ai.auth.credentials import fetch_credentials_from_web_browser
+from synth_ai.utils import (
+    resolve_env_var,
+    write_env_var_to_dotenv,
+    write_env_var_to_json,
+)
+
+Sources = Literal[
+    "web",
+    "local"
+]
+
+
+@click.command()
+@click.option(
+    "--source",
+    type=click.Choice(
+        list(typing.get_args(Sources)),
+        case_sensitive=False
+    ),
+    default="web",
+    show_default=True
+)
+def setup_cmd(source: Sources = "web") -> None:
+    credentials = {}
+    match source:
+        case "local":
+            credentials["SYNTH_API_KEY"] = resolve_env_var("SYNTH_API_KEY")
+            credentials["ENVIRONMENT_API_KEY"] = resolve_env_var("ENVIRONMENT_API_KEY")
+        case "web":
+            credentials = fetch_credentials_from_web_browser()
+
+    required = {
+        "SYNTH_API_KEY",
+        "ENVIRONMENT_API_KEY"
+    }
+    missing = [k for k in required if not credentials.get(k)]
+    if missing:
+        raise ValueError(f"Missing credential values: {', '.join(missing)}")
+
+    for k, v in credentials.items():
+        write_env_var_to_json(k, v, "~/.synth-ai/config.json")
+        write_env_var_to_dotenv(k, v)
+        os.environ[k] = v

synth_ai/cli/status.py

@@ -1,133 +1,15 @@
 #!/usr/bin/env python3
-"""
-CLI: status of agent runs/versions and environment service.
-"""
+"""Compatibility wrapper for legacy status imports."""
 
-import asyncio
+from __future__ import annotations
 
 import click
-import requests
-from rich import box
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
+from synth_ai.cli.commands.status import register as _register_status
 
 
-async def _db_stats(db_url: str) -> dict:
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+def register(cli: click.Group) -> None:
+    """Register status subcommands on the provided CLI group."""
+    _register_status(cli)
 
-    db = AsyncSQLTraceManager(db_url)
-    await db.initialize()
-    try:
-        out: dict = {}
-        # Totals
-        totals = await db.query_traces(
-            """
-            SELECT 
-              (SELECT COUNT(*) FROM session_traces) AS sessions,
-              (SELECT COUNT(*) FROM experiments) AS experiments,
-              (SELECT COUNT(*) FROM events) AS events,
-              (SELECT COUNT(*) FROM messages) AS messages,
-              (SELECT COALESCE(SUM(CASE WHEN event_type='cais' THEN cost_usd ELSE 0 END),0)/100.0 FROM events) AS total_cost_usd,
-              (SELECT COALESCE(SUM(CASE WHEN event_type='cais' THEN total_tokens ELSE 0 END),0) FROM events) AS total_tokens
-        """
-        )
-        if not totals.empty:
-            out["totals"] = totals.iloc[0].to_dict()
-        else:
-            out["totals"] = {}
 
-        # Systems summary
-        systems = await db.query_traces(
-            """
-            SELECT system_type, COUNT(*) as count FROM systems GROUP BY system_type
-        """
-        )
-        out["systems"] = systems
-
-        versions = await db.query_traces(
-            """
-            SELECT COUNT(*) as version_count FROM system_versions
-        """
-        )
-        if not versions.empty:
-            out["version_count"] = int(versions.iloc[0]["version_count"])
-        else:
-            out["version_count"] = 0
-        return out
-    finally:
-        await db.close()
-
-
-def register(cli):
-    @cli.command()
-    @click.option(
-        "--url",
-        "db_url",
-        default="sqlite+aiosqlite:///./synth_ai.db/dbs/default/data",
-        help="Database URL",
-    )
-    @click.option("--service-url", default="http://127.0.0.1:8901", help="Environment service URL")
-    def status(db_url: str, service_url: str):
-        """Show DB stats, agent/environment system counts, and env service health."""
-        console = Console()
-
-        async def _run():
-            # DB
-            stats = await _db_stats(db_url)
-
-            # Env service
-            health_text = "[red]unreachable[/red]"
-            envs_list = []
-            try:
-                r = requests.get(f"{service_url}/health", timeout=2)
-                if r.ok:
-                    data = r.json()
-                    health_text = "[green]ok[/green]"
-                    envs_list = data.get("supported_environments", [])
-                else:
-                    health_text = f"[red]{r.status_code}[/red]"
-            except Exception:
-                pass
-
-            # Render
-            totals = stats.get("totals", {})
-            lines = []
-            lines.append(f"DB: [dim]{db_url}[/dim]")
-            lines.append(
-                f"Experiments: {int(totals.get('experiments', 0)):,}  "
-                f"Sessions: {int(totals.get('sessions', 0)):,}  "
-                f"Events: {int(totals.get('events', 0)):,}  "
-                f"Messages: {int(totals.get('messages', 0)):,}"
-            )
-            lines.append(
-                f"Cost: ${float(totals.get('total_cost_usd', 0.0) or 0.0):.4f}  "
-                f"Tokens: {int(totals.get('total_tokens', 0)):,}"
-            )
-            lines.append("")
-            lines.append(f"Env Service: {health_text}  [dim]{service_url}[/dim]")
-            if envs_list:
-                lines.append(
-                    "Environments: "
-                    + ", ".join(sorted(envs_list)[:10])
-                    + (" ..." if len(envs_list) > 10 else "")
-                )
-
-            panel_main = Panel("\n".join(lines), title="Synth AI Status", border_style="cyan")
-            console.print(panel_main)
-
-            # Systems table
-            sys_df = stats.get("systems")
-            if sys_df is not None and not sys_df.empty:
-                tbl = Table(
-                    title=f"Systems (versions: {stats.get('version_count', 0)})",
-                    box=box.SIMPLE,
-                    header_style="bold",
-                )
-                tbl.add_column("Type")
-                tbl.add_column("Count", justify="right")
-                for _, r in sys_df.iterrows():
-                    tbl.add_row(str(r.get("system_type", "-")), f"{int(r.get('count', 0)):,}")
-                console.print(tbl)
-
-        asyncio.run(_run())
+__all__ = ["register"]

synth_ai/cli/task_app_deploy.py

@@ -0,0 +1,7 @@
+"""Compatibility wrapper for task-app deploy command."""
+
+from __future__ import annotations
+
+from synth_ai.cli.deploy import deploy_cmd as deploy_command  # type: ignore[attr-defined]
+
+__all__ = ["deploy_command"]

synth_ai/cli/task_app_list.py

@@ -0,0 +1,25 @@
+"""Task app list command."""
+
+from __future__ import annotations
+
+import click
+from synth_ai.task.apps import registry
+
+from .task_apps import task_app_group
+
+
+@task_app_group.command("list")
+def list_apps() -> None:
+    """List registered task apps."""
+
+    entries = registry.list()
+    if not entries:
+        click.echo("No task apps registered.")
+        return
+
+    for entry in entries:
+        aliases = f" (aliases: {', '.join(entry.aliases)})" if entry.aliases else ""
+        click.echo(f"- {entry.app_id}{aliases}: {entry.description}")
+
+
+__all__ = ["list_apps"]

synth_ai/cli/task_app_modal_serve.py

@@ -0,0 +1,11 @@
+"""Compatibility wrapper for task-app modal-serve command."""
+
+from __future__ import annotations
+
+from synth_ai.cli.task_apps import task_app_group
+
+modal_serve_command = task_app_group.commands.get("modal-serve")
+if modal_serve_command is None:  # pragma: no cover - defensive guard
+    raise RuntimeError("Modal-serve command is not registered on task_app_group")
+
+__all__ = ["modal_serve_command"]

synth_ai/cli/task_app_serve.py

@@ -0,0 +1,11 @@
+"""Compatibility wrapper for task-app serve command."""
+
+from __future__ import annotations
+
+from synth_ai.cli.task_apps import serve_command, task_app_group
+
+serve_task_group = task_app_group.commands.get("serve")
+if serve_task_group is None:  # pragma: no cover - defensive guard
+    raise RuntimeError("Serve command is not registered on task_app_group")
+
+__all__ = ["serve_command", "serve_task_group"]