@dypai-ai/mcp 1.7.3 → 1.7.5

package/package.json

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

package/src/lib/cloudBackendCompiler.js

@@ -23,7 +23,10 @@ async function compileSnapshot(projectId, command, files, endpoint = undefined)
     files,
   }
   if (endpoint) args.endpoint = endpoint
-  return proxyToolCall("backend_compile_snapshot", args)
+  // Compiler `ok:false` is a domain validation result, not a transport/tool
+  // failure. It intentionally carries valid payloads plus diagnostics so the
+  // push pipeline can skip only broken flows instead of dropping all source.
+  return proxyToolCall("backend_compile_snapshot", args, { allowFailureResult: true })
 }
 
 export async function buildSnapshotPayload(dypaiRootDir, projectRoot = null) {

package/src/tools/proxy.js

@@ -209,7 +209,15 @@ async function ensureInitialized() {
   return initPromise
 }
 
-export async function proxyToolCall(toolName, args) {
+function shouldPromoteRemoteFailure(parsed, allowFailureResult = false) {
+  return !allowFailureResult
+    && parsed
+    && typeof parsed === "object"
+    && !Array.isArray(parsed)
+    && (parsed.success === false || parsed.ok === false)
+}
+
+export async function proxyToolCall(toolName, args, { allowFailureResult = false } = {}) {
   async function callOnce() {
     await ensureInitialized()
 
@@ -242,11 +250,9 @@ export async function proxyToolCall(toolName, args) {
         // Other remote errors come as a JSON object with success:false but no isError
         // flag. The push pipeline was treating these as successes — promote them to
         // throws here so the caller's try/catch sees them.
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-          if (parsed.success === false || parsed.ok === false) {
-            const msg = parsed.error || parsed.message || parsed.detail || JSON.stringify(parsed).slice(0, 300)
-            throw new Error(typeof msg === "string" ? msg : JSON.stringify(msg))
-          }
+        if (shouldPromoteRemoteFailure(parsed, allowFailureResult)) {
+          const msg = parsed.error || parsed.message || parsed.detail || JSON.stringify(parsed).slice(0, 300)
+          throw new Error(typeof msg === "string" ? msg : JSON.stringify(msg))
         }
         return parsed
       }
@@ -270,3 +276,7 @@ export async function proxyToolCall(toolName, args) {
     throw error
   }
 }
+
+export const __testing = {
+  shouldPromoteRemoteFailure,
+}

package/src/tools/sync/planner.js

@@ -539,15 +539,6 @@ export async function readLocalEffectiveState(rootDir, projectId = null, deps =
     if (shadowedMeta) shadowed.push({ name: payload.name, shadowed: shadowedMeta })
   }
 
-  for (const diagnostic of diagnostics) {
-    if (diagnostic?.severity !== "error") continue
-    yamlState.errors.push({
-      file: diagnostic.file || diagnostic.endpoint,
-      error: diagnostic.message || "Failed to build flow push payload",
-      rule: diagnostic.rule || "flow_push_payload_failed",
-    })
-  }
-
   for (const item of rejected) {
     if (!isBackendSourcePath(item?.path)) continue
     yamlState.errors.push({
@@ -562,7 +553,14 @@ export async function readLocalEffectiveState(rootDir, projectId = null, deps =
     byName[name] = { ...entry, source: "legacy-yaml" }
   }
 
-  return { byName, errors: yamlState.errors, shadowed, runnerWarning: null, automations: bulkResult.data?.automations ?? null }
+  return {
+    byName,
+    errors: yamlState.errors,
+    shadowed,
+    runnerWarning: null,
+    compilerDiagnostics: diagnostics,
+    automations: bulkResult.data?.automations ?? null,
+  }
 }
 
 // ─── Normalization + diff ──────────────────────────────────────────────────
@@ -664,6 +662,39 @@ function localToComparable(entry, mapsCtx) {
   return remoteToComparable(row, mapsCtx)
 }
 
+export function flowSourceHashesMatch(entry, remoteRow) {
+  if (entry?.source !== "flow" || !entry.pushPayload || !remoteRow) return false
+  const localHash = entry.pushPayload.workflow_code?.metadata?.source_hash
+  const remoteHash = remoteRow.workflow_code?.metadata?.source_hash
+  return typeof localHash === "string"
+    && localHash.length > 0
+    && localHash === remoteHash
+}
+
+export function preserveMatchingRemoteFileRefs(rawLocalDoc, localComparable, remoteComparable) {
+  if (!rawLocalDoc || !localComparable || !remoteComparable) return localComparable
+  if (Array.isArray(rawLocalDoc)) {
+    if (!Array.isArray(localComparable) || !Array.isArray(remoteComparable)) return localComparable
+    rawLocalDoc.forEach((item, index) => {
+      preserveMatchingRemoteFileRefs(item, localComparable[index], remoteComparable[index])
+    })
+    return localComparable
+  }
+  if (typeof rawLocalDoc !== "object" || Array.isArray(localComparable) || Array.isArray(remoteComparable)) {
+    return localComparable
+  }
+
+  for (const [key, value] of Object.entries(rawLocalDoc)) {
+    if (key.endsWith("_file") && typeof value === "string" && remoteComparable[key] === value) {
+      delete localComparable[key.replace(/_file$/, "")]
+      localComparable[key] = value
+      continue
+    }
+    preserveMatchingRemoteFileRefs(value, localComparable[key], remoteComparable[key])
+  }
+  return localComparable
+}
+
 function deepEqual(a, b) {
   if (a === b) return true
   if (typeof a !== typeof b) return false
@@ -771,6 +802,7 @@ export function detectConflicts(stateSnapshot, remoteByName) {
 export function computePlan(local, remote, mapsCtx, { deleteOrphans = false, stateSnapshot = null, liveRemote = null } = {}) {
   const plan = { create: [], update: [], delete: [], unchanged: [] }
   const warnings = []
+  const compilerOnlyDrift = []
 
   const endpointNameCollisions = findEndpointNameCollisions(Object.keys(remote?.byName || {}))
   if (endpointNameCollisions.length) {
@@ -824,6 +856,19 @@ export function computePlan(local, remote, mapsCtx, { deleteOrphans = false, sta
     }
 
     const remoteCanonical = remoteToComparable(remoteRow, mapsCtx)
+    if (entry.doc) {
+      preserveMatchingRemoteFileRefs(entry.doc, localCanonical, remoteCanonical)
+    }
+    if (
+      flowSourceHashesMatch(entry, remoteRow)
+      && !deepEqual(localCanonical.workflow, remoteCanonical.workflow)
+    ) {
+      // Same authored source, different compiler artifact (for example after
+      // a compiler upgrade). Keep comparing roles/contracts/description, but
+      // do not stage a mass endpoint update solely to rewrite generated IR.
+      localCanonical.workflow = remoteCanonical.workflow
+      compilerOnlyDrift.push(name)
+    }
     if (deepEqual(localCanonical, remoteCanonical)) {
       plan.unchanged.push(name)
     } else {
@@ -832,6 +877,16 @@ export function computePlan(local, remote, mapsCtx, { deleteOrphans = false, sta
     }
   }
 
+  if (compilerOnlyDrift.length) {
+    warnings.push({
+      type: "compiler_artifact_drift_ignored",
+      count: compilerOnlyDrift.length,
+      examples: compilerOnlyDrift.slice(0, 25),
+      truncated: compilerOnlyDrift.length > 25,
+      hint: "Authored Flow source_hash matches live. Generated workflow differences from a compiler upgrade were not staged.",
+    })
+  }
+
   if (deleteOrphans) {
     for (const name of Object.keys(remote.byName)) {
       if (!local.byName[name]) plan.delete.push({ name })

package/src/tools/sync/pull.js

@@ -761,10 +761,15 @@ export const dypaiPullTool = {
         description: "If true, removes existing endpoints/, sql/, prompts/ before writing and allows persisted Flow source to overwrite differing local .flow.ts files.",
         default: false,
       },
+      live_authoritative: {
+        type: "boolean",
+        description: "Recovery mode. Export every live workflow as legacy YAML instead of trusting persisted Flow/Automation source. Use only when live is intentionally authoritative and source has drifted.",
+        default: false,
+      },
     },
   },
 
-  async execute({ project_id, out_dir = "./dypai", clean = false } = {}) {
+  async execute({ project_id, out_dir = "./dypai", clean = false, live_authoritative = false } = {}) {
     const { path: outDir, source: outDirSource } = resolveOutDir(out_dir)
     const suspiciousWarning = suspiciousPathWarning(outDir, outDirSource)
 
@@ -864,6 +869,7 @@ export const dypaiPullTool = {
 
     const filesWritten = []
     const errors = []
+    const sourceRecoveryWarnings = []
 
     const capabilityGroups = capabilityCatalogResult?.groups || []
     const capabilityDoc = {
@@ -939,7 +945,7 @@ export const dypaiPullTool = {
       row.workflow_source = parseMaybeJson(row.workflow_source)
       try {
         const workflowSource = row.workflow_source
-        if (isEditableTsSource(workflowSource)) {
+        if (isEditableTsSource(workflowSource) && !live_authoritative) {
           const groupName = row.group_id ? (mapsCtx.groupIdToName[row.group_id] || null) : null
           const sourceFile = normalizeEditableSourceFile(workflowSource, row.name)
           const relFlowPath = flowSourceRelPath(sourceFile)
@@ -985,18 +991,30 @@ export const dypaiPullTool = {
             continue
           }
 
-          const relPath = groupName
-            ? `endpoints/${groupName}/${row.name}.yaml.disabled`
-            : `endpoints/${row.name}.yaml.disabled`
-          await writeFileEnsured(join(outDir, relPath), renderMissingFlowStub(row, sourceFile, persistedFlowSources))
-          filesWritten.push(relPath)
-          errors.push({
+          // The editable TS source has been lost, but live still contains the
+          // complete executable workflow. Recover it as legacy YAML so a live
+          // repair pull remains complete and its state baseline stays honest.
+          // The warning makes the source loss visible without dropping the
+          // endpoint from disk or producing a false clean dry-run.
+          sourceRecoveryWarnings.push({
             endpoint: row.name,
-            error:
+            source_file: sourceFile,
+            recovered_as: "legacy_yaml",
+            warning:
               `Endpoint is source-authored but ${sourceFile} was not found in persisted project source. ` +
-              `Restore/sync the editable TypeScript source, then rerun dypai_pull.`,
+              "Recovered the live workflow as legacy YAML; restore editable TypeScript later if desired.",
           })
-          continue
+          row.workflow_source = null
+        }
+
+        if (isEditableTsSource(workflowSource) && live_authoritative) {
+          sourceRecoveryWarnings.push({
+            endpoint: row.name,
+            source_file: normalizeEditableSourceFile(workflowSource, row.name),
+            recovered_as: "legacy_yaml",
+            warning: "Live-authoritative recovery exported the executable workflow as legacy YAML. The previous editable TypeScript source remains available in the backup/history.",
+          })
+          row.workflow_source = null
         }
 
         const { doc, extractedFiles } = serializeEndpoint(row, mapsCtx)
@@ -1191,12 +1209,26 @@ export const dypaiPullTool = {
           : ["Read dypai/schema.sql before writing queries.", "Edit Flow in dypai/flows/, Automations in dypai/automations/, or legacy YAML in dypai/endpoints/, then dypai_diff → dypai_push."],
     }
 
+    const safetyWarnings = [
+      ...(endpointNameCollisions.length ? [{
+        type: "canonical_endpoint_name_collisions",
+        count: endpointNameCollisions.length,
+        examples: endpointNameCollisions.slice(0, 10),
+        hint: "Legacy underscore and canonical hyphen slugs coexist. Treat them as separate live APIs; audit traffic and migrate/delete deliberately.",
+      }] : []),
+      ...sourceRecoveryWarnings.map((item) => ({
+        type: "missing_editable_source_recovered",
+        ...item,
+      })),
+    ]
+
     return {
       success: errors.length === 0,
       endpoints: endpoints.length,
       files_written: filesWritten.length,
       files_kept_local: keptLocalEndpoints.length,
       kept_local_endpoints: keptLocalEndpoints.length ? keptLocalEndpoints : undefined,
+      source_recovery_warnings: sourceRecoveryWarnings.length ? sourceRecoveryWarnings : undefined,
       name_collisions: endpointNameCollisions.length,
       output_dir: outDir,
       out_dir_resolved_via: outDirSource,
@@ -1206,12 +1238,7 @@ export const dypaiPullTool = {
       overview,
       errors: errors.length ? errors : undefined,
       warning: suspiciousWarning || undefined,
-      safety_warnings: endpointNameCollisions.length ? [{
-        type: "canonical_endpoint_name_collisions",
-        count: endpointNameCollisions.length,
-        examples: endpointNameCollisions.slice(0, 10),
-        hint: "Legacy underscore and canonical hyphen slugs coexist. Treat them as separate live APIs; audit traffic and migrate/delete deliberately.",
-      }] : undefined,
+      safety_warnings: safetyWarnings.length ? safetyWarnings : undefined,
       hint: errors.length
         ? keptLocalEndpoints.length
           ? `${keptLocalEndpoints.length} local Flow file(s) differed and were kept. They were excluded from .dypai/state.json, so a later push will continue to block on remote drift. Review the files or rerun with clean:true only when remote is intentionally authoritative.`

package/src/tools/sync/push.js

@@ -310,6 +310,41 @@ function dropErroringFromPlan(plan, erroringEndpoints, skippedDiagnostics) {
     : undefined
 }
 
+function skippedEndpointsFromDiagnostics(diagnostics) {
+  const names = [...new Set(
+    (diagnostics || [])
+      .filter((item) => item?.severity === "error" && item.endpoint)
+      .map((item) => item.endpoint),
+  )]
+  return names.length
+    ? names.map((name) => ({
+        endpoint: name,
+        errors: diagnostics
+          .filter((item) => item.endpoint === name && item.severity === "error")
+          .slice(0, 5)
+          .map((item) => ({
+            rule: item.rule,
+            message: item.message,
+            file: item.file,
+            loc: item.loc,
+          })),
+      }))
+    : undefined
+}
+
+function mergeSkippedEndpointSummaries(...groups) {
+  const merged = new Map()
+  for (const group of groups) {
+    for (const item of group || []) {
+      const current = merged.get(item.endpoint)
+      merged.set(item.endpoint, current
+        ? { ...current, errors: [...(current.errors || []), ...(item.errors || [])].slice(0, 5) }
+        : item)
+    }
+  }
+  return merged.size ? [...merged.values()] : undefined
+}
+
 function splitBlockingConflicts(plan, conflicts) {
   const touched = new Set([
     ...(plan.update || []).map((item) => item.name),
@@ -741,6 +776,20 @@ export const dypaiPushTool = {
         error: e.message,
       }
     }
+    const compilerValidation = partitionValidationErrors(local.compilerDiagnostics)
+    if (compilerValidation.projectLevel.length) {
+      return {
+        success: false,
+        applied: false,
+        reason: "compiler_validation_failed",
+        diagnostics: compilerValidation.projectLevel.slice(0, 20),
+        hint: "The compiler reported project-level errors that cannot be isolated to one endpoint.",
+      }
+    }
+    for (const endpoint of compilerValidation.erroringEndpoints) {
+      erroringEndpoints.add(endpoint)
+    }
+    skippedDiagnostics.push(...compilerValidation.errorDiags)
     try {
       remote = await fetchRemoteState(targetProjectId)
     } catch (e) {
@@ -817,7 +866,10 @@ export const dypaiPushTool = {
     // they aren't pushed (they keep their live version). Deletes stay — a broken
     // local flow shouldn't block removing endpoints. skip_validation leaves
     // erroringEndpoints empty, so nothing is dropped.
-    const skipped_endpoints = dropErroringFromPlan(plan, erroringEndpoints, skippedDiagnostics)
+    const skipped_endpoints = mergeSkippedEndpointSummaries(
+      dropErroringFromPlan(plan, erroringEndpoints, skippedDiagnostics),
+      skippedEndpointsFromDiagnostics(compilerValidation.errorDiags),
+    )
 
     const groupChanges = (plan.groups?.create?.length || 0) + (plan.groups?.delete?.length || 0)
     const totalChanges = plan.create.length + plan.update.length + plan.delete.length + groupChanges
@@ -830,8 +882,13 @@ export const dypaiPushTool = {
         success: false,
         applied: false,
         reason: "conflicts_detected",
+        summary: summaryFromPlan(plan),
         conflicts: conflictSplit.blocking,
         non_blocking_conflicts: conflictSplit.non_blocking.length ? conflictSplit.non_blocking : undefined,
+        skipped_endpoints,
+        compiler_diagnostics: local.compilerDiagnostics?.length
+          ? local.compilerDiagnostics.slice(0, 50)
+          : undefined,
         hint: "Remote changes overlap endpoints this push would update/delete. Run dypai_pull to refresh local state, resolve the overlap, then push again. To override, pass force=true.",
       }
     }
@@ -861,6 +918,9 @@ export const dypaiPushTool = {
             : totalChanges === 0 ? "no_changes" : "dry_run",
         summary: summaryFromPlan(plan),
         skipped_endpoints,
+        compiler_diagnostics: local.compilerDiagnostics?.length
+          ? local.compilerDiagnostics.slice(0, 50)
+          : undefined,
         plan,
         non_blocking_conflicts: conflictSplit.non_blocking.length ? conflictSplit.non_blocking : undefined,
         types: typesGenerated,
@@ -1073,6 +1133,9 @@ export const dypaiPushTool = {
       details: applied,
       endpoint_results,
       skipped_endpoints,
+      compiler_diagnostics: local.compilerDiagnostics?.length
+        ? local.compilerDiagnostics.slice(0, 50)
+        : undefined,
       non_blocking_conflicts: conflictSplit.non_blocking.length ? conflictSplit.non_blocking : undefined,
       errors: errors.length ? errors : undefined,
       types: typesGenerated,
@@ -1131,6 +1194,8 @@ export const __testing = {
   syncAutomationMetadata,
   partitionValidationErrors,
   dropErroringFromPlan,
+  skippedEndpointsFromDiagnostics,
+  mergeSkippedEndpointSummaries,
   normalizeEndpointSelection,
   scopePlanToEndpoints,
   backendSourcePathsForEndpointSelection,