@dypai-ai/mcp 1.7.2 → 1.7.4

package/src/tools/sync/push.js

@@ -81,14 +81,16 @@ function isCheckpointTextPath(path) {
   return BACKEND_SOURCE_CHECKPOINT_EXTS.has(extOfPath(path))
 }
 
-async function collectBackendSourceCheckpointFiles(rootDir) {
+async function collectBackendSourceCheckpointFiles(rootDir, allowedPaths = null) {
   const files = []
 
   async function addFile(absPath, relPath) {
+    const sourcePath = `dypai/${relPath}`
+    if (allowedPaths && !allowedPaths.has(sourcePath)) return
     if (!isCheckpointTextPath(relPath)) return
     const content = await readFile(absPath, "utf8")
     files.push({
-      path: `dypai/${relPath}`,
+      path: sourcePath,
       content: Buffer.from(content, "utf8").toString("base64"),
     })
   }
@@ -165,7 +167,7 @@ function deletedBackendSourcePathsFromPlan(plan, remote) {
   return [...deleted].sort()
 }
 
-async function checkpointBackendSource(projectId, rootDir, plan, remote) {
+async function checkpointBackendSource(projectId, rootDir, plan, remote, allowedPaths = null) {
   if (!projectId) {
     return {
       ok: false,
@@ -173,7 +175,7 @@ async function checkpointBackendSource(projectId, rootDir, plan, remote) {
       reason: "project_id_missing",
     }
   }
-  const files = await collectBackendSourceCheckpointFiles(rootDir)
+  const files = await collectBackendSourceCheckpointFiles(rootDir, allowedPaths)
   const deleted_paths = deletedBackendSourcePathsFromPlan(plan, remote)
   if (!files.length && !deleted_paths.length) {
     return {
@@ -264,6 +266,85 @@ function endpointPayload(row) {
   return p
 }
 
+/**
+ * Splits the "error" severity diagnostics from a `dypai_validate` run into
+ * project-level errors (no `.endpoint` — can't be scoped, must block the
+ * whole push) vs. per-endpoint errors (can be isolated so the rest of the
+ * push still goes through). Returns everything the caller needs to decide
+ * whether to block or to do a partial push.
+ */
+function partitionValidationErrors(diagnostics) {
+  const errorDiags = (diagnostics || []).filter((d) => d.severity === "error")
+  const projectLevel = errorDiags.filter((d) => !d.endpoint)
+  const erroringEndpoints = new Set(errorDiags.map((d) => d.endpoint).filter(Boolean))
+  return { errorDiags, projectLevel, erroringEndpoints }
+}
+
+/**
+ * Partial push: drops any `plan.create`/`plan.update` item whose endpoint
+ * name is in `erroringEndpoints` (mutates `plan` in place, matching the
+ * previous inline behavior) so it keeps its live version instead of being
+ * pushed. `plan.delete` is left untouched — a broken local flow shouldn't
+ * block removing an endpoint. Returns the `skipped_endpoints` summary (with
+ * up to 5 errors per endpoint drawn from `skippedDiagnostics`), or
+ * `undefined` when nothing was dropped.
+ */
+function dropErroringFromPlan(plan, erroringEndpoints, skippedDiagnostics) {
+  const skippedNames = []
+  if (erroringEndpoints.size) {
+    const drop = (arr) => (arr || []).filter((item) => {
+      if (erroringEndpoints.has(item.name)) { skippedNames.push(item.name); return false }
+      return true
+    })
+    plan.create = drop(plan.create)
+    plan.update = drop(plan.update)
+  }
+  return skippedNames.length
+    ? [...new Set(skippedNames)].map((name) => ({
+        endpoint: name,
+        errors: skippedDiagnostics
+          .filter((d) => d.endpoint === name)
+          .slice(0, 5)
+          .map((d) => ({ rule: d.rule, message: d.message, file: d.file, loc: d.loc })),
+      }))
+    : 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),
@@ -278,6 +359,68 @@ function splitBlockingConflicts(plan, conflicts) {
   return { blocking, non_blocking }
 }
 
+function normalizeEndpointSelection(value) {
+  if (value == null) return null
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("only_endpoints must be a non-empty array of endpoint slugs")
+  }
+  const names = [...new Set(value.map((item) => typeof item === "string" ? item.trim() : ""))]
+  const invalid = names.filter((name) => !/^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/.test(name))
+  if (invalid.length) {
+    throw new Error(`only_endpoints contains invalid endpoint slug(s): ${invalid.join(", ")}`)
+  }
+  return names.sort()
+}
+
+function scopePlanToEndpoints(plan, selectedNames, local) {
+  if (!selectedNames) return plan
+  const selected = new Set(selectedNames)
+  const keepItem = (item) => selected.has(typeof item === "string" ? item : item?.name)
+
+  plan.create = (plan.create || []).filter(keepItem)
+  plan.update = (plan.update || []).filter(keepItem)
+  plan.delete = (plan.delete || []).filter(keepItem)
+  plan.unchanged = (plan.unchanged || []).filter(keepItem)
+  plan.orphansIgnored = (plan.orphansIgnored || []).filter((name) => selected.has(name))
+
+  const selectedGroups = new Set()
+  for (const name of selected) {
+    const entry = local?.byName?.[name]
+    const group = entry?.group || entry?.doc?.group || entry?.pushPayload?.group_name
+    if (group) selectedGroups.add(group)
+  }
+  plan.groups = {
+    create: (plan.groups?.create || []).filter((name) => selectedGroups.has(name)),
+    // Endpoint-scoped pushes never delete groups: group deletion is a
+    // project-wide reconciliation and could affect unselected endpoints.
+    delete: [],
+    unchanged: (plan.groups?.unchanged || []).filter((name) => selectedGroups.has(name)),
+  }
+  plan.selection = { only_endpoints: selectedNames }
+  return plan
+}
+
+function backendSourcePathsForEndpointSelection(local, selectedNames) {
+  if (!selectedNames) return null
+  const paths = new Set()
+  for (const name of selectedNames) {
+    const entry = local?.byName?.[name]
+    if (!entry) continue
+    if (entry.source === "flow") {
+      const raw = entry.pushPayload?.workflow_source?.file || entry.file
+      if (typeof raw === "string" && raw) {
+        paths.add(raw.startsWith("dypai/") ? raw : `dypai/${raw}`)
+      }
+      continue
+    }
+    if (entry.file) paths.add(`dypai/endpoints/${entry.file}`)
+    for (const refPath of Object.keys(entry.fileMap || {})) {
+      paths.add(refPath.startsWith("dypai/") ? refPath : `dypai/${refPath}`)
+    }
+  }
+  return paths
+}
+
 /**
  * Treat a remote tool response as a definite success only when it has at
  * least one of the markers we expect from a real mutation. Anything else
@@ -329,20 +472,36 @@ async function applyCreate(canonicalRow, projectId) {
   return assertMutationOK(res, "create", canonicalRow.name)
 }
 
-async function applyUpdate(canonicalRow, endpointId, projectId) {
+function endpointUpdatesForRemote(canonicalRow, expectedRevision = null) {
+  const updates = endpointPayload(canonicalRow)
+  if (expectedRevision != null) updates.expected_revision = Number(expectedRevision)
+  return updates
+}
+
+async function applyUpdate(canonicalRow, endpointId, projectId, expectedRevision = null) {
+  const updates = endpointUpdatesForRemote(canonicalRow, expectedRevision)
   const res = await proxyToolCallWithRetry("update_endpoint", {
     ...(projectId ? { project_id: projectId } : {}),
     endpoint_id: endpointId,
-    updates: endpointPayload(canonicalRow),
+    updates,
   })
   return assertMutationOK(res, "update", canonicalRow.name)
 }
 
-async function applyDelete(endpointId, projectId) {
-  const res = await proxyToolCallWithRetry("delete_endpoint", {
+function endpointDeleteArgs(endpointId, projectId, expectedRevision = null) {
+  return {
     ...(projectId ? { project_id: projectId } : {}),
     endpoint_id: endpointId,
-  })
+    ...(expectedRevision != null ? { expected_revision: Number(expectedRevision) } : {}),
+  }
+}
+
+async function applyDelete(endpointId, projectId, expectedRevision = null) {
+  const res = await proxyToolCallWithRetry("delete_endpoint", endpointDeleteArgs(
+    endpointId,
+    projectId,
+    expectedRevision,
+  ))
   return assertMutationOK(res, "delete", endpointId)
 }
 
@@ -484,6 +643,7 @@ export const dypaiPushTool = {
     "ALWAYS run dypai_diff first to preview what will be staged. " +
     "The public dypai_push wrapper also saves frontend source to Studio. " +
     "By default, endpoints in remote but missing locally are kept (safe). Pass delete_orphans: true to stage their deletion as a draft as well. " +
+    "For endpoint-scoped work, pass only_endpoints: ['slug-a', 'slug-b']; unrelated endpoints, groups, realtime policies, automations, and source files are left untouched. " +
     "PARTIAL PUSH: an endpoint whose flow has errors is SKIPPED (it keeps its live version) and the rest are pushed — one broken endpoint no longer blocks the whole push. Skipped ones are listed in `skipped_endpoints` (with their errors) and `partial_success` is set. A project-level error still blocks. Use skip_validation:true to push everything, errors included.",
   inputSchema: {
     type: "object",
@@ -517,11 +677,29 @@ export const dypaiPushTool = {
         description: "Skip the dypai_validate pre-flight check and push EVERY endpoint, including ones with errors (no per-endpoint skipping). By default the push already applies the valid endpoints and only skips the erroring ones — so use this only when you know the validator is wrong. Default: false.",
         default: false,
       },
+      only_endpoints: {
+        type: "array",
+        minItems: 1,
+        uniqueItems: true,
+        items: { type: "string" },
+        description: "Optional explicit endpoint allowlist. Only these endpoint slugs may be created, updated, or deleted; project-wide realtime/automation reconciliation is skipped.",
+      },
     },
   },
 
-  async execute({ project_id, root_dir = "./dypai", delete_orphans = false, dry_run = false, force = false, skip_validation = false } = {}) {
+  async execute({ project_id, root_dir = "./dypai", delete_orphans = false, dry_run = false, force = false, skip_validation = false, only_endpoints = null } = {}) {
     const rootDir = resolvePath(process.cwd(), root_dir)
+    let selectedNames
+    try {
+      selectedNames = normalizeEndpointSelection(only_endpoints)
+    } catch (error) {
+      return {
+        success: false,
+        applied: false,
+        reason: "invalid_endpoint_selection",
+        error: error.message,
+      }
+    }
 
     // Resolve the target project via dypai.config.yaml if the caller didn't
     // pass an explicit project_id. If both are provided and disagree, refuse —
@@ -541,8 +719,7 @@ export const dypaiPushTool = {
       try {
         const validation = await runValidation(rootDir, project_id || configProjectId)
         if (!validation.success) {
-          const errorDiags = (validation.diagnostics || []).filter(d => d.severity === "error")
-          const projectLevel = errorDiags.filter(d => !d.endpoint)
+          const { errorDiags, projectLevel, erroringEndpoints: partitioned } = partitionValidationErrors(validation.diagnostics)
           if (projectLevel.length) {
             return {
               success: false,
@@ -554,7 +731,7 @@ export const dypaiPushTool = {
             }
           }
           skippedDiagnostics = errorDiags
-          erroringEndpoints = new Set(errorDiags.map(d => d.endpoint).filter(Boolean))
+          erroringEndpoints = partitioned
         }
       } catch (e) {
         // Don't block the push on a validator crash — just warn
@@ -599,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) {
@@ -653,29 +844,32 @@ export const dypaiPushTool = {
       stateSnapshot,
       liveRemote: remote,
     })
+    if (selectedNames) {
+      const unavailable = selectedNames.filter((name) => {
+        if (local.byName[name]) return false
+        return !(delete_orphans && effectiveRemote.byName?.[name])
+      })
+      if (unavailable.length) {
+        return {
+          success: false,
+          applied: false,
+          reason: "endpoint_selection_not_found",
+          unavailable_endpoints: unavailable,
+          hint: "Each only_endpoints slug must exist locally. A remote-only slug is accepted only with delete_orphans:true for an explicit deletion.",
+        }
+      }
+      scopePlanToEndpoints(plan, selectedNames, local)
+    }
+    const selectedSourcePaths = backendSourcePathsForEndpointSelection(local, selectedNames)
 
     // Partial push: drop endpoints that failed validation from create/update so
     // 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 skippedNames = []
-    if (erroringEndpoints.size) {
-      const drop = (arr) => (arr || []).filter((item) => {
-        if (erroringEndpoints.has(item.name)) { skippedNames.push(item.name); return false }
-        return true
-      })
-      plan.create = drop(plan.create)
-      plan.update = drop(plan.update)
-    }
-    const skipped_endpoints = skippedNames.length
-      ? [...new Set(skippedNames)].map((name) => ({
-          endpoint: name,
-          errors: skippedDiagnostics
-            .filter((d) => d.endpoint === name)
-            .slice(0, 5)
-            .map((d) => ({ rule: d.rule, message: d.message, file: d.file, loc: d.loc })),
-        }))
-      : undefined
+    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
@@ -688,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.",
       }
     }
@@ -697,11 +896,13 @@ export const dypaiPushTool = {
     if (dry_run || totalChanges === 0) {
       const sourceCheckpoint = dry_run
         ? null
-        : await checkpointBackendSource(targetProjectId, rootDir, plan, remote)
+        : await checkpointBackendSource(targetProjectId, rootDir, plan, remote, selectedSourcePaths)
       const sourceCheckpointFailed = sourceCheckpoint?.ok === false && sourceCheckpoint?.skipped !== true
       const automationSync = dry_run
         ? { skipped: true, reason: "dry_run" }
-        : await syncAutomationMetadata(targetProjectId, local.automations)
+        : selectedNames
+          ? { skipped: true, reason: "endpoint_scoped_push" }
+          : await syncAutomationMetadata(targetProjectId, local.automations)
       const automationSyncHasFailed = automationSyncFailed(automationSync)
       const sourceBaseline = !dry_run && !sourceCheckpointFailed
         ? await refreshBackendSourceBaseline(targetProjectId, rootDir, sourceCheckpoint)
@@ -717,12 +918,16 @@ 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,
         automation_sync: automationSync,
         source_checkpoint: sourceCheckpoint || undefined,
         source_baseline: sourceBaseline,
+        selection: selectedNames ? { only_endpoints: selectedNames } : undefined,
         hint: automationSyncHasFailed
           ? "Backend runtime/source was unchanged, but DYPAI could not sync automation setup metadata. Retry after the API is updated/restarted; file requirements may be missing until this succeeds."
           : sourceCheckpointFailed
@@ -787,7 +992,7 @@ export const dypaiPushTool = {
         const canonical = localToCanonical(local.byName[item.name], remote.mapsCtx)
         const endpointId = remote.byName[item.name]?.id
         const res = endpointId
-          ? await applyUpdate(canonical, endpointId, targetProjectId)
+          ? await applyUpdate(canonical, endpointId, targetProjectId, remote.byName[item.name]?.revision)
           : await applyCreate(canonical, targetProjectId)
         applied.updated.push({ name: item.name, changed_fields: item.changedFields })
         if (isDraftResponse(res)) applied.updated_drafts.push(item.name)
@@ -805,7 +1010,11 @@ export const dypaiPushTool = {
       try {
         const endpointId = remote.byName[item.name]?.id
         if (!endpointId) throw new Error("endpoint_id missing from remote state")
-        const res = await applyDelete(endpointId, targetProjectId)
+        const res = await applyDelete(
+          endpointId,
+          targetProjectId,
+          remote.byName[item.name]?.revision,
+        )
         applied.deleted.push(item.name)
         if (isDraftResponse(res)) applied.deleted_drafts.push(item.name)
         endpoint_results.push(endpointResult("delete", item.name, "applied", {
@@ -834,10 +1043,14 @@ export const dypaiPushTool = {
 
     // Also reconcile realtime policies if realtime.yaml exists
     let realtime = null
-    try {
-      realtime = await syncRealtimePolicies(targetProjectId, rootDir, false)
-    } catch (e) {
-      errors.push({ op: "realtime", error: e.message })
+    if (selectedNames) {
+      realtime = { skipped: true, reason: "endpoint_scoped_push" }
+    } else {
+      try {
+        realtime = await syncRealtimePolicies(targetProjectId, rootDir, false)
+      } catch (e) {
+        errors.push({ op: "realtime", error: e.message })
+      }
     }
 
     // Names of endpoints that actually changed this run — drives the follow-up
@@ -868,7 +1081,7 @@ export const dypaiPushTool = {
     const isDraftMode = draftCount > 0
       && draftCount === endpointTotal + realtimeTotal
     const sourceCheckpoint = errors.length === 0
-      ? await checkpointBackendSource(targetProjectId, rootDir, plan, remote)
+      ? await checkpointBackendSource(targetProjectId, rootDir, plan, remote, selectedSourcePaths)
       : {
           ok: true,
           skipped: true,
@@ -876,7 +1089,9 @@ export const dypaiPushTool = {
         }
     const sourceCheckpointFailed = sourceCheckpoint?.ok === false && sourceCheckpoint?.skipped !== true
     const automationSync = errors.length === 0
-      ? await syncAutomationMetadata(targetProjectId, local.automations)
+      ? selectedNames
+        ? { skipped: true, reason: "endpoint_scoped_push" }
+        : await syncAutomationMetadata(targetProjectId, local.automations)
       : { skipped: true, reason: "push_had_errors" }
     const automationSyncHasFailed = automationSyncFailed(automationSync)
     const sourceBaseline = errors.length === 0 && !sourceCheckpointFailed
@@ -918,12 +1133,16 @@ 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,
       automation_sync: automationSync,
       source_checkpoint: sourceCheckpoint,
       source_baseline: sourceBaseline,
+      selection: selectedNames ? { only_endpoints: selectedNames } : undefined,
       // Only one next_step — and only when it's non-obvious. Drafts win
       // over the test suggestion because tests against live won't see
       // the change until the drafts are promoted.
@@ -967,9 +1186,18 @@ function summaryFromPlan(plan) {
 export const __testing = {
   normalizeResponseCardinality,
   endpointPayload,
+  endpointUpdatesForRemote,
+  endpointDeleteArgs,
   splitBlockingConflicts,
   collectBackendSourceCheckpointFiles,
   deletedBackendSourcePathsFromPlan,
   syncAutomationMetadata,
+  partitionValidationErrors,
+  dropErroringFromPlan,
+  skippedEndpointsFromDiagnostics,
+  mergeSkippedEndpointSummaries,
+  normalizeEndpointSelection,
+  scopePlanToEndpoints,
+  backendSourcePathsForEndpointSelection,
   PUSH_CONCURRENCY,
 }