@dypai-ai/mcp 1.7.8 → 1.7.9

package/package.json

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

package/src/tools/sync/push.js

@@ -223,6 +223,69 @@ async function refreshBackendSourceBaseline(projectId, rootDir, sourceCheckpoint
   }
 }
 
+async function readComputePolicy(rootDir) {
+  try {
+    const raw = await readFile(join(rootDir, "compute.json"), "utf8")
+    const parsed = JSON.parse(raw)
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("dypai/compute.json must contain an object")
+    }
+    return parsed
+  } catch (error) {
+    if (error?.code === "ENOENT") return null
+    if (error instanceof SyntaxError) {
+      throw new Error("dypai/compute.json is not valid JSON")
+    }
+    throw error
+  }
+}
+
+async function prepareEndpointPayloadsForCompute(projectId, rootDir, names, local, mapsCtx) {
+  if (!names.length) {
+    return { ok: true, payloadsByName: {}, compute: { artifacts: 0, uploaded: 0, registered: 0 } }
+  }
+  const payloads = names.map((name) => {
+    const entry = local.byName[name]
+    if (!entry) throw new Error(`Compute preparation is missing local endpoint '${name}'`)
+    return localToCanonical(entry, mapsCtx)
+  })
+  const computePolicy = await readComputePolicy(rootDir)
+  const result = await api.post(
+    `/api/engine/${projectId}/backend/snapshot/prepare-push-payloads`,
+    {
+      payloads,
+      ...(computePolicy ? { compute_policy: computePolicy } : {}),
+    },
+  )
+  if (!result || result.ok !== true || !Array.isArray(result.payloads)) {
+    throw new Error("Core API returned an invalid Compute preparation response")
+  }
+  const payloadsByName = {}
+  for (const payload of result.payloads) {
+    const name = typeof payload?.name === "string" ? payload.name : ""
+    if (!name || payloadsByName[name]) {
+      throw new Error("Core API returned duplicate or unnamed Compute payloads")
+    }
+    payloadsByName[name] = payload
+  }
+  const missing = names.filter((name) => !payloadsByName[name])
+  if (missing.length) {
+    throw new Error(`Core API omitted Compute payloads: ${missing.slice(0, 5).join(", ")}`)
+  }
+  return { ok: true, payloadsByName, compute: result.compute || {} }
+}
+
+function canonicalPreparedEndpoint(name, local, preparedByName, mapsCtx) {
+  const prepared = preparedByName[name]
+  if (!prepared) return localToCanonical(local.byName[name], mapsCtx)
+  const entry = local.byName[name]
+  return localToCanonical({
+    source: "flow",
+    group: entry?.group || prepared.group_name || null,
+    pushPayload: prepared,
+  }, mapsCtx)
+}
+
 /**
  * Run an async worker over an array with bounded concurrency. Workers never
  * throw (they handle their own errors via the push errors[] accumulator),
@@ -947,6 +1010,33 @@ export const dypaiPushTool = {
     // pushing 50 endpoints doesn't take 50 * 200ms = 10s — drops to ~2s.
     // Group operations are sequential because they're fast (a handful of
     // groups typically) and we need mapsCtx mutations to be race-free.
+    const endpointNamesToWrite = [...new Set([
+      ...plan.create.map((item) => item.name),
+      ...plan.update.map((item) => item.name),
+    ])]
+    let computePreparation
+    try {
+      computePreparation = await prepareEndpointPayloadsForCompute(
+        targetProjectId,
+        rootDir,
+        endpointNamesToWrite,
+        local,
+        remote.mapsCtx,
+      )
+    } catch (error) {
+      return {
+        success: false,
+        applied: false,
+        phase: "prepare_compute",
+        error: error?.body?.detail?.message
+          || error?.detail?.message
+          || error?.detail
+          || error?.message
+          || String(error),
+        hint: "No backend drafts were written. Update/retry after the Compute preparation path is healthy.",
+      }
+    }
+    const preparedByName = computePreparation.payloadsByName
     const CONCURRENCY = PUSH_CONCURRENCY
     // `applied.*_drafts` tracks the per-op subset that the API staged as
     // drafts (default behavior). The lists in `created/updated/deleted`
@@ -974,7 +1064,7 @@ export const dypaiPushTool = {
 
     await runWithConcurrency(plan.create, CONCURRENCY, async (item) => {
       try {
-        const canonical = localToCanonical(local.byName[item.name], remote.mapsCtx)
+        const canonical = canonicalPreparedEndpoint(item.name, local, preparedByName, remote.mapsCtx)
         const res = await applyCreate(canonical, targetProjectId)
         applied.created.push(item.name)
         if (isDraftResponse(res)) applied.created_drafts.push(item.name)
@@ -989,7 +1079,7 @@ export const dypaiPushTool = {
 
     await runWithConcurrency(plan.update, CONCURRENCY, async (item) => {
       try {
-        const canonical = localToCanonical(local.byName[item.name], remote.mapsCtx)
+        const canonical = canonicalPreparedEndpoint(item.name, local, preparedByName, remote.mapsCtx)
         const endpointId = remote.byName[item.name]?.id
         const res = endpointId
           ? await applyUpdate(canonical, endpointId, targetProjectId, remote.byName[item.name]?.revision)
@@ -1139,6 +1229,7 @@ export const dypaiPushTool = {
       non_blocking_conflicts: conflictSplit.non_blocking.length ? conflictSplit.non_blocking : undefined,
       errors: errors.length ? errors : undefined,
       types: typesGenerated,
+      compute: computePreparation.compute,
       automation_sync: automationSync,
       source_checkpoint: sourceCheckpoint,
       source_baseline: sourceBaseline,
@@ -1199,5 +1290,8 @@ export const __testing = {
   normalizeEndpointSelection,
   scopePlanToEndpoints,
   backendSourcePathsForEndpointSelection,
+  readComputePolicy,
+  prepareEndpointPayloadsForCompute,
+  canonicalPreparedEndpoint,
   PUSH_CONCURRENCY,
 }