@dypai-ai/mcp 1.6.16 → 1.6.18

package/src/tools/sync/push.js

@@ -25,6 +25,7 @@ import {
 } from "./planner.js"
 import { runValidation } from "./validate.js"
 import { runGenerateEndpointTypes } from "./generate-types.js"
+import { writeBackendSourceBaseline } from "./source-diff.js"
 // Codegen removed from v1 — see pull.js note.
 // import { regenerateTypes } from "../codegen.js"
 
@@ -34,7 +35,7 @@ const VALID_RESPONSE_CARDINALITY = new Set(["single", "many", "zero_or_one"])
 const PUSH_CONCURRENCY = Math.max(1, Number(process.env.DYPAI_PUSH_CONCURRENCY || 1))
 const PUSH_RETRY_ATTEMPTS = Math.max(1, Number(process.env.DYPAI_PUSH_RETRY_ATTEMPTS || 3))
 const PUSH_RETRY_DELAY_MS = Math.max(100, Number(process.env.DYPAI_PUSH_RETRY_DELAY_MS || 500))
-const BACKEND_SOURCE_CHECKPOINT_DIRS = ["flows", "endpoints", "migrations", "types", "lib"]
+const BACKEND_SOURCE_CHECKPOINT_DIRS = ["flows", "automations", "endpoints", "migrations", "types", "lib"]
 const BACKEND_SOURCE_CHECKPOINT_EXACT = ["schema.sql", "realtime.yaml"]
 const BACKEND_SOURCE_CHECKPOINT_EXTS = new Set([
   ".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cjs", ".cts",
@@ -136,6 +137,8 @@ function normalizeWorkflowSourceFile(row) {
   const raw = typeof source?.file === "string" ? source.file.trim().replace(/\\/g, "/") : ""
   if (raw.startsWith("dypai/flows/") && raw.endsWith(".flow.ts")) return raw
   if (raw.startsWith("flows/") && raw.endsWith(".flow.ts")) return `dypai/${raw}`
+  if (raw.startsWith("dypai/automations/") && raw.endsWith(".automation.ts")) return raw
+  if (raw.startsWith("automations/") && raw.endsWith(".automation.ts")) return `dypai/${raw}`
   return null
 }
 
@@ -195,6 +198,29 @@ async function checkpointBackendSource(projectId, rootDir, plan, remote) {
   }
 }
 
+async function refreshBackendSourceBaseline(projectId, rootDir, sourceCheckpoint) {
+  if (sourceCheckpoint?.ok === false && sourceCheckpoint?.skipped !== true) {
+    return {
+      ok: false,
+      skipped: true,
+      reason: "source_checkpoint_failed",
+    }
+  }
+  try {
+    const baseline = await writeBackendSourceBaseline(rootDir, projectId)
+    return {
+      ok: true,
+      files: Array.isArray(baseline.files) ? baseline.files.length : 0,
+      path: "dypai/.dypai/backend-baseline.json",
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      error: error?.message || String(error),
+    }
+  }
+}
+
 /**
  * Run an async worker over an array with bounded concurrency. Workers never
  * throw (they handle their own errors via the push errors[] accumulator),
@@ -275,7 +301,7 @@ function assertMutationOK(result, op, name) {
  * Returns true when the API staged the change as a draft (default behavior)
  * instead of applying it directly to live. Both the draft branch and the
  * direct-write branch are valid successful outcomes — drafts just need to
- * be reported back to the user so they know to run dypai_deploy_production(confirm:true).
+ * be reported back to the user so they know to publish the drafts explicitly.
  */
 function isDraftResponse(result) {
   return result && typeof result === "object" && result.applied_to === "draft"
@@ -439,7 +465,7 @@ export const dypaiPushTool = {
       },
       dry_run: {
         type: "boolean",
-        description: "If true, compute the plan and return it without applying. Same as dypai_diff.",
+        description: "If true, compile and compute the backend plan without applying or regenerating types. For a fast source-only preview use dypai_diff.",
         default: false,
       },
       force: {
@@ -499,11 +525,13 @@ export const dypaiPushTool = {
       }
     }
 
-    let typesGenerated = null
-    try {
-      typesGenerated = await runGenerateEndpointTypes(rootDir, targetProjectId)
-    } catch (e) {
-      typesGenerated = { ok: false, error: e.message }
+    let typesGenerated = dry_run ? { ok: true, skipped: true, reason: "dry_run" } : null
+    if (!dry_run) {
+      try {
+        typesGenerated = await runGenerateEndpointTypes(rootDir, targetProjectId)
+      } catch (e) {
+        typesGenerated = { ok: false, error: e.message }
+      }
     }
 
     let local
@@ -594,6 +622,9 @@ export const dypaiPushTool = {
         ? null
         : await checkpointBackendSource(targetProjectId, rootDir, plan, remote)
       const sourceCheckpointFailed = sourceCheckpoint?.ok === false && sourceCheckpoint?.skipped !== true
+      const sourceBaseline = !dry_run && !sourceCheckpointFailed
+        ? await refreshBackendSourceBaseline(targetProjectId, rootDir, sourceCheckpoint)
+        : undefined
       return {
         success: !sourceCheckpointFailed,
         applied: false,
@@ -602,6 +633,7 @@ export const dypaiPushTool = {
         plan,
         types: typesGenerated,
         source_checkpoint: sourceCheckpoint || undefined,
+        source_baseline: sourceBaseline,
         hint: sourceCheckpointFailed
           ? "Backend runtime was unchanged, but DYPAI could not save the local dypai/ source to the Studio branch. Retry dypai_push once the GitHub/source checkpoint issue is resolved."
           : undefined,
@@ -725,7 +757,7 @@ export const dypaiPushTool = {
     ]
 
     // How many ops landed in draft state. When `draftCount > 0` the user
-    // must run dypai_deploy_production(confirm:true) to expose the changes
+    // must publish drafts explicitly to expose the changes
     // on live; tests against live won't see them yet. Realtime drafts are
     // also counted — the API returns `applied_to: "draft"` and a
     // `drafts_queued` array when realtime policies were staged.
@@ -752,6 +784,9 @@ export const dypaiPushTool = {
           reason: "push_had_errors",
         }
     const sourceCheckpointFailed = sourceCheckpoint?.ok === false && sourceCheckpoint?.skipped !== true
+    const sourceBaseline = errors.length === 0 && !sourceCheckpointFailed
+      ? await refreshBackendSourceBaseline(targetProjectId, rootDir, sourceCheckpoint)
+      : undefined
 
     return {
       success: errors.length === 0 && !sourceCheckpointFailed,
@@ -786,6 +821,7 @@ export const dypaiPushTool = {
       errors: errors.length ? errors : undefined,
       types: typesGenerated,
       source_checkpoint: sourceCheckpoint,
+      source_baseline: sourceBaseline,
       // 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.
@@ -794,7 +830,7 @@ export const dypaiPushTool = {
           ? `${endpointTotal} endpoint(s) saved, ${failedTotal} failed. Fix failed endpoints and push again. Failed: ${errors.slice(0, 3).map((item) => item.endpoint || item.group || item.op).join(", ")}${errors.length > 3 ? "…" : ""}`
           : "Fix the offending YAMLs and push again."
         : draftCount > 0
-          ? `${draftCount} backend change(s) saved to preview — they're not live yet. Verify with dypai_test_endpoint(mode:'draft', endpoint:'<name>') or ask the user to test the preview. Publish with dypai_deploy_production(confirm:true) ONLY after explicit approval.`
+          ? `${draftCount} backend change(s) saved as drafts — they're not live yet. Review with manage_drafts(operation:'list'), verify with dypai_test_endpoint(mode:'draft', endpoint:'<name>') when useful, then publish with manage_drafts(operation:'publish', confirm:true) or dypai_deploy_production(target:'backend', confirm:true) ONLY after explicit approval.`
           : changedNames.length
             ? `Test changed endpoint(s) with dypai_test_endpoint: ${changedNames.slice(0, 3).join(", ")}${changedNames.length > 3 ? "…" : ""}`
             : undefined,

package/src/tools/sync/source-diff.js

@@ -0,0 +1,217 @@
+import { createHash } from "node:crypto"
+import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises"
+import { dirname, join } from "path"
+
+const BACKEND_SOURCE_DIRS = ["flows", "automations", "endpoints", "migrations", "types", "lib"]
+const BACKEND_SOURCE_EXACT = [
+  "schema.sql",
+  "realtime.yaml",
+  "credentials.yaml",
+  "node-catalog.json",
+  "capability-catalog.json",
+  "capability-brief.md",
+  "dypai.config.yaml",
+]
+const BACKEND_SOURCE_EXTS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cjs", ".cts",
+  ".json", ".yaml", ".yml", ".sql", ".md", ".txt",
+])
+
+function extOfPath(path) {
+  const filename = path.split("/").pop() || path
+  return filename.includes(".") ? `.${filename.split(".").pop().toLowerCase()}` : ""
+}
+
+function isTextBackendPath(path) {
+  return BACKEND_SOURCE_EXTS.has(extOfPath(path))
+}
+
+function normalizePath(path) {
+  return String(path || "").replace(/\\/g, "/").replace(/^\/+/, "")
+}
+
+export function isTrackedBackendSourcePath(path) {
+  const normalized = normalizePath(path)
+  if (!normalized.startsWith("dypai/")) return false
+  if (normalized.startsWith("dypai/.dypai/")) return false
+  const rel = normalized.slice("dypai/".length)
+  if (BACKEND_SOURCE_EXACT.includes(rel)) return true
+  return BACKEND_SOURCE_DIRS.some((dir) => rel.startsWith(`${dir}/`)) && isTextBackendPath(rel)
+}
+
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex")
+}
+
+async function addFile(files, absPath, relPath) {
+  if (!isTextBackendPath(relPath)) return
+  const content = await readFile(absPath, "utf8")
+  files.push({
+    path: `dypai/${relPath}`,
+    content,
+    sha256: hashContent(content),
+  })
+}
+
+async function walkDir(files, absDir, relBase) {
+  let entries = []
+  try {
+    entries = await readdir(absDir, { withFileTypes: true })
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue
+    const relPath = `${relBase}/${entry.name}`.replace(/^\/+/, "")
+    const absPath = join(absDir, entry.name)
+    if (entry.isDirectory()) {
+      await walkDir(files, absPath, relPath)
+    } else if (entry.isFile()) {
+      await addFile(files, absPath, relPath)
+    }
+  }
+}
+
+export async function collectBackendSourceFiles(rootDir) {
+  const files = []
+
+  for (const relPath of BACKEND_SOURCE_EXACT) {
+    const absPath = join(rootDir, relPath)
+    try {
+      const s = await stat(absPath)
+      if (s.isFile()) await addFile(files, absPath, relPath)
+    } catch {
+      // optional
+    }
+  }
+
+  for (const dir of BACKEND_SOURCE_DIRS) {
+    await walkDir(files, join(rootDir, dir), dir)
+  }
+
+  files.sort((a, b) => a.path.localeCompare(b.path))
+  return files
+}
+
+function normalizeBaseline(raw) {
+  const parsed = JSON.parse(raw)
+  const files = parsed?.files
+  const result = new Map()
+  if (Array.isArray(files)) {
+    for (const file of files) {
+      if (typeof file?.path === "string" && typeof file?.sha256 === "string" && isTrackedBackendSourcePath(file.path)) {
+        result.set(file.path, file.sha256)
+      }
+    }
+  } else if (files && typeof files === "object") {
+    for (const [path, value] of Object.entries(files)) {
+      if (!isTrackedBackendSourcePath(path)) continue
+      if (typeof value === "string") result.set(path, value)
+      else if (value && typeof value === "object" && typeof value.sha256 === "string") result.set(path, value.sha256)
+    }
+  }
+  return result
+}
+
+export async function readBackendSourceBaseline(rootDir) {
+  try {
+    const raw = await readFile(join(rootDir, ".dypai", "backend-baseline.json"), "utf8")
+    return {
+      ok: true,
+      baseline: normalizeBaseline(raw),
+    }
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {
+        ok: false,
+        missing: true,
+        baseline: new Map(),
+      }
+    }
+    return {
+      ok: false,
+      error: error?.message || String(error),
+      baseline: new Map(),
+    }
+  }
+}
+
+export async function diffBackendSource(rootDir) {
+  const currentFiles = await collectBackendSourceFiles(rootDir)
+  const current = new Map(currentFiles.map((file) => [file.path, file.sha256]))
+  const baselineResult = await readBackendSourceBaseline(rootDir)
+
+  if (!baselineResult.ok && !baselineResult.missing) {
+    return {
+      ok: false,
+      reason: "baseline_parse_error",
+      error: baselineResult.error,
+    }
+  }
+
+  if (baselineResult.missing) {
+    return {
+      ok: true,
+      baseline: false,
+      files: {
+        created: currentFiles.map((file) => file.path),
+        updated: [],
+        deleted: [],
+      },
+      summary: {
+        create: currentFiles.length,
+        update: 0,
+        delete: 0,
+        unchanged: 0,
+      },
+    }
+  }
+
+  const baseline = baselineResult.baseline
+  const created = []
+  const updated = []
+  const deleted = []
+  const unchanged = []
+
+  for (const [path, hash] of current) {
+    if (!baseline.has(path)) created.push(path)
+    else if (baseline.get(path) !== hash) updated.push(path)
+    else unchanged.push(path)
+  }
+  for (const path of baseline.keys()) {
+    if (!current.has(path)) deleted.push(path)
+  }
+
+  return {
+    ok: true,
+    baseline: true,
+    files: {
+      created,
+      updated,
+      deleted,
+    },
+    summary: {
+      create: created.length,
+      update: updated.length,
+      delete: deleted.length,
+      unchanged: unchanged.length,
+    },
+  }
+}
+
+export async function writeBackendSourceBaseline(rootDir, projectId = null) {
+  const files = await collectBackendSourceFiles(rootDir)
+  const payload = {
+    synced_at: new Date().toISOString(),
+    ...(projectId ? { project_id: projectId } : {}),
+    files: files.map((file) => ({
+      path: file.path,
+      sha256: file.sha256,
+    })),
+  }
+  const target = join(rootDir, ".dypai", "backend-baseline.json")
+  await mkdir(dirname(target), { recursive: true })
+  await writeFile(target, JSON.stringify(payload, null, 2) + "\n", "utf8")
+  return payload
+}
+