@dypai-ai/mcp 1.4.2 → 1.4.3

package/package.json

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

package/src/api.js

@@ -18,11 +18,15 @@ function getConfig() {
   return {
     token: process.env.DYPAI_TOKEN || "",
     apiUrl: process.env.DYPAI_API_URL || DEFAULT_API_URL,
+    // Escape hatch for local dev against an API that doesn't have the
+    // gzip decompression middleware yet. Set DYPAI_NO_GZIP=1 to send
+    // bodies as plain JSON regardless of size.
+    noGzip: process.env.DYPAI_NO_GZIP === "1" || process.env.DYPAI_NO_GZIP === "true",
   }
 }
 
 export function request(method, path, body) {
-  const { token, apiUrl } = getConfig()
+  const { token, apiUrl, noGzip } = getConfig()
   const url = `${apiUrl}${path}`
 
   return new Promise((resolve, reject) => {
@@ -33,7 +37,7 @@ export function request(method, path, body) {
     let payload = jsonStr ? Buffer.from(jsonStr) : null
     let useGzip = false
 
-    if (payload && payload.length > GZIP_THRESHOLD) {
+    if (payload && payload.length > GZIP_THRESHOLD && !noGzip) {
       payload = gzipSync(payload)
       useGzip = true
     }

package/src/tools/deploy.js

@@ -1,22 +1,28 @@
 /**
- * deploy_frontend — delta deploy engine.
+ * deploy_frontend — full-project deploy with "skip if identical" optimization.
  *
- * Like InsForge/Vercel, uses SHA-256 hashing + a local manifest to send only
- * the files that actually changed since the last deploy. Typical second deploy
- * goes from ~30 MB to a few KB.
+ * Architecture (deliberately simple, InsForge-style):
+ *   1. Walk the project, hash every file.
+ *   2. Compute a single project-wide hash (SHA-256 of sorted path+hash pairs).
+ *   3. If this hash matches the last-deploy hash on disk → skip entirely.
+ *   4. Otherwise send ALL files to the API (full deploy, replace_all=True).
+ *   5. Poll build-status to confirm GitHub commit happened.
+ *   6. On confirmation, persist the new project hash locally.
  *
- * Manifest lives at `dypai/.dypai/deploy-manifest.json`:
- *   { "src/app/page.tsx": "a1b2c3...", "public/logo.png": "d4e5f6..." }
+ * Why not delta? A previous delta-based implementation (incremental commits,
+ * per-file manifest, deleted_paths list) generated too many edge cases:
+ *   - Manifest drift after walk-rule changes (ghost "deletions")
+ *   - Optimistic manifest updates on HTTP 202 where async commit failed
+ *   - Migration triggers on deletion-only deploys
+ * Each required a new defensive hack. The failure mode was always the same:
+ * client-side state drifted from remote truth. Full deploys make drift
+ * impossible: every deploy is a self-contained snapshot of project state.
+ * GitHub's blob dedup handles unchanged-content efficiency at the server
+ * side — we don't need to reinvent it client-side.
  *
- * Flow:
- *   1. Walk directory, hash each accepted file (SHA-256)
- *   2. Diff against manifest → new, changed, unchanged, deleted
- *   3. If nothing changed → skip deploy ("No changes detected")
- *   4. Send only new+changed files + deleted_paths to API (incremental mode)
- *   5. API commits via GitHub Trees API with base_tree (preserves unchanged)
- *   6. Update local manifest
- *
- * Files > 25 MB → surfaced in `assets_requiring_action` with upload_file cmd
+ * Trade-off: ~10s extra per deploy when only one file changed (because we
+ * send the whole project over gzip-compressed wire instead of just that
+ * file). For production reliability, that trade is the right one.
  */
 
 import { createHash } from "crypto"
@@ -33,10 +39,16 @@ const MAX_BUNDLED_FILE = 25 * 1024 * 1024
 
 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",
+  // DYPAI backend metadata — handled by dypai_pull/push, not shipped to the
+  // frontend build.
+  "dypai",
 ])
 
 // ─── Accepted file extensions ───────────────────────────────────────────────
@@ -109,33 +121,53 @@ function mediaCategory(ext) {
   return "other"
 }
 
-// ─── Deploy manifest ────────────────────────────────────────────────────────
-//
-// Tracks SHA-256 of each file at last successful deploy.
-// Path: <sourceDirectory>/dypai/.dypai/deploy-manifest.json
+// ─── Last-deploy hash (single value, no per-file tracking) ──────────────────
 //
-// Format: { "src/app/page.tsx": "a1b2c3...", ... }
+// Replaces the old per-file manifest. Stores ONE hash representing the entire
+// project state at last successful deploy. Drift is impossible: either the
+// recomputed project hash matches (skip) or it doesn't (full deploy).
 
-function manifestPath(sourceDirectory) {
+function lastDeployPath(sourceDirectory) {
   const dypaiDir = join(sourceDirectory, "dypai", ".dypai")
-  if (existsSync(join(sourceDirectory, "dypai"))) return join(dypaiDir, "deploy-manifest.json")
-  return join(sourceDirectory, ".dypai", "deploy-manifest.json")
+  if (existsSync(join(sourceDirectory, "dypai"))) return join(dypaiDir, "last-deploy.json")
+  return join(sourceDirectory, ".dypai", "last-deploy.json")
 }
 
-function readDeployManifest(sourceDirectory) {
-  const path = manifestPath(sourceDirectory)
+function readLastDeployHash(sourceDirectory) {
+  const path = lastDeployPath(sourceDirectory)
   if (!existsSync(path)) return null
-  try { return JSON.parse(readFileSync(path, "utf-8")) } catch { return null }
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8"))
+    return raw && typeof raw.hash === "string" ? raw.hash : null
+  } catch { return null }
 }
 
-function writeDeployManifest(sourceDirectory, manifest) {
-  const path = manifestPath(sourceDirectory)
+function writeLastDeployHash(sourceDirectory, hash) {
+  const path = lastDeployPath(sourceDirectory)
   const dir = dirname(path)
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
-  writeFileSync(path, JSON.stringify(manifest, null, 2) + "\n")
+  writeFileSync(path, JSON.stringify({ hash, at: new Date().toISOString() }, null, 2) + "\n")
+}
+
+/**
+ * Produce a single SHA-256 fingerprint that uniquely identifies the set of
+ * files about to be deployed. Files are sorted by path for determinism;
+ * path and per-file hash are joined with a NUL byte (which can't appear in
+ * either) to avoid any ambiguity between e.g. "foo"+"bar" and "foob"+"ar".
+ */
+function computeProjectHash(files) {
+  const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path))
+  const h = createHash("sha256")
+  for (const f of sorted) {
+    h.update(f.path)
+    h.update("\0")
+    h.update(f.hash)
+    h.update("\0")
+  }
+  return h.digest("hex")
 }
 
-// ─── Media manifest (for bucket-uploaded files) ─────────────────────────────
+// ─── Media manifest (kept — tracks bucket uploads for the upload_file tool) ─
 
 function mediaManifestPath(sourceDirectory) {
   const dypaiDir = join(sourceDirectory, "dypai", ".dypai")
@@ -188,18 +220,9 @@ function classifySkip(path, ext, size) {
   return null
 }
 
-/**
- * Walk directory. Returns:
- *   allFiles:   [{ path, content (base64), hash (sha256) }]
- *   skipped:    [{ local_path, ext, size_bytes, ... }]
- *   total:      bytes of accepted files
- *   hashMap:    { path: sha256 }
- *   textByPath: Map<path, string>
- */
 function collectSource(dir) {
   const allFiles = []
   const skipped = []
-  const hashMap = {}
   const textByPath = new Map()
   let total = 0
 
@@ -251,7 +274,6 @@ function collectSource(dir) {
 
         total += content.length
         const hash = sha256(content)
-        hashMap[path] = hash
         allFiles.push({ path, content: content.toString("base64"), hash })
 
         if (CODE_SEARCH_EXTS.has(ext)) {
@@ -262,36 +284,10 @@ function collectSource(dir) {
   }
 
   walk(dir, "")
-  return { allFiles, total, skipped, hashMap, textByPath }
-}
-
-// ─── Delta computation ──────────────────────────────────────────────────────
-
-function computeDelta(hashMap, prevManifest) {
-  if (!prevManifest) return { isFirstDeploy: true, changed: Object.keys(hashMap), deleted: [], unchanged: [] }
-
-  const changed = []
-  const unchanged = []
-  const deleted = []
-
-  for (const [path, hash] of Object.entries(hashMap)) {
-    if (prevManifest[path] === hash) {
-      unchanged.push(path)
-    } else {
-      changed.push(path)
-    }
-  }
-
-  for (const path of Object.keys(prevManifest)) {
-    if (!(path in hashMap)) {
-      deleted.push(path)
-    }
-  }
-
-  return { isFirstDeploy: false, changed, deleted, unchanged }
+  return { allFiles, total, skipped, textByPath }
 }
 
-// ─── Reference grep ─────────────────────────────────────────────────────────
+// ─── Reference grep for assets_requiring_action ─────────────────────────────
 
 function grepReferences(skipped, textByPath) {
   if (skipped.length === 0) return skipped
@@ -403,9 +399,36 @@ function detectFramework(dir) {
   } catch { return null }
 }
 
+// ─── Post-deploy confirmation ───────────────────────────────────────────────
+//
+// Polls /build-status after the API accepts the deploy. The API returns 202
+// queued immediately but the GitHub commit happens in a background task; we
+// only persist the new "last deploy" hash once the commit has clearly
+// happened (status moved past "queued"). If the background task fails, we
+// leave the hash untouched — the next deploy will re-send everything.
+
+async function confirmDeploySucceeded(project_id) {
+  const MAX_POLLS = 6
+  const INTERVAL_MS = 2000
+
+  for (let i = 0; i < MAX_POLLS; i++) {
+    await new Promise(r => setTimeout(r, INTERVAL_MS))
+    try {
+      const res = await api.get(`/api/engine/${project_id}/frontend/build-status`)
+      const status = res?.status || res?.build_status || null
+      if (status === "failed") return { confirmed: false, status, reason: "build_failed" }
+      if (status === "building" || status === "success") return { confirmed: true, status, reason: null }
+    } catch {
+      // Transient — keep polling
+    }
+  }
+  // Never left "queued" — treat as unconfirmed (safer to re-deploy next time)
+  return { confirmed: false, status: "queued", reason: "confirmation_timeout" }
+}
+
 // ─── Public entrypoint ──────────────────────────────────────────────────────
 
-export async function deployFromSource({ sourceDirectory, project_id }) {
+export async function deployFromSource({ sourceDirectory, project_id, force = false }) {
   if (!existsSync(sourceDirectory)) {
     return { error: `Directory not found: ${sourceDirectory}` }
   }
@@ -416,76 +439,58 @@ export async function deployFromSource({ sourceDirectory, project_id }) {
   _lastSourceDirectory = resolve(sourceDirectory)
 
   const framework = detectFramework(sourceDirectory)
-  const { allFiles, total, skipped, hashMap, textByPath } = collectSource(sourceDirectory)
+  const { allFiles, total, skipped, textByPath } = collectSource(sourceDirectory)
 
   if (!allFiles.length) {
     return { error: "No source files found." }
   }
 
-  // ── Delta computation ───────────────────────────────────────────────────
-  const prevManifest = readDeployManifest(sourceDirectory)
-  const delta = computeDelta(hashMap, prevManifest)
-
-  // Nothing changed at all → skip deploy entirely
-  if (!delta.isFirstDeploy && delta.changed.length === 0 && delta.deleted.length === 0) {
-    return {
-      success: true,
-      deployed: false,
-      skipped_reason: "no_changes",
-      files_total: allFiles.length,
-      message: `No changes detected since last deploy (${allFiles.length} files, all hashes match). Deploy skipped.`,
+  // ── Skip-if-identical check ─────────────────────────────────────────────
+  // One hash represents the whole project state. Same hash → nothing to do.
+  // Different hash (or no previous hash) → full deploy.
+  const projectHash = computeProjectHash(allFiles)
+
+  if (!force) {
+    const lastHash = readLastDeployHash(sourceDirectory)
+    if (lastHash && lastHash === projectHash) {
+      return {
+        success: true,
+        deployed: false,
+        skipped_reason: "no_changes",
+        files_total: allFiles.length,
+        project_hash: projectHash,
+        message: `No changes since last deploy (${allFiles.length} files match). Pass force:true to re-deploy anyway.`,
+      }
     }
   }
 
-  // ── Build payload (delta or full) ───────────────────────────────────────
-  const isIncremental = !delta.isFirstDeploy && delta.unchanged.length > 0
-  let filesToSend, payloadSize
-
-  if (isIncremental) {
-    // Only send new + changed files
-    const changedSet = new Set(delta.changed)
-    filesToSend = allFiles.filter(f => changedSet.has(f.path))
-    payloadSize = filesToSend.reduce((sum, f) => sum + Buffer.byteLength(f.content, "base64") * 0.75, 0)
-  } else {
-    filesToSend = allFiles
-    payloadSize = total
-  }
-
+  // ── Build payload (always full) ────────────────────────────────────────
   grepReferences(skipped, textByPath)
   const mediaManifest = readMediaManifest(sourceDirectory)
 
   try {
     const body = {
-      files: filesToSend.map(f => ({ path: f.path, content: f.content })),
+      files: allFiles.map(f => ({ path: f.path, content: f.content })),
       framework: framework?.id ?? null,
     }
 
-    // Signal incremental mode to the API
-    if (isIncremental) {
-      body.incremental = true
-      if (delta.deleted.length > 0) {
-        body.deleted_paths = delta.deleted
-      }
-    }
-
     const result = await api.post(
       `/api/engine/${project_id}/frontend/deploy/source`,
       body,
     )
 
-    // ── Update manifest on success ──────────────────────────────────────
-    writeDeployManifest(sourceDirectory, hashMap)
+    // ── Confirm the background task actually committed ──────────────────
+    const confirmation = await confirmDeploySucceeded(project_id)
+    if (confirmation.confirmed) {
+      writeLastDeployHash(sourceDirectory, projectHash)
+    }
 
     const label = framework?.label ?? "Project"
     const assetsAction = buildAssetsRequiringAction(skipped, mediaManifest, project_id)
     const hasUnresolvedAssets = assetsAction && assetsAction.count > 0
 
-    const deltaInfo = isIncremental
-      ? `Delta deploy: ${delta.changed.length} changed, ${delta.deleted.length} deleted, ${delta.unchanged.length} unchanged (sent ${formatBytes(payloadSize)} instead of ${formatBytes(total)})`
-      : `Full deploy: ${allFiles.length} files (${formatBytes(total)})`
-
     const baseMessage =
-      `Deploy accepted — ${deltaInfo}. ` +
+      `Deploy accepted — ${allFiles.length} files (${formatBytes(total)}). ` +
       `Build running (${label}, ~20-60s). Poll manage_frontend({operation:"build_status"}) every ~5s.`
 
     let message = baseMessage
@@ -498,20 +503,12 @@ export async function deployFromSource({ sourceDirectory, project_id }) {
       deployed: false,
       url: result.url,
       framework: label,
-      build_status: "queued",
-
-      // Delta stats — shows the agent (and user) how much we saved
-      delta: {
-        mode: isIncremental ? "incremental" : "full",
-        files_sent: filesToSend.length,
-        files_total: allFiles.length,
-        files_changed: delta.changed.length,
-        files_deleted: delta.deleted.length,
-        files_unchanged: delta.unchanged.length,
-        bytes_sent: Math.round(payloadSize),
-        bytes_total: total,
-        savings: isIncremental ? `${Math.round((1 - payloadSize / total) * 100)}%` : "0% (first deploy)",
-      },
+      build_status: confirmation.status || "queued",
+      files_total: allFiles.length,
+      bytes_total: total,
+      project_hash: projectHash,
+      last_deploy_hash_updated: confirmation.confirmed,
+      ...(confirmation.reason ? { confirmation_warning: confirmation.reason } : {}),
 
       ...(hasUnresolvedAssets ? { assets_requiring_action: assetsAction } : {}),
       ...(assetsAction?.all_synced ? { assets_synced: assetsAction.already_in_bucket } : {}),
@@ -522,7 +519,7 @@ export async function deployFromSource({ sourceDirectory, project_id }) {
             priority_order: [
               "1. Execute each suggested_action in assets_requiring_action.files.",
               "2. Edit source files to use the returned URL.",
-              "3. Re-deploy. Delta deploy will only send the edited files.",
+              "3. Re-deploy.",
               "4. Poll build_status until terminal.",
             ],
             terminal_statuses: ["success", "failure"],

package/src/tools/frontend.js

@@ -60,6 +60,11 @@ export const manageFrontendTool = {
         description: "sync only. When true, allows writing into a directory that already has a project. Local-only files (.env, node_modules, etc.) are NOT touched. Default: false.",
         default: false,
       },
+      force: {
+        type: "boolean",
+        description: "deploy only. Bypass the delta manifest and re-send ALL files (full deploy). Use when the previous deploy's remote build FAILED — the manifest says 'synced' but the remote never built, so a normal delta incorrectly reports no_changes. Default: false.",
+        default: false,
+      },
       deployment_id: {
         type: "string",
         description: "logs only. Deployment UUID obtained from list_deployments.",
@@ -72,7 +77,7 @@ export const manageFrontendTool = {
     required: ["operation"],
   },
 
-  async execute({ operation, project_id, sourceDirectory, targetDirectory, overwrite, deployment_id, limit } = {}) {
+  async execute({ operation, project_id, sourceDirectory, targetDirectory, overwrite, force, deployment_id, limit } = {}) {
     if (!operation) {
       return { success: false, error: "operation is required (deploy | sync | status | build_status | list_deployments | logs)." }
     }
@@ -86,7 +91,7 @@ export const manageFrontendTool = {
           if (!sourceDirectory) {
             return { success: false, error: "operation 'deploy' requires 'sourceDirectory' (absolute path to your frontend project root)." }
           }
-          return await deployFromSource({ sourceDirectory, project_id })
+          return await deployFromSource({ sourceDirectory, project_id, force: !!force })
 
         case "sync":
           if (!targetDirectory) {

package/src/tools/sync.js

@@ -92,22 +92,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.