@scemoon/cdh 1.0.6 → 1.0.8

package/ai-dlc-skill/workflows/deployment.yaml

@@ -1,199 +0,0 @@
-# AI-DLC Deliver Deployment Pipeline (Stack)
-
-Extends the Deliver phase with a unified stack deploy pipeline, per-component and cross-stack e2e, and stack-level BVT + rollback.
-
-## Environments
-
-| Environment | Purpose | Deploy Trigger | TTL |
-|-------------|---------|----------------|-----|
-| preview | Per-component + cross-stack e2e verification | Feature branch | 24h, auto-cleanup |
-| staging | Pre-production stack validation | PR merge to main | — |
-| production | Live traffic | Release tag + human approval | — |
-
-## Stack Topology
-
-```yaml
-stack:
-  components:
-    - id: backend
-      deploy:
-        - functions: tcb fn deploy
-        - db: tcb db migrate
-      exposes: BACKEND_URL
-    - id: web
-      depends_on: [backend]
-      deploy:
-        - hosting: tcb hosting deploy --build-env BACKEND_URL=${BACKEND_URL}
-      consumes: BACKEND_URL
-    - id: native
-      depends_on: [backend]
-      deploy:
-        - build: build with BACKEND_URL injected
-        - distribute: upload to internal distribution
-      consumes: BACKEND_URL
-    - id: desktop
-      depends_on: [backend]
-      deploy:
-        - build: build with BACKEND_URL injected
-        - distribute: upload to internal distribution
-      consumes: BACKEND_URL
-    - id: wxa
-      depends_on: [backend]
-      deploy:
-        - build: build with BACKEND_URL injected
-        - distribute: upload to mini-program platform
-      consumes: BACKEND_URL
-    - id: mya
-      depends_on: [backend]
-      deploy:
-        - build: build with BACKEND_URL injected
-        - distribute: upload to mini-program platform
-      consumes: BACKEND_URL
-    - id: tta
-      depends_on: [backend]
-      deploy:
-        - build: build with BACKEND_URL injected
-        - distribute: upload to mini-program platform
-      consumes: BACKEND_URL
-```
-
-The `deploy_stack` orchestrator:
-1. Resolves the platform (TCB / Aliyun) from the active provider.
-2. Deploys `backend` first; captures `BACKEND_URL`.
-3. Deploys all client components (`web`, `native`, `desktop`, `wxa`, `mya`, `tta`) in parallel with `BACKEND_URL` injected at build time.
-4. Exposes `STACK_URL` (= `BACKEND_URL` for the gateway) and per-component URLs.
-
-## Pipeline
-
-```yaml
-name: deliver
-version: 3.0.0
-
-stages:
-  - name: preview
-    description: Unified stack preview with per-component + cross-stack e2e
-    steps:
-      - name: deploy_stack
-        command: deploy_stack --preview
-        platform: dynamic  # TCB or Aliyun
-        output:
-          - name: stack_url
-          - name: backend_url
-          - name: web_url
-      - name: e2e_backend
-        command: pytest apps/backend/tests/e2e/ --base-url ${BACKEND_URL}
-        requires: [deploy_stack]
-      - name: e2e_web
-        command: pytest apps/web/tests/e2e/ --base-url ${WEB_URL} --api-url ${BACKEND_URL}
-        requires: [deploy_stack]
-      - name: e2e_native
-        command: pytest apps/native/tests/e2e/ --backend-url ${BACKEND_URL}
-        requires: [deploy_stack]
-        when: affects contains native
-      - name: e2e_desktop
-        command: pytest apps/desktop/tests/e2e/ --backend-url ${BACKEND_URL}
-        requires: [deploy_stack]
-        when: affects contains desktop
-      - name: e2e_wxa
-        command: pytest apps/wxa/tests/e2e/ --backend-url ${BACKEND_URL}
-        requires: [deploy_stack]
-        when: affects contains wxa
-      - name: e2e_mya
-        command: pytest apps/mya/tests/e2e/ --backend-url ${BACKEND_URL}
-        requires: [deploy_stack]
-        when: affects contains mya
-      - name: e2e_tta
-        command: pytest apps/tta/tests/e2e/ --backend-url ${BACKEND_URL}
-        requires: [deploy_stack]
-        when: affects contains tta
-      - name: e2e_cross_stack
-        command: pytest aidlc/tests/cross-stack/ --stack-url ${STACK_URL}
-        requires: [e2e_backend, e2e_web, e2e_native, e2e_desktop, e2e_wxa, e2e_mya, e2e_tta]
-        when: affects contains >= 2 components
-
-  - name: staging
-    description: Staging stack smoke test
-    steps:
-      - name: deploy_stack
-        command: deploy_stack --env staging
-      - name: smoke
-        command: smoke-test ${STACK_URL}
-      - name: cross_stack
-        command: pytest aidlc/tests/cross-stack/ --stack-url ${STACK_URL}
-
-  - name: production
-    description: Stack production deploy with stack BVT
-    conditions:
-      branch: main
-    steps:
-      - name: approve
-        command: human-approval-gate
-        inputs:
-          - per_component_e2e_reports
-          - cross_stack_e2e_report
-          - staging_smoke_report
-          - aidlc/openspec/changes/{id}/contract-diff.md
-      - name: deploy_stack
-        command: deploy_stack --env production
-      - name: bvt
-        command: bvt ${PRODUCTION_URL}
-        timeout: 60s
-      - name: health_check
-        command: curl -f ${PRODUCTION_URL}/health
-        timeout: 30s
-      - name: archive_contract_diff
-        command: cp aidlc/openspec/changes/{id}/contract-diff.md aidlc/deploy-artifacts/
-
-rollback:
-  triggers:
-    - condition: BVT failure → automatic stack rollback
-    - condition: Health check 5xx → automatic stack rollback
-    - condition: Error rate >1% in 5min → manual stack rollback
-  action: deploy_stack --rollback ${LAST_STABLE_STACK_VERSION}
-  scope: stack   # all components roll back together (STK-006)
-```
-
-## BVT Checklist (Stack)
-
-Executed after every production deployment. BVT operates on the **stack**, not a single component:
-
-```bash
-bvt ${PRODUCTION_URL}
-#  1. backend /health returns 200 OK
-#  2. web home page returns 200 (SSR) or shell loads (SPA)
-#  3. native/desktop/mini-program launch probe (deep link resolves against BACKEND_URL)
-#  4. Core cross-stack flow (login) succeeds end-to-end
-#  5. Database reachable
-#  6. Error rate < 0.1%
-#  7. Latency p99 < 500ms
-#  8. Contract diff archived
-```
-
-## Build Config Injection
-
-All client builds (`web`, `native`, `desktop`, `wxa`, `mya`, `tta`) receive `BACKEND_URL` (and any other stack-level config) at build time. The orchestrator passes the env value; components MUST NOT hardcode URLs (STK-005).
-
-```bash
-# web
-pnpm --filter web build --env BACKEND_URL=$BACKEND_URL
-
-# native
-cd apps/native && BACKEND_URL=$BACKEND_URL pnpm build
-
-# desktop
-cd apps/desktop && BACKEND_URL=$BACKEND_URL pnpm build
-
-# mini-programs (wxa, mya, tta)
-cd apps/wxa && BACKEND_URL=$BACKEND_URL pnpm build
-cd apps/mya && BACKEND_URL=$BACKEND_URL pnpm build
-cd apps/tta && BACKEND_URL=$BACKEND_URL pnpm build
-```
-
-## Component URL Resolution
-
-Per-platform URL patterns (resolved by `deploy_stack`):
-
-| Platform | STACK_URL | WEB_URL | NATIVE/DESKTOP distribution | MINI-PROGRAM distribution |
-|----------|-----------|---------|---------------------------|---------------------------|
-| TCB | `https://{env-id}.tcb-preview.com` | `https://{env-id}-{project}.tcb-preview.com` | internal distribution URL | mini-program preview QR |
-| Aliyun | `https://{gateway}.{region}.fc.devs.com` | `https://{bucket}.{region}.oss-website.aliyuncs.com` | internal distribution URL | mini-program preview QR |

