@dypai-ai/mcp 1.7.8 → 1.7.10

package/package.json

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

package/src/tools/sync/describe.js

@@ -10,6 +10,7 @@
  */
 
 import { proxyToolCall } from "../proxy.js"
+import { fetchRemoteCredentials } from "./remote-metadata.js"
 
 async function execSql(projectId, sql) {
   // Bypass remote execute_sql auto-LIMIT 20 so describe counts match reality.
@@ -59,7 +60,7 @@ export const dypaiDescribeTool = {
         LEFT JOIN system.endpoints_group g ON g.id = e.group_id
         ORDER BY e.name
       `),
-      execSql(project_id, "SELECT name, type FROM system.credentials ORDER BY name"),
+      fetchRemoteCredentials(project_id).catch(() => null),
       execSql(project_id, "SELECT name, description FROM system.roles ORDER BY name"),
       execSql(project_id, `
         SELECT id, name, public FROM storage.buckets ORDER BY name

package/src/tools/sync/planner.js

@@ -17,6 +17,7 @@ import {
   runEffectiveWorkflows,
 } from "../../lib/effective-workflows-runner.js"
 import { findEndpointNameCollisions } from "./endpoint-names.js"
+import { fetchRemoteCredentials } from "./remote-metadata.js"
 
 const ENDPOINT_NAME_RE = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/
 
@@ -195,7 +196,7 @@ export async function fetchRemoteState(projectId) {
       FROM system.endpoints
       ORDER BY name
     `)
-  const credentials = await execSql(projectId, "SELECT id, name, type FROM system.credentials")
+  const credentials = await fetchRemoteCredentials(projectId)
   const groups = await execSql(projectId, "SELECT id, name FROM system.endpoints_group")
 
   const mapsCtx = {

package/src/tools/sync/pull.js

@@ -22,6 +22,7 @@ import { api } from "../../api.js"
 import { serializeEndpoint } from "./codec.js"
 import { dumpPublicSchema } from "./schema-dump.js"
 import { findEndpointNameCollisions, findLegacyAliasEndpointNames } from "./endpoint-names.js"
+import { fetchRemoteCredentials } from "./remote-metadata.js"
 // Codegen was removed from v1 — the agent reads dypai/schema.sql + endpoint YAMLs
 // directly instead of relying on auto-generated TS types. The codegen.js file
 // still lives on disk in case we resurface it later with a leaner design.
@@ -817,7 +818,7 @@ export const dypaiPullTool = {
         FROM system.endpoints
         ORDER BY name
       `),
-      execSql(project_id, "SELECT id, name, type FROM system.credentials"),
+      fetchRemoteCredentials(project_id),
       execSql(project_id, "SELECT id, name FROM system.endpoints_group"),
       dumpPublicSchema(project_id),
       // Dump the global node catalog (central control plane) in one call.

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,
 }

package/src/tools/sync/remote-metadata.js

@@ -0,0 +1,40 @@
+import { proxyToolCall } from "../proxy.js"
+
+const CREDENTIAL_PAGE_SIZE = 50
+
+/**
+ * Read credential metadata through the dedicated, secret-safe MCP tool.
+ *
+ * `execute_sql` intentionally rejects system.credentials because that table
+ * also stores encrypted secret material. Sync only needs id/name/type, which
+ * get_app_credentials exposes without returning any secret values.
+ */
+export async function fetchRemoteCredentials(
+  projectId,
+  { call = proxyToolCall, pageSize = CREDENTIAL_PAGE_SIZE } = {},
+) {
+  const credentials = []
+  let offset = 0
+
+  while (true) {
+    const args = { limit: pageSize, offset }
+    if (projectId) args.project_id = projectId
+
+    const result = await call("get_app_credentials", args)
+    const page = Array.isArray(result?.credentials) ? result.credentials : []
+    credentials.push(...page)
+
+    const total = Number(result?.total)
+    if (
+      page.length === 0
+      || page.length < pageSize
+      || (Number.isFinite(total) && credentials.length >= total)
+    ) {
+      return credentials
+    }
+
+    offset += page.length
+  }
+}
+
+export const __testing = { CREDENTIAL_PAGE_SIZE }