@dypai-ai/mcp 1.5.28 → 1.5.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dypai-ai/mcp",
-  "version": "1.5.28",
+  "version": "1.5.30",
   "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

@@ -1,16 +1,28 @@
 /**
- * Cloud backend compiler client — calls Core API snapshot compile routes.
+ * Cloud backend compiler client — calls MCP Cloud tool backend_compile_snapshot.
+ * MCP local never talks to Core API or the compiler MS directly for Flow compile.
  */
 
-import { api } from "../api.js"
+import { proxyToolCall } from "../tools/proxy.js"
 import { collectBackendSnapshotFromDypaiDir } from "./backendSnapshot.js"
 
-function compilerBasePath(projectId) {
-  return `/api/engine/${encodeURIComponent(projectId)}/backend/snapshot`
+const COMMAND_MAP = {
+  validate: "validate",
+  list: "list",
+  resolve: "resolve",
+  "push-payload": "push-payload",
+  "push-payloads": "push-payloads",
+  "generate-types": "generate-types",
 }
 
-async function postSnapshotRoute(projectId, route, body) {
-  return api.post(`${compilerBasePath(projectId)}/${route}`, body)
+async function compileSnapshot(projectId, command, files, endpoint = undefined) {
+  const args = {
+    project_id: projectId,
+    command: COMMAND_MAP[command] || command,
+    files,
+  }
+  if (endpoint) args.endpoint = endpoint
+  return proxyToolCall("backend_compile_snapshot", args)
 }
 
 export async function buildSnapshotPayload(dypaiRootDir, projectRoot = null) {
@@ -18,27 +30,27 @@ export async function buildSnapshotPayload(dypaiRootDir, projectRoot = null) {
 }
 
 export async function cloudValidateSnapshot(projectId, files) {
-  return postSnapshotRoute(projectId, "validate", { files })
+  return compileSnapshot(projectId, "validate", files)
 }
 
 export async function cloudListEffectiveEntries(projectId, files) {
-  return postSnapshotRoute(projectId, "list", { files })
+  return compileSnapshot(projectId, "list", files)
 }
 
 export async function cloudResolveEffectiveEndpoint(projectId, files, endpoint) {
-  return postSnapshotRoute(projectId, "resolve", { files, endpoint })
+  return compileSnapshot(projectId, "resolve", files, endpoint)
 }
 
 export async function cloudBuildPushPayload(projectId, files, endpoint) {
-  return postSnapshotRoute(projectId, "push-payload", { files, endpoint })
+  return compileSnapshot(projectId, "push-payload", files, endpoint)
 }
 
 export async function cloudBuildEffectivePushPayloads(projectId, files) {
-  return postSnapshotRoute(projectId, "effective-push-payloads", { files })
+  return compileSnapshot(projectId, "push-payloads", files)
 }
 
 export async function cloudGenerateTypes(projectId, files) {
-  return postSnapshotRoute(projectId, "generate-types", { files })
+  return compileSnapshot(projectId, "generate-types", files)
 }
 
 export async function compileFromDypaiDir(projectId, dypaiRootDir, projectRoot = null) {
@@ -48,7 +60,3 @@ export async function compileFromDypaiDir(projectId, dypaiRootDir, projectRoot =
   }
   return { ok: true, snapshot }
 }
-
-export function shouldUseLocalFlowCompiler() {
-  return Boolean(process.env.DYPAI_MONOREPO_ROOT || process.env.DYPAI_USE_LOCAL_FLOW_COMPILER === "1")
-}

package/src/lib/effective-workflows-runner.js

@@ -1,11 +1,8 @@
 /**
- * Effective workflow runner — cloud compiler by default, local monorepo CLI for dev override.
+ * Effective workflow runner — cloud compiler only (MCP Cloud → backend_compile_snapshot).
  */
 
-import { spawnSync } from "node:child_process"
-import { existsSync } from "node:fs"
-import { dirname, join, resolve as resolvePath, basename } from "node:path"
-import { fileURLToPath } from "node:url"
+import { basename, dirname, resolve as resolvePath } from "node:path"
 import {
   buildSnapshotPayload,
   cloudBuildEffectivePushPayloads,
@@ -14,115 +11,13 @@ import {
   cloudListEffectiveEntries,
   cloudResolveEffectiveEndpoint,
   cloudValidateSnapshot,
-  shouldUseLocalFlowCompiler,
 } from "./cloudBackendCompiler.js"
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
 export function resolveProjectRootFromDypaiDir(dypaiRootDir) {
   const resolved = resolvePath(dypaiRootDir)
   return basename(resolved) === "dypai" ? dirname(resolved) : resolved
 }
 
-export function resolveMonorepoRoot() {
-  if (process.env.DYPAI_MONOREPO_ROOT) {
-    return resolvePath(process.env.DYPAI_MONOREPO_ROOT)
-  }
-
-  let cursor = __dirname
-  for (let i = 0; i < 10; i++) {
-    if (existsSync(join(cursor, "dypai-workspace")) && existsSync(join(cursor, "dypai-flow"))) {
-      return cursor
-    }
-    const parent = dirname(cursor)
-    if (parent === cursor) break
-    cursor = parent
-  }
-  return null
-}
-
-function parseCliStdout(stdout) {
-  const trimmed = (stdout || "").trim()
-  if (!trimmed) return { error: "effective-workflows-cli returned empty output" }
-  try {
-    return JSON.parse(trimmed)
-  } catch {
-    return { error: `effective-workflows-cli returned non-JSON output: ${trimmed.slice(0, 300)}` }
-  }
-}
-
-export function runEffectiveWorkflowsCli(projectRoot, commandArgs = []) {
-  const monorepoRoot = resolveMonorepoRoot()
-  if (!monorepoRoot) {
-    return {
-      ok: false,
-      unavailable: true,
-      warning: {
-        severity: "warn",
-        rule: "effective_workflow_runner_unavailable",
-        message: "Effective workflow runner unavailable (monorepo root not found). YAML workflows still work.",
-        fix_hint: "Flow validation now runs in DYPAI cloud by default. Ensure DYPAI_TOKEN is set.",
-      },
-    }
-  }
-
-  const scriptPath = join(monorepoRoot, "dypai-workspace/scripts/effective-workflows-cli.ts")
-  if (!existsSync(scriptPath)) {
-    return {
-      ok: false,
-      unavailable: true,
-      warning: {
-        severity: "warn",
-        rule: "effective_workflow_runner_unavailable",
-        message: `Effective workflow CLI missing at ${scriptPath}.`,
-      },
-    }
-  }
-
-  const bunBin = process.env.DYPAI_BUN_BIN || "bun"
-  const args = ["run", scriptPath, ...commandArgs, "--root", resolvePath(projectRoot)]
-  const result = spawnSync(bunBin, args, {
-    encoding: "utf8",
-    cwd: monorepoRoot,
-    env: process.env,
-  })
-
-  if (result.error) {
-    return {
-      ok: false,
-      unavailable: true,
-      warning: {
-        severity: "warn",
-        rule: "effective_workflow_runner_unavailable",
-        message: `Failed to spawn ${bunBin}: ${result.error.message}`,
-        fix_hint: "Install bun or set DYPAI_BUN_BIN to a working bun executable.",
-      },
-    }
-  }
-
-  const parsed = parseCliStdout(result.stdout)
-  if (parsed.error && !parsed.diagnostics && !parsed.entries && !parsed.status) {
-    return {
-      ok: false,
-      unavailable: false,
-      error: parsed.error,
-      stderr: (result.stderr || "").trim() || undefined,
-      exitCode: result.status,
-    }
-  }
-
-  if (result.status !== 0 && !parsed.diagnostics && !parsed.entries && !parsed.status) {
-    return {
-      ok: false,
-      unavailable: false,
-      error: parsed.error || (result.stderr || "").trim() || `effective-workflows-cli exited with ${result.status}`,
-      exitCode: result.status,
-    }
-  }
-
-  return { ok: true, data: parsed }
-}
-
 function endpointArg(commandArgs) {
   const idx = commandArgs.indexOf("--endpoint")
   if (idx < 0) return null
@@ -133,7 +28,9 @@ function commandFromArgs(commandArgs) {
   return commandArgs[0] || "validate"
 }
 
-async function runEffectiveWorkflowsCloud(dypaiRootDir, projectRoot, projectId, commandArgs = []) {
+export async function runEffectiveWorkflows(dypaiRootDir, projectId, commandArgs = []) {
+  const projectRoot = resolveProjectRootFromDypaiDir(dypaiRootDir)
+
   if (!projectId) {
     return {
       ok: false,
@@ -198,13 +95,3 @@ async function runEffectiveWorkflowsCloud(dypaiRootDir, projectRoot, projectId,
     }
   }
 }
-
-export async function runEffectiveWorkflows(dypaiRootDir, projectId, commandArgs = []) {
-  const projectRoot = resolveProjectRootFromDypaiDir(dypaiRootDir)
-  if (shouldUseLocalFlowCompiler()) {
-    return runEffectiveWorkflowsCli(projectRoot, commandArgs)
-  }
-  return runEffectiveWorkflowsCloud(dypaiRootDir, projectRoot, projectId, commandArgs)
-}
-
-export { shouldUseLocalFlowCompiler }

package/src/toolProfiles.js

@@ -42,6 +42,7 @@ export const MCP_TOOLS_REMOVED = new Set([
   "search_design_patterns",
   "search_project_templates",
   "search_workflow_templates",
+  "backend_compile_snapshot",
 ]);
 
 /** Local-only ship/deploy tools — excluded from Studio allowlists, not from local. */