@dypai-ai/mcp 1.4.2 → 1.4.5

package/src/tools/sync.js

@@ -12,11 +12,61 @@
  * node_modules, .vscode, etc.) are preserved.
  */
 
-import { writeFileSync, mkdirSync, existsSync } from "fs"
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs"
 import { join, dirname } from "path"
 import { createHash } from "crypto"
 import { api } from "../api.js"
 
+// Engine hostname suffix. Production hosts of the form `<project_id>.dypai.dev`
+// serve LIVE traffic; `dev-<project_id>.dypai.dev` serves the LAYER 2.5 draft
+// overlay (drafts when present, live as fallback). Override only for local
+// engine development against `*.localhost`.
+const DEFAULT_ENGINE_BASE = "dypai.dev"
+
+// Detect the frontend framework by inspecting `package.json` so we know which
+// env-var prefix the bundler will inject at build time. We only need to
+// distinguish Next.js from everything else (Vite/React/Astro/SvelteKit/etc.
+// all consume `VITE_*` style or accept it as fallback). Returns "next" |
+// "vite" | "unknown" — when "unknown" we write BOTH prefixes (cheap, harmless).
+function detectFramework(targetDirectory) {
+  try {
+    const pkgPath = join(targetDirectory, "package.json")
+    if (!existsSync(pkgPath)) return "unknown"
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"))
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) }
+    if (deps.next) return "next"
+    if (deps.vite || deps["@vitejs/plugin-react"]) return "vite"
+    return "unknown"
+  } catch {
+    return "unknown"
+  }
+}
+
+// Build the contents of `.env.local`. We point at the DRAFT OVERLAY host
+// (`dev-<project_id>.<base>`), not at live, so an unpublished `dypai_push`
+// is visible end-to-end from the local frontend. On production deploy the
+// platform PATCHes `<PREFIX>DYPAI_URL` to the LIVE host as a CF Pages build
+// env var, so this file is only ever consumed by `vite dev` / `next dev`.
+function buildEnvLocalContents(project_id, framework, engineBase) {
+  const draftUrl = `https://dev-${project_id}.${engineBase}`
+  const lines = [
+    `# DYPAI — generated by manage_frontend(sync). Safe to edit; do NOT commit.`,
+    `# Points at the LAYER 2.5 draft overlay so unpublished \`dypai_push\` changes`,
+    `# are picked up by the local dev server. Production builds receive the LIVE`,
+    `# URL automatically as a CF Pages build env var (no action needed).`,
+    ``,
+  ]
+  if (framework === "next" || framework === "unknown") {
+    lines.push(`NEXT_PUBLIC_DYPAI_URL=${draftUrl}`)
+    lines.push(`NEXT_PUBLIC_PROJECT_ID=${project_id}`)
+  }
+  if (framework === "vite" || framework === "unknown") {
+    lines.push(`VITE_DYPAI_URL=${draftUrl}`)
+    lines.push(`VITE_PROJECT_ID=${project_id}`)
+  }
+  return lines.join("\n") + "\n"
+}
+
 export async function syncFromRemote({ project_id, targetDirectory, overwrite = false }) {
   if (!project_id) {
     return { success: false, error: "project_id is required." }
@@ -92,22 +142,33 @@ export async function syncFromRemote({ project_id, targetDirectory, overwrite =
     }
   }
 
-  // Seed the deploy manifest with the synced files' hashes. The next deploy
-  // sees the full project already matches the remote and only uploads what
-  // the agent actually edits — avoids a pointless 30 MB "full deploy" right
-  // after a sync when nothing has changed yet.
+  // Seed the last-deploy hash so the next deploy can skip if nothing
+  // changed. We compute the same project-wide hash deploy.js produces
+  // (sorted path+file-hash pairs). If the user runs `manage_frontend(deploy)`
+  // right after a sync and hasn't edited anything, it returns "no_changes"
+  // instantly without re-uploading 30 MB over the wire.
   try {
     const dypaiBase = existsSync(join(targetDirectory, "dypai"))
       ? join(targetDirectory, "dypai", ".dypai")
       : join(targetDirectory, ".dypai")
     mkdirSync(dypaiBase, { recursive: true })
+
+    // Same algorithm as deploy.js:computeProjectHash — sort by path, join
+    // path + hash with NUL, SHA-256 the concatenation. Keep in sync.
+    const entries = Object.entries(hashMap).sort(([a], [b]) => a.localeCompare(b))
+    const h = createHash("sha256")
+    for (const [path, fileHash] of entries) {
+      h.update(path); h.update("\0"); h.update(fileHash); h.update("\0")
+    }
+    const projectHash = h.digest("hex")
+
     writeFileSync(
-      join(dypaiBase, "deploy-manifest.json"),
-      JSON.stringify(hashMap, null, 2) + "\n",
+      join(dypaiBase, "last-deploy.json"),
+      JSON.stringify({ hash: projectHash, at: new Date().toISOString() }, null, 2) + "\n",
     )
   } catch (e) {
     // Non-fatal: the first deploy will just be a full deploy.
-    failures.push({ path: ".dypai/deploy-manifest.json", reason: `Manifest seed failed: ${e.message}` })
+    failures.push({ path: ".dypai/last-deploy.json", reason: `Hash seed failed: ${e.message}` })
   }
 
   // Structured next_steps so the agent can act without re-prompting the LLM.
@@ -121,19 +182,41 @@ export async function syncFromRemote({ project_id, targetDirectory, overwrite =
     )
   }
 
-  // .env is gitignored → the source API does NOT return it → the frontend won't
-  // know the engine URL. If it's missing after sync, tell the agent to create it.
-  // Engine URL convention: https://<project_id>.dypai.app (override with DYPAI_ENGINE_BASE).
-  const envMissing = !existsSync(join(targetDirectory, ".env"))
-  if (envMissing) {
-    const engineBase = process.env.DYPAI_ENGINE_BASE || "dypai.app"
-    const engineUrl = `https://${project_id}.${engineBase}`
-    next_steps.push(
-      `Create .env in ${targetDirectory} with \`VITE_DYPAI_URL=${engineUrl}\` (and \`VITE_PROJECT_ID=${project_id}\`). ` +
-      `Use NEXT_PUBLIC_DYPAI_URL instead of VITE_DYPAI_URL for Next.js projects. ` +
-      `The frontend SDK reads this to reach the engine — without .env, API calls will fail with network errors.`
-    )
+  // `.env` / `.env.local` are gitignored → the source API does NOT return them
+  // → the frontend wouldn't know which engine URL to hit. We auto-write
+  // `.env.local` with the LAYER 2.5 draft-overlay URL (`dev-<project_id>.<base>`)
+  // so the local dev server picks up unpublished `dypai_push` changes
+  // immediately. Production builds receive the LIVE URL via CF Pages build
+  // env vars set by the control plane (api/services/frontend/pages_service.py).
+  //
+  // We only WRITE if `.env.local` (and the legacy `.env`) don't exist —
+  // never clobber a user-authored config.
+  const engineBase = process.env.DYPAI_ENGINE_BASE || DEFAULT_ENGINE_BASE
+  const envLocalPath = join(targetDirectory, ".env.local")
+  const envPath = join(targetDirectory, ".env")
+  const hasUserEnv = existsSync(envLocalPath) || existsSync(envPath)
+  let envWritten = false
+  if (!hasUserEnv) {
+    try {
+      const framework = detectFramework(targetDirectory)
+      writeFileSync(envLocalPath, buildEnvLocalContents(project_id, framework, engineBase))
+      envWritten = true
+      next_steps.push(
+        `Wrote \`.env.local\` pointing at the draft-overlay host \`https://dev-${project_id}.${engineBase}\`. ` +
+        `Local dev (\`vite dev\` / \`next dev\`) will see unpublished \`dypai_push\` changes immediately. ` +
+        `Production builds get the LIVE URL injected automatically — no manual switch needed.`
+      )
+    } catch (e) {
+      failures.push({ path: ".env.local", reason: `Could not write env file: ${e.message}` })
+      next_steps.push(
+        `Could not auto-write .env.local (${e.message}). Create it manually with ` +
+        `\`VITE_DYPAI_URL=https://dev-${project_id}.${engineBase}\` (or \`NEXT_PUBLIC_DYPAI_URL=...\` for Next.js).`
+      )
+    }
   }
+  // Surface env_file_missing as before (back-compat for older agents that
+  // gate on it). Treats `.env.local` as satisfying the requirement.
+  const envMissing = !hasUserEnv && !envWritten
 
   return {
     success: written > 0,

package/src/tools/status.js

@@ -1,94 +0,0 @@
-/**
- * Frontend status + build status tools.
- */
-
-import { api } from "../api.js"
-
-export const listDeploymentsTool = {
-  name: "list_deployments",
-  description: `List deployment history for the project's frontend. Shows recent deploys with status, commit, duration, and URL.`,
-
-  inputSchema: {
-    type: "object",
-    properties: {
-      project_id: { type: "string", description: "Project UUID." },
-      limit: { type: "number", description: "Max deployments to return (default 10, max 20)." },
-    },
-    required: ["project_id"],
-  },
-
-  async execute({ project_id, limit }) {
-    try {
-      return await api.get(`/api/engine/${project_id}/frontend/deployments?limit=${limit || 10}`)
-    } catch (e) {
-      return { error: e.message }
-    }
-  },
-}
-
-export const getDeploymentLogsTool = {
-  name: "get_deployment_logs",
-  description: `Get build logs for a specific deployment. Use list_deployments first to get the deployment ID. Useful for debugging failed builds.`,
-
-  inputSchema: {
-    type: "object",
-    properties: {
-      project_id: { type: "string", description: "Project UUID." },
-      deployment_id: { type: "string", description: "Deployment UUID from list_deployments." },
-    },
-    required: ["project_id", "deployment_id"],
-  },
-
-  async execute({ project_id, deployment_id }) {
-    try {
-      return await api.get(`/api/engine/${project_id}/frontend/deployments/${deployment_id}/logs`)
-    } catch (e) {
-      return { error: e.message }
-    }
-  },
-}
-
-export const frontendStatusTool = {
-  name: "get_frontend_status",
-  description: "Get the current frontend deployment status — URL, status, last deploy time, size.",
-
-  inputSchema: {
-    type: "object",
-    properties: {
-      project_id: { type: "string", description: "Project UUID." },
-    },
-    required: ["project_id"],
-  },
-
-  async execute({ project_id }) {
-    try {
-      return await api.get(`/api/engine/${project_id}/frontend`)
-    } catch (e) {
-      return { error: e.message }
-    }
-  },
-}
-
-export const buildStatusTool = {
-  name: "get_build_status",
-  description: `Get the latest build status from Cloudflare Pages.
-
-Returns: status (queued/building/success/failure), current stage, progress %, URL.
-Useful to check if a deploy has finished building.`,
-
-  inputSchema: {
-    type: "object",
-    properties: {
-      project_id: { type: "string", description: "Project UUID." },
-    },
-    required: ["project_id"],
-  },
-
-  async execute({ project_id }) {
-    try {
-      return await api.get(`/api/engine/${project_id}/frontend/build-status`)
-    } catch (e) {
-      return { error: e.message }
-    }
-  },
-}