caraer-cli 0.1.2__py3-none-any.whl

caraer_cli/project/manifest_edit.py

@@ -0,0 +1,51 @@
+"""Append marketplace items into app.caraer.yaml."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable
+
+from caraer_cli.local_app import load_local_app
+from caraer_cli.project.paths import app_manifest_path
+from caraer_cli.project.scaffold import write_app_manifest
+from caraer_cli.project.schema import ProjectConfig
+
+
+def append_manifest_list_item(
+    root: Path,
+    config: ProjectConfig,
+    *,
+    list_key: str,
+    item: dict[str, Any],
+    identity: Callable[[dict[str, Any]], str],
+    force: bool = False,
+) -> Path:
+    """Append (or replace) an item in a top-level list on ``app.caraer.yaml``."""
+    manifest_path = app_manifest_path(root, config.srcDir)
+    if not manifest_path.is_file():
+        raise FileNotFoundError(f"App manifest not found: {manifest_path}")
+    payload = load_local_app(manifest_path)
+    items = payload.get(list_key)
+    if not isinstance(items, list):
+        items = []
+    key = identity(item)
+    if not key:
+        raise ValueError(f"Cannot determine identity for {list_key} item.")
+    existing_idx = None
+    for idx, current in enumerate(items):
+        if isinstance(current, dict) and identity(current) == key:
+            existing_idx = idx
+            break
+    if existing_idx is not None and not force:
+        raise FileExistsError(
+            f"{list_key} already has an item matching '{key}'. Use --force to replace."
+        )
+    next_items = list(items)
+    if existing_idx is not None:
+        next_items[existing_idx] = item
+    else:
+        next_items.append(item)
+    payload[list_key] = next_items
+    return write_app_manifest(
+        root, payload, src_dir=config.srcDir, include_examples=False
+    )

caraer_cli/project/marketplace_assemble.py

@@ -0,0 +1,165 @@
+"""Assemble modular marketplace/lifecycle files into the app manifest payload."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from caraer_cli.project.app_bars_sync import (
+    app_bar_identity,
+    discover_local_app_bars,
+    resolve_app_bar_functions,
+    write_app_bars_files,
+)
+from caraer_cli.project.lifecycle_sync import (
+    LIFECYCLE_HOOKS,
+    discover_local_lifecycle,
+    resolve_lifecycle_functions,
+    write_lifecycle_files,
+)
+from caraer_cli.project.pricing_sync import (
+    discover_local_pricing,
+    pricing_identity,
+    write_pricing_files,
+)
+from caraer_cli.project.schema import ProjectConfig
+from caraer_cli.project.settings_sync import discover_local_settings, write_settings_files
+from caraer_cli.project.state import load_state
+
+
+def _fn_by_name(root: Path) -> dict[str, str]:
+    state = load_state(root)
+    fn_state = state.get("functions") or {}
+    return {
+        name: str(meta["uuid"])
+        for name, meta in fn_state.items()
+        if isinstance(meta, dict) and meta.get("uuid")
+    }
+
+
+def _merge_by_key(
+    yaml_items: list[Any],
+    file_items: list[dict[str, Any]],
+    *,
+    identity,
+) -> list[dict[str, Any]]:
+    """Merge YAML list with file list; files win on identity conflict."""
+    merged: dict[str, dict[str, Any]] = {}
+    order: list[str] = []
+    for item in yaml_items:
+        if not isinstance(item, dict):
+            continue
+        key = identity(item)
+        if not key:
+            continue
+        if key not in merged:
+            order.append(key)
+        merged[key] = item
+    for item in file_items:
+        key = identity(item)
+        if not key:
+            continue
+        if key not in merged:
+            order.append(key)
+        merged[key] = item
+    return [merged[k] for k in order]
+
+
+def assemble_local_manifest(
+    root: Path,
+    config: ProjectConfig,
+    local: dict[str, Any],
+    *,
+    resolve_functions: bool = True,
+    strict_function_refs: bool = True,
+) -> dict[str, Any]:
+    """Return a copy of ``local`` with modular disk files merged in.
+
+    When ``resolve_functions`` is True, serverlessFunction name refs are replaced
+    with UUIDs from ``.caraer/state.json`` (required before push).
+    When ``strict_function_refs`` is False, hooks/bars that cannot resolve are omitted.
+    """
+    out = dict(local)
+    fn_by_name = _fn_by_name(root) if resolve_functions else {}
+
+    yaml_settings = out.get("settingsSchema") if isinstance(out.get("settingsSchema"), list) else []
+    file_settings = [item for _path, item in discover_local_settings(root, config)]
+    out["settingsSchema"] = _merge_by_key(
+        yaml_settings,
+        file_settings,
+        identity=lambda i: str(i.get("name") or "").strip().lower(),
+    )
+
+    yaml_pricing = out.get("pricingPlans") if isinstance(out.get("pricingPlans"), list) else []
+    file_pricing = [item for _path, item in discover_local_pricing(root, config)]
+    out["pricingPlans"] = _merge_by_key(
+        yaml_pricing,
+        file_pricing,
+        identity=pricing_identity,
+    )
+
+    yaml_bars = out.get("appBars") if isinstance(out.get("appBars"), list) else []
+    file_bars = [item for _path, item in discover_local_app_bars(root, config)]
+    merged_bars = _merge_by_key(yaml_bars, file_bars, identity=app_bar_identity)
+    if resolve_functions:
+        resolved_bars: list[dict[str, Any]] = []
+        for bar in merged_bars:
+            resolved = resolve_app_bar_functions(
+                bar, fn_by_name=fn_by_name, strict=strict_function_refs
+            )
+            if resolved is not None:
+                resolved_bars.append(resolved)
+        out["appBars"] = resolved_bars
+    else:
+        out["appBars"] = merged_bars
+
+    file_hooks = discover_local_lifecycle(root, config)
+    for _stem, (manifest_key, expected_topic) in LIFECYCLE_HOOKS.items():
+        hook = file_hooks.get(manifest_key)
+        if hook is None:
+            continue
+        payload = dict(hook)
+        if not payload.get("topic"):
+            payload["topic"] = expected_topic
+        if resolve_functions:
+            resolved = resolve_lifecycle_functions(
+                payload, fn_by_name=fn_by_name, strict=strict_function_refs
+            )
+            if resolved is None:
+                out.pop(manifest_key, None)
+                continue
+            payload = resolved
+        out[manifest_key] = payload
+
+    return out
+
+
+def split_marketplace_to_disk(
+    root: Path,
+    config: ProjectConfig,
+    payload: dict[str, Any],
+) -> dict[str, Any]:
+    """Write modular files from a remote/local payload and clear arrays/hooks in YAML copy."""
+    out = dict(payload)
+
+    settings = out.get("settingsSchema") if isinstance(out.get("settingsSchema"), list) else []
+    write_settings_files(root, config, [i for i in settings if isinstance(i, dict)])
+    out["settingsSchema"] = []
+
+    pricing = out.get("pricingPlans") if isinstance(out.get("pricingPlans"), list) else []
+    write_pricing_files(root, config, [i for i in pricing if isinstance(i, dict)])
+    out["pricingPlans"] = []
+
+    bars = out.get("appBars") if isinstance(out.get("appBars"), list) else []
+    write_app_bars_files(root, config, [i for i in bars if isinstance(i, dict)])
+    out["appBars"] = []
+
+    hooks = {
+        key: out.get(key) if isinstance(out.get(key), dict) else None
+        for _stem, (key, _topic) in LIFECYCLE_HOOKS.items()
+    }
+    write_lifecycle_files(root, config, hooks)
+    for key in hooks:
+        out.pop(key, None)
+
+    return out

