@dypai-ai/mcp 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dypai-ai/mcp",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "DYPAI MCP Server — AI agent toolkit for building and deploying full-stack apps",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -138,10 +138,13 @@ const SERVER_INSTRUCTIONS = `You are building full-stack applications on the DYP
 
 ## Deploy Frontend
 - Use deploy_frontend tool with the project's source directory
-- Cloudflare Pages builds automatically (Vite, Next.js, Astro, etc.)
-- Site goes live at https://{slug}.dypai.app within ~1 minute
-- Check build progress with get_build_status
-- View build logs with get_deployment_logs if something fails
+- The tool pushes source, then waits for the build to finish (~1-2 min)
+- If the build succeeds, the response includes the live URL
+- If the build FAILS, the response includes the error logs — read them carefully, fix the code, and redeploy
+- Common build failures: missing dependencies (add to package.json), TypeScript errors, import path issues
+- Supports: Vite, React, Next.js, Astro, SvelteKit, Nuxt, Remix, Angular, Vinext, CRA, and more
+- Framework is auto-detected from package.json — correct build config is set automatically
+- If build times out (>2 min), use get_build_status / get_deployment_logs to check manually
 
 ## Import Data
 - Use bulk_upsert to import CSV or JSON files into database tables

package/src/tools/deploy.js

@@ -11,14 +11,51 @@ import { join, relative } from "path"
 import { api } from "../api.js"
 
 const MAX_SOURCE_SIZE = 50 * 1024 * 1024
-const IGNORE_DIRS = new Set(["node_modules", "dist", "build", "out", ".git", ".next", ".cache", ".turbo", ".vercel", ".output", "coverage"])
-const SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".js", ".cjs", ".css", ".scss", ".less", ".html", ".json", ".toml", ".yaml", ".yml", ".md", ".mdx", ".txt", ".svg", ".ico", ".webmanifest"])
+
+// Directories to skip — build outputs, caches, package managers
+const IGNORE_DIRS = new Set([
+  "node_modules", ".git",
+  // Build outputs
+  "dist", "build", "out", ".output", ".vercel", ".netlify",
+  // Framework caches
+  ".next", ".nuxt", ".svelte-kit", ".astro", ".angular", ".docusaurus",
+  ".cache", ".turbo", ".vite", ".parcel-cache", ".wrangler",
+  // Test / misc
+  "coverage", "storybook-static", "__pycache__", ".idea", ".vscode",
+])
+
+// Source file extensions to include
+const SOURCE_EXTS = new Set([
+  // JavaScript / TypeScript
+  ".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cjs", ".cts",
+  // Styles
+  ".css", ".scss", ".less", ".sass", ".styl",
+  // Markup / templates
+  ".html", ".htm",
+  // Framework-specific SFCs
+  ".vue", ".svelte", ".astro",
+  // Data / config
+  ".json", ".toml", ".yaml", ".yml",
+  // Content
+  ".md", ".mdx", ".txt",
+  // Assets metadata
+  ".svg", ".ico", ".webmanifest",
+  // Schema / query
+  ".graphql", ".gql", ".prisma",
+  // Misc
+  ".xml", ".csv",
+])
+
 const IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".svg"])
 const BLOCKED = new Set([".env", ".env.local", ".env.production", ".env.development", ".DS_Store", "Thumbs.db"])
 const MAX_IMAGE = 2 * 1024 * 1024
 
