synth-ai 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

synth_ai/utils/cli.py

@@ -1,9 +1,29 @@
 from collections.abc import Sequence
-from typing import Any, cast
+from pathlib import Path
+from typing import Any, Callable, cast
 
 import click
 
 
+def prompt_choice(msg: str, choices: list[str]) -> str:
+    print(msg)
+    for i, label in enumerate(choices, start=1):
+        print(f" [{i}] {label}")
+    while True:
+        try:
+            choice = click.prompt(
+                "Select an option",
+                default=1,
+                type=int,
+                show_choices=False
+            )
+        except click.Abort:
+            raise
+        if 1 <= choice <= len(choices):
+            return choices[choice - 1]
+        print(f"Invalid selection. Enter a number between 1 and {len(choices)}")
+
+
 class PromptedChoiceType(click.Choice):
     """`click.Choice` variant that reprompts with an interactive menu on failure.
 
@@ -61,9 +81,15 @@ class PromptedChoiceType(click.Choice):
         for index, choice in enumerate(self.choices, 1):
             click.echo(f" [{index}] {choice}")
         while True:
-            selection = click.prompt("> ", type=int)
-            if 1 <= selection <= len(self.choices):
-                return cast(str, self.choices[selection - 1])
+            choice = click.prompt(
+                "Select an option",
+                default=1,
+                type=int,
+                show_choices=False
+            )
+            if 1 <= choice <= len(self.choices):
+                print('')
+                return cast(str, self.choices[choice - 1])
             click.echo(f"Invalid selection for {arg_name}, please try again")
 
     def _get_cmd_name(self, ctx: click.Context | None) -> str:
@@ -122,7 +148,125 @@ class PromptedChoiceOption(click.Option):
         if isinstance(option_type, PromptedChoiceType):
             return option_type._prompt_user(self, ctx)
         return super().prompt_for_value(ctx)
-    
+
+
+def prompt_for_path(
+    label: str,
+    *,
+    available_paths: Sequence[str | Path] | None = None,
+    file_type: str | None = None,
+    path_type: click.Path | None = None,
+) -> Path:
+    """Prompt for a filesystem path, optionally offering curated choices."""
+
+    def _normalize_suffix(ext: str | None) -> str | None:
+        if not ext:
+            return None
+        stripped = ext.strip()
+        if not stripped:
+            return None
+        if not stripped.startswith("."):
+            stripped = f".{stripped}"
+        return stripped.lower()
+
+    def _format_label(text: str) -> str:
+        return text.strip() or "path"
+
+    expected_suffix = _normalize_suffix(file_type)
+    prompt_label = _format_label(label)
+
+    path_type = path_type or click.Path(
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        path_type=Path,
+    )
+
+    candidates: list[str] = []
+    if available_paths:
+        seen: set[str] = set()
+        for entry in available_paths:
+            candidate = str(Path(entry))
+            suffix = Path(candidate).suffix.lower()
+            if candidate in seen:
+                continue
+            if expected_suffix and suffix != expected_suffix:
+                continue
+            seen.add(candidate)
+            candidates.append(candidate)
+
+    ctx = click.get_current_context(silent=True)
+
+    while True:
+        if candidates:
+            click.echo(f"\nPlease choose a {prompt_label}:")
+            for index, option in enumerate(candidates, 1):
+                click.echo(f" [{index}] {option}")
+            custom_index = len(candidates) + 1
+            click.echo(f" [{custom_index}] Enter a custom path")
+
+            selection = click.prompt("> ", type=int)
+            if 1 <= selection <= len(candidates):
+                raw_value = candidates[selection - 1]
+            elif selection == custom_index:
+                raw_value = click.prompt(prompt_label, type=path_type)
+            else:
+                click.echo("Invalid selection, please try again")
+                continue
+        else:
+            raw_value = click.prompt(prompt_label, type=path_type)
+
+        try:
+            converted = path_type.convert(str(raw_value), None, ctx)
+        except click.BadParameter as exc:
+            click.echo(str(exc))
+            continue
+
+        result = converted if isinstance(converted, Path) else Path(converted)
+        if expected_suffix and result.suffix.lower() != expected_suffix:
+            click.echo(f"Expected a {expected_suffix} file. Received: {result}")
+            continue
+        
+        return result
+
+
+class PromptedPathOption(click.Option):
+    """Option that prompts for a filesystem path when omitted."""
+
+    def __init__(
+        self,
+        *args: Any,
+        available_paths: Sequence[str | Path] | None = None,
+        file_type: str | None = None,
+        path_type: click.Path | None = None,
+        prompt_guard: Callable[[click.Context], bool] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self._available_paths = available_paths
+        self._file_type = file_type
+        self._path_type = path_type
+        self._prompt_guard = prompt_guard
+        kwargs.setdefault("prompt", True)
+        kwargs.setdefault("prompt_required", True)
+        super().__init__(*args, **kwargs)
+
+    def prompt_for_value(self, ctx: click.Context) -> Any:
+        if not ctx:
+            return super().prompt_for_value(ctx)
+        if self._prompt_guard is not None:
+            try:
+                if not self._prompt_guard(ctx):
+                    return None
+            except Exception:
+                return None
+        label = self.help or self.name or "path"
+        return prompt_for_path(
+            label,
+            available_paths=self._available_paths,
+            file_type=self._file_type,
+            path_type=self._path_type or getattr(self, "type", None),
+        )
+
 
 def print_next_step(message: str, lines: Sequence[str]) -> None:
     print(f"\n➡️  Next, {message}:")

synth_ai/utils/env.py

@@ -5,6 +5,8 @@ from pathlib import Path
 
 import click
 
+from .paths import get_env_file_paths, get_home_config_file_paths
+
 _ENV_SAFE_CHARS = set(string.ascii_letters + string.digits + "_-./:@+=")
 
 
@@ -84,18 +86,6 @@ def mask_str(input: str, position: int = 3) -> str:
     return input[:position] + "..." + input[-position:] if len(input) > position * 2 else "***"
 
 
-def get_env_file_paths(base_dir: str | Path = '.') -> list[Path]:
-    base = Path(base_dir).resolve()
-    return [path for path in base.rglob(".env*") if path.is_file()]
-
-
-def get_synth_config_file_paths() -> list[Path]:
-    dir = Path.home() / ".synth-ai"
-    if not dir.exists():
-        return []
-    return [path for path in dir.glob("*.json") if path.is_file()]
-
-
 def filter_env_files_by_key(key: str, paths: list[Path]) -> list[tuple[Path, str]]:
     matches: list[tuple[Path, str]] = []
     for path in paths:
@@ -133,18 +123,25 @@ def ensure_env_var(key: str, expected_value: str) -> None:
         raise ValueError(f"Expected: {key}={expected_value}\nActual: {key}={actual_value}")
 
 
-def resolve_env_var(key: str) -> str:
+def resolve_env_var(
+    key: str,
+    override_process_env: bool = False
+) -> str:
     env_value = os.getenv(key)
-    if env_value is not None:
+    if env_value is not None and not override_process_env:
         click.echo(f"Using {key}={mask_str(env_value)} from process environment")
         return env_value
 
     value: str = ""
 
     env_file_paths = filter_env_files_by_key(key, get_env_file_paths())
-    synth_file_paths = filter_json_files_by_key(key, get_synth_config_file_paths())
+    synth_file_paths = filter_json_files_by_key(key, get_home_config_file_paths(".synth-ai"))
 
     options: list[tuple[str, str]] = []
+    if env_value is not None:
+        if not override_process_env:
+            return env_value
+        options.append((f"(process environment)  {mask_str(env_value)}", env_value))
     for path, value in env_file_paths:
         resolved_path = path.resolve()
         try:
@@ -167,7 +164,7 @@ def resolve_env_var(key: str) -> str:
         while True:
             try:
                 choice = click.prompt(
-                    "Select option",
+                    "Select an option",
                     default=1,
                     type=str,
                     show_choices=False,
@@ -204,6 +201,8 @@ def write_env_var_to_dotenv(
     key: str,
     value: str,
     output_file_path: str | Path | None = None,
+    print_msg: bool = True,
+    mask_msg: bool = True
 ) -> None:
     path = Path(".env") if output_file_path is None else Path(output_file_path)
     path = path.expanduser()
@@ -247,7 +246,8 @@ def write_env_var_to_dotenv(
     except OSError as exc:
         raise RuntimeError(f"Failed to write {path}: {exc}") from exc
 
-    print(f"Wrote {key}={mask_str(value)} to {path.resolve()}")
+    if print_msg:
+        print(f"Wrote {key}={mask_str(value) if mask_msg else value} to {path.resolve()}")
 
 
 def write_env_var_to_json(

synth_ai/utils/json.py

@@ -0,0 +1,72 @@
+import json
+from pathlib import Path
+
+
+def strip_json_comments(raw: str) -> str:
+    """Remove // and /* */ comments from JSONC text."""
+    result: list[str] = []
+    in_string = False
+    in_line_comment = False
+    in_block_comment = False
+    escape = False
+    i = 0
+    length = len(raw)
+    while i < length:
+        char = raw[i]
+        next_char = raw[i + 1] if i + 1 < length else ""
+
+        if in_line_comment:
+            if char == "\n":
+                in_line_comment = False
+                result.append(char)
+            i += 1
+            continue
+
+        if in_block_comment:
+            if char == "*" and next_char == "/":
+                in_block_comment = False
+                i += 2
+            else:
+                i += 1
+            continue
+
+        if in_string:
+            result.append(char)
+            if char == "\"" and not escape:
+                in_string = False
+            escape = (char == "\\") and not escape
+            i += 1
+            continue
+
+        if char == "/" and next_char == "/":
+            in_line_comment = True
+            i += 2
+            continue
+
+        if char == "/" and next_char == "*":
+            in_block_comment = True
+            i += 2
+            continue
+
+        if char == "\"":
+            in_string = True
+            escape = False
+
+        result.append(char)
+        i += 1
+
+    return "".join(result)
+
+
+def create_and_write_json(path: Path, content: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(content, indent=2) + "\n")
+
+
+def load_json_to_dict(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(strip_json_comments(path.read_text()))
+    except (json.JSONDecodeError, OSError):
+        return {}

synth_ai/utils/modal.py

@@ -1,16 +1,25 @@
+import ast
 import contextlib
 import json
 import os
+import re
+import shlex
 import shutil
+import subprocess
 import sys
+import tempfile
+import textwrap
 from pathlib import Path
 from typing import Any
 from urllib.parse import urlparse, urlunparse
 
+import click
+from modal.config import config
 from synth_ai.demos import core as demo_core
 from synth_ai.demos.core import DEFAULT_TASK_APP_SECRET_NAME, DemoEnv
+from synth_ai.task_app_cfgs import ModalTaskAppConfig
 
-from .env import mask_str
+from .env import mask_str, resolve_env_var, write_env_var_to_dotenv
 from .http import http_request
 from .process import popen_capture
 from .user_config import load_user_config
@@ -25,6 +34,279 @@ __all__ = [
 ]
 
 
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+START_DIV = f"{'-' * 31} Modal start {'-' * 31}"
+END_DIV = f"{'-' * 32} Modal end {'-' * 32}"
+MODAL_URL_REGEX = re.compile(r"https?://[^\s]+modal\.run[^\s]*")
+
+
+def get_default_modal_bin_path() -> Path | None:
+    resolved = shutil.which("modal")
+    return Path(resolved) if resolved else None
+
+
+def ensure_py_file_defines_modal_app(file_path: Path) -> None:
+    if file_path.suffix != ".py":
+        raise TypeError()
+    try:
+        tree = ast.parse(file_path.read_text(encoding="utf-8"), filename=str(file_path))
+    except OSError as exc:
+        raise OSError() from exc
+
+    app_aliases: set[str] = set()
+    modal_aliases: set[str] = set()
+
+    def literal_name(call: ast.Call) -> str | None:
+        for kw in call.keywords:
+            if (
+                kw.arg in {"name", "app_name"}
+                and isinstance(kw.value, ast.Constant)
+                and isinstance(kw.value.value, str)
+            ):
+                return kw.value.value
+        if call.args:
+            first = call.args[0]
+            if isinstance(first, ast.Constant) and isinstance(first.value, str):
+                return first.value
+        return None
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom) and node.module == "modal":
+            for alias in node.names:
+                if alias.name == "App":
+                    app_aliases.add(alias.asname or alias.name)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == "modal":
+                    modal_aliases.add(alias.asname or alias.name)
+        elif isinstance(node, ast.Call):
+            func = node.func
+            if isinstance(func, ast.Name) and func.id in app_aliases:
+                if literal_name(node):
+                    return None
+            elif (
+                isinstance(func, ast.Attribute)
+                and func.attr == "App"
+                and isinstance(func.value, ast.Name)
+                and func.value.id in modal_aliases
+                and literal_name(node)
+            ):
+                return None
+    raise ValueError()
+
+
+def run_modal_setup(modal_bin_path: Path) -> None:
+    
+    print("\n🌐 Connecting to your Modal account via https://modal.com")
+    print(START_DIV)
+    cmd = [str(modal_bin_path), "setup"]
+    try:
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as exc:
+        print(END_DIV)
+        raise RuntimeError(
+            f"`{' '.join(cmd)}` exited with status {exc.returncode}"
+            f"Run `{' '.join(cmd)} manually to inspect output"
+        ) from exc
+    print(END_DIV)
+    print("✅ Connected to your Modal account")
+
+
+def ensure_modal_config() -> None:
+    token_id = os.environ.get("MODAL_TOKEN_ID") \
+        or config.get("token_id") \
+        or ''
+    token_secret = os.environ.get("MODAL_TOKEN_SECRET") \
+        or config.get("token_secret") \
+        or ''
+    if token_id and token_secret:
+        print(f"Found Modal token_id={mask_str(token_id)}")
+        print(f"Found Modal token_secret={mask_str(token_secret)}")
+        return
+    
+    modal_bin_path = get_default_modal_bin_path()
+    if not modal_bin_path:
+        raise RuntimeError("Modal CLI not found on PATH")
+    run_modal_setup(modal_bin_path)
+
+
+def deploy_modal_app(cfg: ModalTaskAppConfig) -> None:
+    ensure_py_file_defines_modal_app(cfg.modal_app_path)
+    ensure_modal_config()
+    
+    py_paths: list[str] = []
+
+    source_dir = cfg.modal_app_path.parent.resolve()
+    py_paths.append(str(source_dir))
+    if (source_dir / "__init__.py").exists():  # if the modal app lives in a package, ensure the parent package is importable
+        py_paths.append(str(source_dir.parent.resolve()))
+
+    py_paths.append(str(REPO_ROOT))
+    
+    env_api_key = resolve_env_var("ENVIRONMENT_API_KEY")
+    if not os.environ["ENVIRONMENT_API_KEY"]:
+        raise RuntimeError()
+    
+    env_copy = os.environ.copy()
+    existing_python_path = env_copy.get("PYTHONPATH")
+    if existing_python_path:
+        py_paths.append(existing_python_path)
+    unique_python_paths = list(dict.fromkeys(py_paths))
+    env_copy["PYTHONPATH"] = os.pathsep.join(unique_python_paths)
+    if "PYTHONPATH" in env_copy: # ensure wrapper has access to synth source for intra-repo imports
+        env_copy["PYTHONPATH"] = os.pathsep.join(
+            [str(REPO_ROOT)] + env_copy["PYTHONPATH"].split(os.pathsep)
+        )
+    else:
+        env_copy["PYTHONPATH"] = str(REPO_ROOT)
+
+    modal_app_dir = cfg.modal_app_path.parent.resolve()
+    tmp_root = Path(tempfile.mkdtemp(prefix="synth_modal_app"))
+    wrapper_src = textwrap.dedent(f"""
+        from importlib import util as _util
+        from pathlib import Path as _Path
+        import sys as _sys
+
+        _source_dir = _Path({str(modal_app_dir)!r}).resolve()
+        _module_path = _source_dir / {cfg.modal_app_path.name!r}
+        _package_name = _source_dir.name
+        _repo_root = _Path({str(REPO_ROOT)!r}).resolve()
+        _synth_dir = _repo_root / "synth_ai"
+
+        for _path in (str(_source_dir), str(_source_dir.parent), str(_repo_root)):
+            if _path not in _sys.path:
+                _sys.path.insert(0, _path)
+
+        _spec = _util.spec_from_file_location("_synth_modal_target", str(_module_path))
+        if _spec is None or _spec.loader is None:
+            raise SystemExit("Unable to load modal task app from {cfg.modal_app_path}")
+        _module = _util.module_from_spec(_spec)
+        _sys.modules.setdefault("_synth_modal_target", _module)
+        _spec.loader.exec_module(_module)
+
+        try:
+            from modal import App as _ModalApp
+            from modal import Image as _ModalImage
+        except Exception:
+            _ModalApp = None  # type: ignore[assignment]
+            _ModalImage = None  # type: ignore[assignment]
+
+        def _apply_local_mounts(image):
+            if _ModalImage is None or not isinstance(image, _ModalImage):
+                return image
+            mounts = [
+                (str(_source_dir), f"/root/{{_package_name}}"),
+                (str(_synth_dir), "/root/synth_ai"),
+            ]
+            for local_path, remote_path in mounts:
+                try:
+                    image = image.add_local_dir(local_path, remote_path=remote_path)
+                except Exception:
+                    pass
+            return image
+
+        if hasattr(_module, "image"):
+            _module.image = _apply_local_mounts(getattr(_module, "image"))
+
+        _candidate = getattr(_module, "app", None)
+        if _ModalApp is None or not isinstance(_candidate, _ModalApp):
+            candidate_modal_app = getattr(_module, "modal_app", None)
+            if _ModalApp is not None and isinstance(candidate_modal_app, _ModalApp):
+                _candidate = candidate_modal_app
+                setattr(_module, "app", _candidate)
+
+        if _ModalApp is not None and not isinstance(_candidate, _ModalApp):
+            raise SystemExit(
+                "Modal task app must expose an 'app = modal.App(...)' (or modal_app) attribute."
+            )
+
+        try:
+            from modal import Secret as _Secret
+        except Exception:
+            _Secret = None
+
+        for remote_path in ("/root/synth_ai", f"/root/{{_package_name}}"):
+            if remote_path not in _sys.path:
+                _sys.path.insert(0, remote_path)
+
+        globals().update({{k: v for k, v in vars(_module).items() if not k.startswith("__")}})
+        app = getattr(_module, "app")
+        _ENVIRONMENT_API_KEY = {env_api_key!r}
+        if _Secret is not None and _ENVIRONMENT_API_KEY:
+            try:
+                _inline_secret = _Secret.from_dict({{"ENVIRONMENT_API_KEY": _ENVIRONMENT_API_KEY}})
+            except Exception:
+                _inline_secret = None
+            if _inline_secret is not None:
+                try:
+                    _decorators = list(getattr(app, "_function_decorators", []))
+                except Exception:
+                    _decorators = []
+                for _decorator in _decorators:
+                    _existing = getattr(_decorator, "secrets", None)
+                    if not _existing:
+                        continue
+                    try:
+                        if _inline_secret not in _existing:
+                            _decorator.secrets = list(_existing) + [_inline_secret]
+                    except Exception:
+                        pass
+    """).strip()
+    wrapper_path = tmp_root / "__modal_wrapper__.py"
+    wrapper_path.write_text(wrapper_src + '\n', encoding="utf-8")
+    wrapper_info = (wrapper_path, tmp_root)
+
+    cmd = [str(cfg.modal_bin_path), cfg.cmd_arg, str(wrapper_path)]
+    if cfg.task_app_name and cfg.cmd_arg == "deploy":
+        cmd.extend(["--name", cfg.task_app_name])
+    
+    msg = " ".join(shlex.quote(c) for c in cmd)
+    if cfg.dry_run:
+        print("Dry run:\n", msg)
+        return
+    print(f"Running:\n{msg}")
+
+    try:
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            env=env_copy
+        )
+        task_app_url = None
+        assert process.stdout is not None
+        print(START_DIV)
+        for line in process.stdout:
+            click.echo(line, nl=False)
+            if task_app_url is None:
+                match = MODAL_URL_REGEX.search(line)
+                if match:
+                    task_app_url = match.group(0).rstrip(".,")
+                    if task_app_url:
+                        write_env_var_to_dotenv(
+                            "TASK_APP_URL",
+                            task_app_url,
+                            print_msg=True,
+                            mask_msg=False,
+                        )
+        print(END_DIV)
+        rc = process.wait()
+        if rc != 0:
+            raise subprocess.CalledProcessError(rc, cmd)
+    except subprocess.CalledProcessError as exc:
+        raise click.ClickException(
+            f"modal {cfg.cmd_arg} failed with exit code: {exc.returncode}"
+        ) from exc
+    finally:
+        if wrapper_info is not None:
+            wrapper_path, tmp_root = wrapper_info
+            wrapper_path.unlink(missing_ok=True)
+        shutil.rmtree(tmp_root, ignore_errors=True)
+
+
 def is_modal_public_url(url: str | None) -> bool:
     try:
         candidate = (url or "").strip().lower()