package/cdh/__main__.py

@@ -1,4 +0,0 @@
-from cdh.cli import main
-
-if __name__ == "__main__":
-    main()

package/cdh/cdh_mcp_injector.py

@@ -1,115 +0,0 @@
-"""cdh platform MCP injector — injects platform MCPs into engines.
-
-Strategies (per engine capability):
-- env var: Set CDH_SHARED_MCP with JSON-serialized platform MCP configs
-- CLI args: Inject via engine-specific CLI flags (--mcp-server name=url)
-- config file: Write a temp config that the engine reads at startup
-
-Name conflict: engine private MCPs win over cdh platform MCPs.
-Engines that don't support injection get a silent fallback (INFO log).
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Optional
-
-import yaml
-
-logger = logging.getLogger("cdh.mcp.injector")
-
-CDH_SHARED_MCP_ENV = "CDH_SHARED_MCP"
-
-
-class CdhMcpInjector:
-    SUPPORTED_ENGINES = {"onecode", "opencode"}
-
-    def __init__(self, platform_mcps_dir: Path | None = None):
-        from cdh.cdh_mcp_manager import CDH_PLATFORM_MCPS_DIR
-
-        self.platform_mcps_dir = platform_mcps_dir or CDH_PLATFORM_MCPS_DIR
-
-    def inject_env(self) -> None:
-        """Set CDH_SHARED_MCP env var with platform MCP configs."""
-        config_path = self.platform_mcps_dir / "mcps.yaml"
-        if not config_path.exists():
-            return
-        try:
-            data = yaml.safe_load(config_path.read_text()) or {}
-            os.environ[CDH_SHARED_MCP_ENV] = json.dumps(data)
-            logger.debug("Set %s with %d MCP servers", CDH_SHARED_MCP_ENV, len(data))
-        except Exception as e:
-            logger.warning("Failed to inject platform MCPs via env: %s", e)
-
-    def clear_env(self) -> None:
-        os.environ.pop(CDH_SHARED_MCP_ENV, None)
-
-    def get_shared_mcp_config(self) -> dict[str, dict]:
-        raw = os.environ.get(CDH_SHARED_MCP_ENV, "")
-        if not raw:
-            return {}
-        try:
-            return json.loads(raw)
-        except json.JSONDecodeError:
-            logger.warning("Invalid %s value, ignoring", CDH_SHARED_MCP_ENV)
-            return {}
-
-    def inject_for_engine(
-        self,
-        engine_name: str,
-        engine_mcps_path: Path | None = None,
-    ) -> Optional[str]:
-        """Inject platform MCPs for a specific engine.
-
-        Returns an info/warning message, or None if no injection needed.
-
-        For supported engines: sets CDH_SHARED_MCP env var.
-        For unsupported engines: logs a silent INFO fallback.
-        """
-        platform_config = self._load_platform_config()
-        if not platform_config:
-            return None
-
-        if engine_name not in self.SUPPORTED_ENGINES:
-            logger.info(
-                "Engine '%s' does not support cdh platform MCP injection. "
-                "Platform MCPs available via %s env var.",
-                engine_name,
-                CDH_SHARED_MCP_ENV,
-            )
-            return None
-
-        # Merge with engine private (engine wins)
-        merged = dict(platform_config)
-        if engine_mcps_path and engine_mcps_path.exists():
-            try:
-                engine_data = yaml.safe_load(engine_mcps_path.read_text()) or {}
-                engine_data = {
-                    k: v for k, v in engine_data.items() if isinstance(v, dict)
-                }
-            except Exception:
-                engine_data = {}
-            merged.update(engine_data)
-
-        os.environ[CDH_SHARED_MCP_ENV] = json.dumps(merged)
-        logger.debug(
-            "Injected %d platform MCPs + %d engine MCPs via %s for '%s'",
-            len(platform_config),
-            len(engine_data) if engine_mcps_path and engine_mcps_path.exists() else 0,
-            CDH_SHARED_MCP_ENV,
-            engine_name,
-        )
-        return f"{len(platform_config)} platform MCP(s) injected for '{engine_name}'"
-
-    def _load_platform_config(self) -> dict[str, dict]:
-        config_path = self.platform_mcps_dir / "mcps.yaml"
-        if not config_path.exists():
-            return {}
-        try:
-            data = yaml.safe_load(config_path.read_text()) or {}
-            return {k: v for k, v in data.items() if isinstance(v, dict)}
-        except Exception:
-            return {}

package/cdh/cdh_mcp_loader.py

@@ -1,67 +0,0 @@
-"""cdh platform MCP loader — merges platform MCPs with engine-private MCPs.
-
-Discovery order:
-1. Read engine-private MCPs from engine's own config (e.g. ~/.onecode/mcps/mcps.yaml)
-2. Read cdh platform MCPs from ~/.cdh/mcps/mcps.yaml
-3. Merge: engine private wins on name conflict
-4. Return merged list for injection
-"""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-
-import yaml
-
-from cdh.cdh_mcp_manager import CDH_PLATFORM_MCPS_DIR
-
-logger = logging.getLogger("cdh.mcp.loader")
-
-
-class CdhMcpLoader:
-    def __init__(self, platform_mcps_dir: Path | None = None):
-        self.platform_mcps_dir = platform_mcps_dir or CDH_PLATFORM_MCPS_DIR
-        self._cache: dict[str, dict] | None = None
-
-    def load_platform(self) -> dict[str, dict]:
-        config_path = self.platform_mcps_dir / "mcps.yaml"
-        if not config_path.exists():
-            return {}
-        try:
-            data = yaml.safe_load(config_path.read_text()) or {}
-            return {k: v for k, v in data.items() if isinstance(v, dict)}
-        except Exception:
-            logger.warning("Failed to load platform MCP config from %s", config_path)
-            return {}
-
-    def get_merged(
-        self, engine_mcps_path: Path | None = None
-    ) -> list[dict]:
-        platform = self.load_platform()
-
-        if engine_mcps_path and engine_mcps_path.exists():
-            try:
-                engine_data = yaml.safe_load(engine_mcps_path.read_text()) or {}
-                engine_data = {k: v for k, v in engine_data.items() if isinstance(v, dict)}
-            except Exception:
-                engine_data = {}
-        else:
-            engine_data = {}
-
-        merged = dict(platform)
-        merged.update(engine_data)
-
-        return [
-            {"name": name, **cfg, "source": "engine" if name in engine_data else "platform"}
-            for name, cfg in merged.items()
-        ]
-
-    def get_platform_only(self) -> list[dict]:
-        return [
-            {"name": name, **cfg, "source": "platform"}
-            for name, cfg in self.load_platform().items()
-        ]
-
-    def invalidate_cache(self) -> None:
-        self._cache = None

package/cdh/cdh_mcp_manager.py

@@ -1,73 +0,0 @@
-"""cdh platform MCP manager — operates ~/.cdh/mcps/.
-
-This is the cdh platform equivalent of onecode.mcp.manager.MCPManager,
-but operates strictly on ~/.cdh/mcps/ (cdh platform shared MCP pool).
-Engines (onecode/opencode/claude) read platform MCPs via env var
-injection at launch time (see cdh_mcp_injector.py).
-"""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-from typing import Optional
-
-import yaml
-
-logger = logging.getLogger("cdh.mcp")
-
-CDH_PLATFORM_MCPS_DIR = Path.home() / ".cdh" / "mcps"
-
-
-class CdhMcpManager:
-    def __init__(self, mcps_dir: Path | None = None):
-        self.mcps_dir = mcps_dir or CDH_PLATFORM_MCPS_DIR
-        self.mcps_dir.mkdir(parents=True, exist_ok=True)
-        self.config_path = self.mcps_dir / "mcps.yaml"
-        self._data: dict[str, dict] = {}
-        if self.config_path.exists():
-            try:
-                self._data = yaml.safe_load(self.config_path.read_text()) or {}
-            except Exception:
-                self._data = {}
-
-    def add(self, name: str, url: str, transport: str = "sse") -> None:
-        self._data[name] = {"url": url, "transport": transport, "enabled": True}
-        self._save()
-
-    def add_stdio(self, name: str, command: str, args: list[str] | None = None) -> None:
-        self._data[name] = {
-            "command": command,
-            "args": args or [],
-            "transport": "stdio",
-            "enabled": True,
-        }
-        self._save()
-
-    def list(self) -> list[dict]:
-        return [{"name": name, **cfg} for name, cfg in self._data.items()]
-
-    def get(self, name: str) -> Optional[dict]:
-        return self._data.get(name)
-
-    def enable(self, name: str, enabled: bool = True) -> Optional[str]:
-        if name not in self._data:
-            return f"MCP server '{name}' not found"
-        self._data[name]["enabled"] = enabled
-        self._save()
-        return None
-
-    def remove(self, name: str) -> Optional[str]:
-        if name not in self._data:
-            return f"MCP server '{name}' not found"
-        del self._data[name]
-        self._save()
-        return None
-
-    def to_dict(self) -> dict[str, dict]:
-        return dict(self._data)
-
-    def _save(self) -> None:
-        self.config_path.write_text(
-            yaml.dump(self._data, default_flow_style=False), encoding="utf-8"
-        )