+// Root-level config files to always include (regex)
+const ROOT_CONFIG_RE = /^(package\.json|package-lock\.json|pnpm-lock\.yaml|bun\.lockb|yarn\.lock|vite\.config|vitest\.config|tsconfig|tailwind\.config|postcss\.config|next\.config|vinext\.config|astro\.config|nuxt\.config|svelte\.config|remix\.config|gatsby-config|angular\.json|docusaurus\.config|wrangler\.toml|wrangler\.json|vercel\.json|netlify\.toml|turbo\.json|components\.json|uno\.config|eslint\.config|prettier\.config|jest\.config|playwright\.config|\.prettierrc|\.eslintrc|\.browserslistrc|\.nvmrc|\.node-version|index\.html)/
+
 function collectSource(dir) {
   const files = []
+  const skipped = []
   let total = 0
 
   function walk(d, rel) {
@@ -35,36 +72,60 @@ function collectSource(dir) {
         if (!stat.isFile()) continue
         const ext = entry.includes(".") ? `.${entry.split(".").pop().toLowerCase()}` : ""
         let ok = SOURCE_EXTS.has(ext)
-        if (!rel && /^(package\.json|package-lock\.json|bun\.lockb|vite\.config|tsconfig|tailwind\.config|postcss\.config|next\.config|astro\.config|nuxt\.config)/.test(entry)) ok = true
+        if (!rel && ROOT_CONFIG_RE.test(entry)) ok = true
         if (IMAGE_EXTS.has(ext) && stat.size <= MAX_IMAGE) ok = true
-        if (ok) {
-          const content = readFileSync(full)
-          if (total + content.length > MAX_SOURCE_SIZE) return
-          total += content.length
-          files.push({ path, content: content.toString("base64") })
+
+        // Track skipped files so the user knows what was excluded
+        if (!ok) {
+          if (IMAGE_EXTS.has(ext) && stat.size > MAX_IMAGE) {
+            skipped.push({ path, reason: `Image too large (${(stat.size / (1024 * 1024)).toFixed(1)}MB, max ${MAX_IMAGE / (1024 * 1024)}MB)` })
+          } else if (ext && ![".lock", ".log"].includes(ext)) {
+            skipped.push({ path, reason: `Unsupported file type (${ext})` })
+          }
+          continue
         }
+
+        const content = readFileSync(full)
+        if (total + content.length > MAX_SOURCE_SIZE) {
+          skipped.push({ path, reason: "Total upload size limit reached" })
+          return
+        }
+        total += content.length
+        files.push({ path, content: content.toString("base64") })
       } catch {}
     }
   }
 
   walk(dir, "")
-  return { files, total }
+  return { files, total, skipped }
 }
 
+/**
+ * Detect framework for display AND for API build config.
+ * Returns { label, id } where id matches pages_service.py FRAMEWORK_PRESETS.
+ */
 function detectFramework(dir) {
   const pkgPath = join(dir, "package.json")
   if (!existsSync(pkgPath)) return null
   try {
     const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
     const deps = { ...pkg.dependencies, ...pkg.devDependencies }
-    if (deps["next"]) return "Next.js"
-    if (deps["astro"]) return "Astro"
-    if (deps["nuxt"]) return "Nuxt"
-    if (deps["@sveltejs/kit"]) return "SvelteKit"
-    if (deps["vite"]) return "Vite"
-    if (deps["react-scripts"]) return "Create React App"
-    if (deps["react"]) return "React"
-    return "Node.js"
+    if (deps["vinext"])          return { label: "Vinext",          id: "vinext" }
+    if (deps["next"])            return { label: "Next.js",         id: "next" }
+    if (deps["@sveltejs/kit"])   return { label: "SvelteKit",       id: "sveltekit" }
+    if (deps["nuxt"])            return { label: "Nuxt",            id: "nuxt" }
+    if (deps["@remix-run/react"])return { label: "Remix",           id: "remix" }
+    if (deps["astro"])           return { label: "Astro",           id: "astro" }
+    if (deps["gatsby"])          return { label: "Gatsby",          id: "gatsby" }
+    if (deps["@angular/core"])   return { label: "Angular",         id: "angular" }
+    if (deps["@docusaurus/core"])return { label: "Docusaurus",      id: "docusaurus" }
+    if (deps["preact"])          return { label: "Preact",          id: "preact" }
+    if (deps["solid-js"])        return { label: "Solid",           id: "solid" }
+    if (deps["react-scripts"])   return { label: "Create React App",id: "cra" }
+    if (deps["vite"])            return { label: "Vite",            id: "vite" }
+    if (deps["vue"])             return { label: "Vue",             id: "vue" }
+    if (deps["react"])           return { label: "React",           id: "react" }
+    return { label: "Node.js", id: "vite" }
   } catch { return null }
 }
 
@@ -105,7 +166,7 @@ After deploying, the site is live at https://{slug}.dypai.app within ~1 minute.`
     }
 
     const framework = detectFramework(sourceDirectory)