caraer_cli/project/oauth_providers_sync.py

@@ -0,0 +1,180 @@
+"""Sync external OAuth providers from app.caraer.yaml to the remote API."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from caraer_cli.api import integration_runtime as api
+from caraer_cli.api.client import CaraerApiClient
+from caraer_cli.local_app import load_local_app
+from caraer_cli.project.paths import app_manifest_path
+from caraer_cli.project.schema import ProjectConfig
+from caraer_cli.project.state import load_state, save_state
+
+
+def _env_expand(value: Any) -> Any:
+    if not isinstance(value, str):
+        return value
+    text = value.strip()
+    if text.startswith("${") and text.endswith("}") and len(text) > 3:
+        return os.environ.get(text[2:-1], "")
+    return value
+
+
+def _sanitize_provider(raw: dict[str, Any]) -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    for key in (
+        "uuid",
+        "name",
+        "logo",
+        "authorizeUrl",
+        "tokenUrl",
+        "clientId",
+        "clientSecret",
+        "scopes",
+        "pkce",
+    ):
+        if key in raw and raw[key] is not None:
+            out[key] = _env_expand(raw[key])
+    # Ignore deprecated preset if present in older manifests.
+    if isinstance(out.get("scopes"), list):
+        out["scopes"] = [_env_expand(s) for s in out["scopes"]]
+    return out
+
+
+def discover_local_providers(root, config: ProjectConfig) -> list[dict[str, Any]]:
+    manifest = load_local_app(app_manifest_path(root, config.srcDir))
+    providers = manifest.get("externalOAuthProviders") or []
+    if not isinstance(providers, list):
+        return []
+    return [_sanitize_provider(p) for p in providers if isinstance(p, dict) and p.get("name")]
+
+
+def pull_external_oauth_providers(
+    client: CaraerApiClient,
+    root,
+    config: ProjectConfig,
+) -> int:
+    """Refresh externalOAuthProviders on the local app manifest from the remote API.
+
+    Secrets are never returned by the API; local clientSecret values are preserved
+    when the provider name/uuid still matches.
+    """
+    if not config.appUuid:
+        raise ValueError("App is not linked.")
+    remote = api.list_external_oauth_providers(client, config.appUuid).get("data") or []
+    if not isinstance(remote, list):
+        remote = []
+
+    manifest_path = app_manifest_path(root, config.srcDir)
+    try:
+        manifest = load_local_app(manifest_path)
+    except (FileNotFoundError, ValueError, OSError):
+        manifest = {}
+    existing = manifest.get("externalOAuthProviders") or []
+    existing_by_uuid: dict[str, dict[str, Any]] = {}
+    existing_by_name: dict[str, dict[str, Any]] = {}
+    if isinstance(existing, list):
+        for item in existing:
+            if not isinstance(item, dict):
+                continue
+            if item.get("uuid"):
+                existing_by_uuid[str(item["uuid"])] = item
+            if item.get("name"):
+                existing_by_name[str(item["name"])] = item
+
+    providers: list[dict[str, Any]] = []
+    providers_map: dict[str, str] = {}
+    for item in remote:
+        if not isinstance(item, dict) or not item.get("name"):
+            continue
+        sanitized = _sanitize_provider(item)
+        # API never returns clientSecret; keep local value when present.
+        prior = existing_by_uuid.get(str(item.get("uuid") or "")) or existing_by_name.get(
+            str(item.get("name") or "")
+        )
+        if prior and prior.get("clientSecret") and not sanitized.get("clientSecret"):
+            sanitized["clientSecret"] = prior["clientSecret"]
+        # Drop empty secret keys so YAML stays clean.
+        if not sanitized.get("clientSecret"):
+            sanitized.pop("clientSecret", None)
+        providers.append(sanitized)
+        if sanitized.get("uuid") and sanitized.get("name"):
+            providers_map[str(sanitized["name"])] = str(sanitized["uuid"])
+
+    from caraer_cli.project.app_manifest_template import render_app_manifest
+
+    manifest["externalOAuthProviders"] = providers
+    manifest_path.write_text(
+        render_app_manifest(manifest, include_examples=False),
+        encoding="utf-8",
+    )
+    state = load_state(root)
+    state["externalOAuthProviders"] = providers_map
+    save_state(root, state)
+    return len(providers)
+
+
+def push_external_oauth_providers(
+    client: CaraerApiClient,
+    root,
+    config: ProjectConfig,
+    *,
+    delete_missing: bool = False,
+) -> dict[str, Any]:
+    if not config.appUuid:
+        raise ValueError("App is not linked.")
+    local = discover_local_providers(root, config)
+    if not local:
+        return {"pushed": 0, "skipped": True}
+
+    remote = api.list_external_oauth_providers(client, config.appUuid).get("data") or []
+    remote_by_name = {
+        str(i["name"]): i for i in remote if isinstance(i, dict) and i.get("name")
+    }
+    remote_by_uuid = {
+        str(i["uuid"]): i for i in remote if isinstance(i, dict) and i.get("uuid")
+    }
+
+    pushed: dict[str, str] = {}
+    kept_uuids: set[str] = set()
+    for provider in local:
+        name = str(provider.get("name") or "")
+        client_id = str(provider.get("clientId") or "").strip()
+        if not client_id:
+            # Placeholder providers are kept locally until Google credentials are set.
+            continue
+        uuid = str(provider.get("uuid") or "")
+        existing = remote_by_uuid.get(uuid) or remote_by_name.get(name)
+        payload = {k: v for k, v in provider.items() if k != "uuid"}
+        # Don't blank an existing secret when local secret omitted.
+        if existing and not payload.get("clientSecret"):
+            payload.pop("clientSecret", None)
+        if existing and existing.get("uuid"):
+            resp = api.update_external_oauth_provider(
+                client, config.appUuid, str(existing["uuid"]), payload
+            )
+            data = resp.get("data") or existing
+        else:
+            if not payload.get("clientSecret"):
+                raise ValueError(
+                    f"externalOAuthProviders.{name} requires clientSecret on first push "
+                    "(set it in app.caraer.yaml or ${GMAIL_OAUTH_CLIENT_SECRET})."
+                )
+            resp = api.create_external_oauth_provider(client, config.appUuid, payload)
+            data = resp.get("data") or {}
+        if isinstance(data, dict) and data.get("uuid"):
+            kept_uuids.add(str(data["uuid"]))
+            if data.get("name"):
+                pushed[str(data["name"])] = str(data["uuid"])
+
+    if delete_missing:
+        for uuid in remote_by_uuid:
+            if uuid not in kept_uuids:
+                api.delete_external_oauth_provider(client, config.appUuid, uuid)
+
+    state = load_state(root)
+    state["externalOAuthProviders"] = pushed
+    save_state(root, state)
+    return {"pushed": len(pushed), "deletedMissing": delete_missing}

caraer_cli/project/paths.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+WORKSPACE_FILE = "caraer.json"
+LEGACY_PROJECT_FILE = "caraer.project.json"
+# Back-compat alias used by older call sites.
+PROJECT_FILE = WORKSPACE_FILE
+STATE_DIR = ".caraer"
+STATE_FILE = "state.json"
+
+
+def find_project_root(start: Path | None = None) -> Path:
+    """Locate the app workspace root (caraer.json or legacy caraer.project.json)."""
+    current = (start or Path.cwd()).resolve()
+    for candidate in [current, *current.parents]:
+        if (candidate / WORKSPACE_FILE).is_file() or (
+            candidate / LEGACY_PROJECT_FILE
+        ).is_file():
+            return candidate
+    raise FileNotFoundError(
+        f"No {WORKSPACE_FILE} found. Run 'caraer apps init' in your app directory."
+    )
+
+
+def workspace_file(root: Path) -> Path:
+    """Preferred workspace config path (always caraer.json)."""
+    return root / WORKSPACE_FILE
+
+
+def project_file(root: Path) -> Path:
+    """Return existing workspace file path (prefer caraer.json, else legacy)."""
+    modern = root / WORKSPACE_FILE
+    if modern.is_file():
+        return modern
+    legacy = root / LEGACY_PROJECT_FILE
+    if legacy.is_file():
+        return legacy
+    return modern
+
+
+def has_workspace_file(root: Path) -> bool:
+    return (root / WORKSPACE_FILE).is_file() or (
+        root / LEGACY_PROJECT_FILE
+    ).is_file()
+
+
+def state_path(root: Path) -> Path:
+    return root / STATE_DIR / STATE_FILE
+
+
+def app_dir(root: Path, src_dir: str = "src") -> Path:
+    return root / src_dir / "app"
+
+
+def functions_dir(root: Path, src_dir: str = "src") -> Path:
+    return app_dir(root, src_dir) / "functions"
+
+
+def webhooks_dir(root: Path, src_dir: str = "src") -> Path:
+    return app_dir(root, src_dir) / "webhooks"
+
+
+def schedules_dir(root: Path, src_dir: str = "src") -> Path:
+    return app_dir(root, src_dir) / "schedules"
+
+
+def inbound_dir(root: Path, src_dir: str = "src") -> Path:
+    return app_dir(root, src_dir) / "inbound"
+
+
+def settings_dir(root: Path, src_dir: str = "src") -> Path:
+    return app_dir(root, src_dir) / "settings"
+
+
+def pricing_dir(root: Path, src_dir: str = "src") -> Path:
+    return app_dir(root, src_dir) / "pricing"
+
+
+def app_bars_dir(root: Path, src_dir: str = "src") -> Path:
+    return app_dir(root, src_dir) / "app-bars"
+
+
+def lifecycle_dir(root: Path, src_dir: str = "src") -> Path:
+    return app_dir(root, src_dir) / "lifecycle"
+
+
+APP_MANIFEST_YAML = "app.caraer.yaml"
+APP_MANIFEST_JSON = "app.caraer.json"
+
+
+def app_manifest_path(root: Path, src_dir: str = "src") -> Path:
+    """Preferred local app definition path (YAML). Falls back to legacy JSON if present."""
+    base = app_dir(root, src_dir)
+    yaml_path = base / APP_MANIFEST_YAML
+    json_path = base / APP_MANIFEST_JSON
+    if yaml_path.is_file():
+        return yaml_path
+    if json_path.is_file():
+        return json_path
+    return yaml_path

caraer_cli/project/pricing_sync.py

@@ -0,0 +1,81 @@
+"""Discover / write modular pricingPlans files under src/app/pricing/."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from caraer_cli.project.paths import pricing_dir
+from caraer_cli.project.schema import ProjectConfig
+
+LOCAL_PRICING_KEYS = (
+    "uuid",
+    "name",
+    "title",
+    "description",
+    "pricingType",
+    "pricePerUnit",
+    "unit",
+    "freeUnits",
+    "freeUnitsPeriod",
+    "tiers",
+)
+
+
+def _slug(value: str) -> str:
+    text = value.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "-", text)
+    return text.strip("-") or "plan"
+
+
+def pricing_filename(item: dict[str, Any]) -> str:
+    key = str(item.get("name") or item.get("title") or "plan")
+    return f"{_slug(key)}.json"
+
+
+def sanitize_pricing(item: dict[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    for key in LOCAL_PRICING_KEYS:
+        if key in item and item[key] is not None:
+            payload[key] = item[key]
+    return payload
+
+
+def pricing_identity(item: dict[str, Any]) -> str:
+    return str(item.get("name") or item.get("title") or "").strip().lower()
+
+
+def discover_local_pricing(
+    root: Path, config: ProjectConfig
+) -> list[tuple[Path, dict[str, Any]]]:
+    base = pricing_dir(root, config.srcDir)
+    if not base.is_dir():
+        return []
+    found: list[tuple[Path, dict[str, Any]]] = []
+    for path in sorted(base.glob("*.json")):
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(data, dict) and (data.get("title") or data.get("name")):
+            found.append((path, sanitize_pricing(data)))
+    return found
+
+
+def write_pricing_files(
+    root: Path, config: ProjectConfig, items: list[dict[str, Any]]
+) -> int:
+    base = pricing_dir(root, config.srcDir)
+    base.mkdir(parents=True, exist_ok=True)
+    for existing in base.glob("*.json"):
+        existing.unlink()
+    count = 0
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        sanitized = sanitize_pricing(item)
+        if not pricing_identity(sanitized):
+            continue
+        path = base / pricing_filename(sanitized)
+        path.write_text(json.dumps(sanitized, indent=2) + "\n", encoding="utf-8")
+        count += 1
+    return count