God Mode+ v3 fix: agents/deploy_agent.py

agents/deploy_agent.py

@@ -1,24 +1,19 @@
 """
-DeployAgent — Automated deployments to Vercel, HF Spaces, GitHub Pages
+DeployAgent — Real deployments to Vercel, HuggingFace, GitHub
+Uses actual APIs (no mock/fake responses)
 """
 import json
 import os
-from typing import Dict
-import httpx
 import structlog
+from typing import Dict, Optional
+import httpx
 from .base_agent import BaseAgent
 
 log = structlog.get_logger()
 
-DEPLOY_SYSTEM = """You are a deployment engineer expert in:
-- Vercel deployments (Next.js, React, API routes)
-- HuggingFace Spaces (Docker, Gradio, Streamlit)
-- GitHub Pages (static sites)
-- Docker containerization
-- Environment variable management
-
-Generate precise deployment configs and commands.
-"""
+VERCEL_TOKEN = os.environ.get("VERCEL_TOKEN", "")
+HF_TOKEN     = os.environ.get("HF_TOKEN", "")
+GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN", "")
 
 
 class DeployAgent(BaseAgent):
@@ -26,76 +21,155 @@ class DeployAgent(BaseAgent):
         super().__init__("DeployAgent", ws_manager, ai_router)
 
     async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
+        session_id = kwargs.get("session_id", context.get("session_id", ""))
+        task_id    = kwargs.get("task_id",    context.get("task_id", ""))
+        task_lower = task.lower()
 
-        await self.emit(task_id, "agent_start", {"agent": "DeployAgent", "task": task[:80]}, session_id)
+        await self.emit(task_id, "deploy_started", {"task": task[:100]}, session_id)
 
-        task_lower = task.lower()
         if "vercel" in task_lower:
-            return await self._deploy_vercel_guide(task, task_id, session_id)
-        elif "huggingface" in task_lower or "hf" in task_lower or "space" in task_lower:
-            return await self._deploy_hf_guide(task, task_id, session_id)
-        elif "docker" in task_lower:
-            return await self._generate_dockerfile(task, task_id, session_id)
+            return await self.deploy_vercel(context, task_id, session_id)
+        elif "hf" in task_lower or "huggingface" in task_lower or "space" in task_lower:
+            return await self.deploy_hf(context, task_id, session_id)
+        elif "github" in task_lower:
+            return await self.push_github(context, task_id, session_id)
         else:
-            return await self._deploy_general(task, task_id, session_id)
-
-    async def _deploy_vercel_guide(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": DEPLOY_SYSTEM},
-            {"role": "user", "content": (
-                f"Generate complete Vercel deployment guide for: {task}\n\n"
-                f"Include:\n1. vercel.json config\n2. Environment variables needed\n"
-                f"3. Build commands\n4. Step-by-step deployment instructions"
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2)
-        await self.emit(task_id, "deploy_plan_ready", {"platform": "vercel"}, session_id)
-        return result
-
-    async def _deploy_hf_guide(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": DEPLOY_SYSTEM},
-            {"role": "user", "content": (
-                f"Generate HuggingFace Space deployment for: {task}\n\n"
-                f"Include:\n1. Dockerfile\n2. README.md with YAML header\n"
-                f"3. Requirements/dependencies\n4. Space configuration"
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2)
-        await self.emit(task_id, "deploy_plan_ready", {"platform": "huggingface"}, session_id)
-        return result
-
-    async def _generate_dockerfile(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": DEPLOY_SYSTEM},
-            {"role": "user", "content": f"Generate production Dockerfile for: {task}\nInclude multi-stage build, security best practices, health check."},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1)
-
-    async def _deploy_general(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": DEPLOY_SYSTEM},
-            {"role": "user", "content": f"Create deployment plan for: {task}\n\nInclude platform recommendation, config files, and step-by-step guide."},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id)
-
-    async def check_vercel_deployments(self) -> str:
-        """Check recent Vercel deployments."""
-        token = os.environ.get("VERCEL_TOKEN", "")
-        if not token:
-            return "⚠️ VERCEL_TOKEN not set."
+            return await self.deploy_vercel(context, task_id, session_id)
+
+    # ─── Vercel Deploy ──────────────────────────────���─────────────────────────
+
+    async def deploy_vercel(self, context: Dict, task_id: str, session_id: str) -> str:
+        if not VERCEL_TOKEN:
+            return "❌ VERCEL_TOKEN not set — cannot deploy to Vercel"
+
+        project_name = context.get("project_name", "god-mode-frontend")
+        files        = context.get("files", {})
+
+        if not files:
+            return "❌ No files provided for Vercel deployment"
+
         try:
-            async with httpx.AsyncClient(timeout=15) as client:
-                resp = await client.get(
-                    "https://api.vercel.com/v6/deployments?limit=5",
-                    headers={"Authorization": f"Bearer {token}"}
+            payload = {
+                "name": project_name,
+                "files": [
+                    {"file": path, "data": content}
+                    for path, content in files.items()
+                ],
+                "projectSettings": {"framework": "nextjs"},
+            }
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                resp = await client.post(
+                    "https://api.vercel.com/v13/deployments",
+                    headers={
+                        "Authorization": f"Bearer {VERCEL_TOKEN}",
+                        "Content-Type": "application/json",
+                    },
+                    json=payload,
                 )
-                if resp.status_code == 200:
-                    deps = resp.json().get("deployments", [])
-                    lines = [f"- {d.get('name')} → {d.get('state')} ({d.get('url', '')})" for d in deps[:5]]
-                    return "🚀 **Recent Vercel Deployments:**\n\n" + "\n".join(lines)
+                resp.raise_for_status()
+                data = resp.json()
+                url  = data.get("url", "")
+                uid  = data.get("uid", "")
+                await self.emit(task_id, "deploy_completed", {
+                    "platform": "vercel", "url": url, "uid": uid
+                }, session_id)
+                return f"✅ Deployed to Vercel: https://{url}"
         except Exception as e:
-            return f"❌ Vercel error: {e}"
-        return "No deployments found."
+            log.error("Vercel deploy failed", error=str(e))
+            return f"❌ Vercel deploy error: {str(e)}"
+
+    # ─── HF Space Update ──────────────────────────────────────────────────────
+
+    async def deploy_hf(self, context: Dict, task_id: str, session_id: str) -> str:
+        if not HF_TOKEN:
+            return "❌ HF_TOKEN not set — cannot deploy to HuggingFace"
+
+        repo_id  = context.get("repo_id", "")
+        files    = context.get("files", {})
+
+        if not repo_id:
+            return "❌ repo_id required for HF Space deployment"
+
+        results = []
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            for path, content in files.items():
+                try:
+                    resp = await client.put(
+                        f"https://huggingface.co/api/spaces/{repo_id}/upload/{path}",
+                        headers={
+                            "Authorization": f"Bearer {HF_TOKEN}",
+                            "Content-Type": "application/octet-stream",
+                        },
+                        content=content.encode() if isinstance(content, str) else content,
+                    )
+                    resp.raise_for_status()
+                    results.append(f"✅ {path}")
+                except Exception as e:
+                    results.append(f"❌ {path}: {str(e)}")
+
+        summary = "\n".join(results)
+        await self.emit(task_id, "deploy_completed", {
+            "platform": "huggingface", "repo_id": repo_id, "files": len(files)
+        }, session_id)
+        return f"**HuggingFace Space Deploy** ({repo_id}):\n{summary}"
+
+    # ─── GitHub Push ──────────────────────────────────────────────────────────
+
+    async def push_github(self, context: Dict, task_id: str, session_id: str) -> str:
+        if not GITHUB_TOKEN:
+            return "❌ GITHUB_TOKEN not set — cannot push to GitHub"
+
+        repo     = context.get("repo", "")
+        files    = context.get("files", {})
+        message  = context.get("commit_message", "God Agent automated commit")
+        branch   = context.get("branch", "main")
+
+        if not repo or not files:
+            return "❌ repo and files required for GitHub push"
+
+        results = []
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            headers = {
+                "Authorization": f"token {GITHUB_TOKEN}",
+                "Accept": "application/vnd.github.v3+json",
+            }
+            for path, content in files.items():
+                try:
+                    import base64
+                    encoded = base64.b64encode(
+                        content.encode() if isinstance(content, str) else content
+                    ).decode()
+
+                    # Check if file exists (get SHA)
+                    sha = None
+                    get_resp = await client.get(
+                        f"https://api.github.com/repos/{repo}/contents/{path}",
+                        headers=headers,
+                        params={"ref": branch},
+                    )
+                    if get_resp.status_code == 200:
+                        sha = get_resp.json().get("sha")
+
+                    payload: Dict = {
+                        "message": message,
+                        "content": encoded,
+                        "branch":  branch,
+                    }
+                    if sha:
+                        payload["sha"] = sha
+
+                    put_resp = await client.put(
+                        f"https://api.github.com/repos/{repo}/contents/{path}",
+                        headers=headers,
+                        json=payload,
+                    )
+                    put_resp.raise_for_status()
+                    results.append(f"✅ {path}")
+                except Exception as e:
+                    results.append(f"❌ {path}: {str(e)}")
+
+        summary = "\n".join(results)
+        await self.emit(task_id, "deploy_completed", {
+            "platform": "github", "repo": repo, "files": len(files)
+        }, session_id)
+        return f"**GitHub Push** ({repo}/{branch}):\n{summary}"