-    const { files, total } = collectSource(sourceDirectory)
+    const { files, total, skipped } = collectSource(sourceDirectory)
 
     if (!files.length) {
       return { error: "No source files found." }
@@ -114,17 +175,93 @@ After deploying, the site is live at https://{slug}.dypai.app within ~1 minute.`
     try {
       const result = await api.post(
         `/api/engine/${project_id}/frontend/deploy/source`,
-        { files }
+        { files, framework: framework?.id ?? null }
       )
 
+      const label = framework?.label ?? "Project"
+
+      // ── Wait for CF Pages build (poll up to ~2 min) ──────────────────────
+      let buildResult = null
+      const maxAttempts = 12       // 12 × 10s = 2 min max
+      const pollInterval = 10_000  // 10 seconds
+
+      for (let i = 0; i < maxAttempts; i++) {
+        await new Promise(r => setTimeout(r, pollInterval))
+        try {
+          const status = await api.get(`/api/engine/${project_id}/frontend/build-status`)
+          const s = status?.status
+          if (s === "success") {
+            buildResult = { status: "success", url: result.url, duration: status.duration_seconds }
+            break
+          }
+          if (s === "failure") {
+            // Fetch build logs for error context
+            let logs = status.build_error || null
+            if (!logs) {
+              try {
+                const deployments = await api.get(`/api/engine/${project_id}/frontend/deployments?limit=1`)
+                const depId = deployments?.deployments?.[0]?.id
+                if (depId) {
+                  const logRes = await api.get(`/api/engine/${project_id}/frontend/deployments/${depId}/logs`)
+                  if (logRes?.logs) {
+                    const lines = logRes.logs.split("\n")
+                    logs = lines.slice(-30).join("\n")
+                  }
+                }
+              } catch {}
+            }
+            buildResult = { status: "failure", error: logs || "Build failed — check logs with get_deployment_logs" }
+            break
+          }
+          // still queued/building — keep polling
+        } catch {
+          // build-status not available yet, keep polling
+        }
+      }
+
+      if (!buildResult) {
+        // Timed out — build still in progress
+        return {
+          success: true,
+          url: result.url,
+          files_pushed: files.length,
+          size_bytes: total,
+          framework: label,
+          build: "cloudflare_pages",
+          build_status: "building",
+          message: `Deployed ${files.length} files (${Math.round(total / 1024)} KB). ${label} build still in progress at ${result.url} — use get_build_status to check progress.`,
+        }
+      }
+
+      if (buildResult.status === "failure") {
+        return {
+          success: false,
+          url: result.url,
+          files_pushed: files.length,
+          framework: label,
+          build: "cloudflare_pages",
+          build_status: "failure",
+          build_error: buildResult.error,
+          message: `Deploy pushed ${files.length} files but the ${label} build FAILED. Build error:\n${buildResult.error}`,
+        }
+      }
+
+      const skippedMsg = skipped.length > 0
+        ? `\n\nSkipped ${skipped.length} file(s):\n${skipped.map(s => `  - ${s.path}: ${s.reason}`).join("\n")}`
+        : ""
+
       return {
         success: true,
         url: result.url,
         files_pushed: files.length,
+        files_skipped: skipped.length,
+        skipped_files: skipped.length > 0 ? skipped : undefined,
         size_bytes: total,
-        framework: framework,
+        framework: label,
         build: "cloudflare_pages",
-        message: `Deployed ${files.length} files (${Math.round(total / 1024)} KB). ${framework || "Project"} building in the cloud. Live in ~1 minute at ${result.url}`,
+        build_status: "success",
+        build_duration: buildResult.duration,
+        message: `Deployed ${files.length} files (${Math.round(total / 1024)} KB). ${label} build succeeded${buildResult.duration ? ` in ${buildResult.duration}s` : ""}. Live at ${result.url}${skippedMsg}`,
       }
     } catch (e) {
       return { error: `Deploy failed: ${e.message}` }

package/src/tools/github.js

@@ -0,0 +1,57 @@
+/**
+ * GitHub repo link/unlink tools.
+ */
+
+import { api } from "../api.js"
+
+export const linkRepoTool = {
+  name: "link_repo",
+  description: `Link an existing GitHub repo to the project.
+
+After linking, pushes to that repo auto-deploy to Cloudflare Pages.
+The MCP deploy tool will also push to this repo.
+Requires the user to have GitHub connected (DYPAI App installed on their account).`,
+
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: { type: "string", description: "Project UUID." },
+      repo_url: { type: "string", description: "GitHub repo URL (e.g. https://github.com/owner/repo)" },
+      branch: { type: "string", description: "Branch to deploy from (default: main)" },
+    },
+    required: ["project_id", "repo_url"],
+  },
+
+  async execute({ project_id, repo_url, branch }) {
+    try {
+      return await api.post(`/api/engine/${project_id}/github/link`, {
+        repo_url,
+        branch: branch || "main",
+      })
+    } catch (e) {
+      return { error: e.message }
+    }
+  },
+}
+
+export const unlinkRepoTool = {
+  name: "unlink_repo",
+  description: `Unlink the user's GitHub repo and revert to a DYPAI-managed repo.
+The user's repo is NOT deleted — only the connection is removed.`,
+
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: { type: "string", description: "Project UUID." },
+    },
+    required: ["project_id"],
+  },
+
+  async execute({ project_id }) {
+    try {
+      return await api.post(`/api/engine/${project_id}/github/unlink`, {})
+    } catch (e) {
+      return { error: e.message }
+    }
+  },
+}