synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__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.core.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,112 +72,113 @@ 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."
+            )
+
+        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)…")
 
-# === Legacy demo command group (aliases new rl_demo implementation) ===
-@cli.group()
-def demo():
-    """Demo helpers (deploy, configure, run)."""
+    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")
 
-def _forward_to_demo(args: list[str]) -> None:
-    # Lazy import to avoid loading demo deps unless needed
+    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()
-@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
+
+    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."""
+    # Add logging to track CLI invocation
+    import sys
+    if "train" in sys.argv:
+        sys.stderr.write(f"[CLI_ROOT] CLI invoked with args: {sys.argv}\n")
+        sys.stderr.flush()
 
 
 @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")
@@ -152,7 +192,7 @@ def run(batch_size: int | None, group_size: int | None, model: str | None, timeo
     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,
@@ -162,6 +202,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):
@@ -180,21 +224,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,
@@ -250,7 +298,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/task_apps/__init__.py

@@ -0,0 +1,37 @@
+"""Task app CLI commands (serve, deploy, list, validate).
+
+Commands for managing Synth task apps - local serving, Modal deployment,
+validation, and discovery.
+"""
+
+from __future__ import annotations
+
+import importlib
+
+from synth_ai.cli.task_apps.commands import (
+    AppChoice,
+    TaskAppEntryType,
+    _find_modal_executable,
+    _is_modal_shim,
+    _markov_message_from_dict,
+    _modal_command_prefix,
+    register,
+    serve_command,
+    task_app_group,
+)
+from synth_ai.cli.task_apps.main import task_app_cmd
+
+# Re-export for backward compatibility
+__all__ = [
+    "AppChoice",
+    "TaskAppEntryType",
+    "task_app_cmd",
+    "task_app_group",
+    "serve_command",
+    "register",
+    "_find_modal_executable",
+    "_is_modal_shim",
+    "_modal_command_prefix",
+    "_markov_message_from_dict",
+    "importlib",
+]