synth_ai/utils/paths.py

@@ -0,0 +1,48 @@
+import shutil
+from pathlib import Path
+
+
+def find_bin_path(name: str) -> Path | None:
+    path = shutil.which(name)
+    if not path:
+        return None
+    return Path(path)
+
+
+def get_env_file_paths(base_dir: str | Path = '.') -> list[Path]:
+    base = Path(base_dir).resolve()
+    return [path for path in base.rglob(".env*") if path.is_file()]
+
+
+def get_home_config_file_paths(
+    dir_name: str,
+    file_extension: str = "json"
+) -> list[Path]:
+    dir = Path.home() / dir_name
+    if not dir.exists():
+        return []
+    return [path for path in dir.glob(f"*.{file_extension}") if path.is_file()]
+
+
+def find_config_path(
+    bin_path: Path,
+    home_subdir: str,
+    filename: str,
+) -> Path | None:
+    """
+    Return a config file located in the user's home directory or alongside the binary.
+
+    Args:
+        bin_path: Resolved path to the executable.
+        home_subdir: Directory under the user's home to inspect (e.g., ".codex").
+        filename: Name of the config file to locate.
+    """
+    home_candidate = Path.home() / home_subdir / filename
+    if home_candidate.exists():
+        return home_candidate
+
+    local_candidate = Path(bin_path).parent / home_subdir / filename
+    if local_candidate.exists():
+        return local_candidate
+
+    return None