@dypai-ai/mcp 1.6.5 → 1.6.6

package/package.json

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

package/src/index.js

@@ -553,7 +553,7 @@ async function handleRequest(msg) {
     return makeResponse(id, {
       protocolVersion: "2024-11-05",
       capabilities: { tools: {} },
-      serverInfo: { name: "dypai", version: "1.6.5" },
+      serverInfo: { name: "dypai", version: "1.6.6" },
       instructions: serverInstructions,
     })
   }

package/src/tools/project-artifacts.js

@@ -32,24 +32,38 @@ const STUDIO_SAFE_MODULE_KINDS = new Set([
 
 function isStudioSafeArtifact(item) {
   if (!isObject(item)) return false
+  if (item.can_apply === true) return true
+  if (!item.artifact_type && !item.kind && !item.module_kind && !item.feature_kind && !item.category) return true
   const artifactType = item.artifact_type || item.kind
-  const moduleKind = item.module_kind || item.feature_kind
+  const moduleKind = item.module_kind || item.feature_kind || item.category
   return artifactType === "feature" && STUDIO_SAFE_MODULE_KINDS.has(moduleKind)
 }
 
-function filterStudioSafeSearchResult(raw, limit) {
+function leanArtifact(item) {
+  return {
+    slug: item.slug,
+    name: item.name,
+    summary: item.summary || item.description,
+    best_for: item.best_for || item.use_when,
+    requires: normalizeList(item.requires || item.requires_artifacts).slice(0, 5),
+    includes: normalizeList(item.includes || item.provides_capabilities).slice(0, 6),
+    next_step: item.next_step || (item.slug ? `manage_project_artifact(operation:'inspect', slug:'${item.slug}')` : undefined),
+  }
+}
+
+function filterArtifactSearchResult(raw, limit) {
   if (!isObject(raw)) return raw
-  const cap = Number.isFinite(Number(limit)) ? Number(limit) : 20
-  const artifacts = normalizeArtifactList(raw.artifacts).filter(isStudioSafeArtifact).slice(0, cap)
-  const features = normalizeArtifactList(raw.features).filter(isStudioSafeArtifact).slice(0, cap)
+  const cap = Number.isFinite(Number(limit)) ? Number(limit) : 3
+  const artifacts = normalizeArtifactList(raw.artifacts)
+    .filter(isStudioSafeArtifact)
+    .slice(0, cap)
+    .map(leanArtifact)
   return {
-    ...raw,
-    frontend_only: true,
+    ok: raw.ok !== false,
+    query: raw.query,
     results_count: artifacts.length,
     artifacts,
-    bases: [],
-    features,
-    migration_note: "Studio only exposes frontend/UI artifacts. Backend/database artifacts must be implemented as Flow before Studio install.",
+    hint: raw.hint || "Pick one slug, inspect it, then apply only if it fits the current app.",
   }
 }
 
@@ -76,11 +90,20 @@ function manifestFromModuleContract(contract) {
   const mount = Array.isArray(contract?.mount_contract?.manifest) ? contract.mount_contract.manifest : []
   const frontendManifest = []
   const backendManifest = []
+  const flowManifest = []
   const databaseManifest = {}
   for (const entry of mount) {
     if (!entry?.source) continue
     const source = String(entry.source)
     const role = String(entry.role || "")
+    if (role === "flow" || source.includes("/flows/")) {
+      flowManifest.push({
+        source,
+        suggestedTarget: entry.target,
+        flowName: entry.export_name || basename(source).replace(/\.flow\.ts$/i, ""),
+      })
+      continue
+    }
     if (role === "endpoint" || source.includes("/endpoints/")) {
       backendManifest.push({
         source,
@@ -128,10 +151,14 @@ function manifestFromModuleContract(contract) {
     dependencies,
     frontendManifest,
     backendManifest,
+    flowManifest,
     databaseManifest,
+    flow_ready: contract.flow_ready === true,
+    studio_safe: contract.studio_safe === true,
+    install_risk: contract.install_risk || null,
     install: {
       requiresExecuteSql: Boolean(databaseManifest.schema || databaseManifest.seed),
-      requiresBackendPublish: backendManifest.length > 0,
+      requiresBackendPublish: backendManifest.length > 0 || flowManifest.length > 0,
     },
   }
 }
@@ -160,24 +187,24 @@ function loadArtifactFromDir(artifactDir) {
   return { dir: artifactDir, manifest }
 }
 
-async function materializeArtifactFromGithub({ source_repo, source_path, source_ref }) {
+async function materializeArtifactFromGithub({ slug, source_repo, source_path, source_ref }) {
   const repo = String(source_repo || "").trim()
-  if (!repo) {
-    throw new Error("source_repo is required from search_project_artifacts (e.g. dyapps-codes/artifacts).")
-  }
+  const wantedSlug = String(slug || "").trim()
+  if (!repo && !wantedSlug) throw new Error("slug is required.")
   const path = String(source_path || "").trim()
   const ref = String(source_ref || "main").trim() || "main"
 
-  const remote = await proxyToolCall("fetch_project_artifact", {
-    source_repo: repo,
-    source_path: path,
-    source_ref: ref,
-  })
+  const remote = await proxyToolCall(
+    "fetch_project_artifact",
+    repo
+      ? { source_repo: repo, source_path: path, source_ref: ref }
+      : { slug: wantedSlug },
+  )
   if (!isObject(remote) || !remote.ok) {
     throw new Error(isObject(remote) && remote.error ? remote.error : "fetch_project_artifact failed")
   }
 
-  const key = crypto.createHash("sha256").update(`${repo}|${path}|${ref}`).digest("hex")
+  const key = crypto.createHash("sha256").update(`${repo || wantedSlug}|${path}|${ref}`).digest("hex")
   const artifactDir = join(tmpdir(), "dypai-artifact-fetch", key)
   rmSync(artifactDir, { recursive: true, force: true })
   mkdirSync(artifactDir, { recursive: true })
@@ -232,29 +259,27 @@ async function lookupArtifactGithubSource(slug) {
 }
 
 async function searchProjectArtifacts(args = {}) {
-  const studioSafe = isStudioArtifactProfile()
-  const requestedLimit = Number(args.limit || 20)
-  const proxyLimit = studioSafe || args.frontend_only ? Math.max(requestedLimit, 50) : requestedLimit
+  const requestedLimit = Number(args.limit || 3)
   const remoteArgs = {
     ...args,
-    limit: Math.min(Math.max(proxyLimit, 1), 50),
+    limit: Math.min(Math.max(requestedLimit, 1), 5),
   }
   delete remoteArgs.frontend_only
 
   const raw = await proxyToolCall("search_project_artifacts", remoteArgs)
   if (!isObject(raw) || raw.ok === false) return raw
-  if (!studioSafe && !args.frontend_only) return raw
-  return filterStudioSafeSearchResult(raw, requestedLimit)
+  return filterArtifactSearchResult(raw, requestedLimit)
 }
 
 async function resolveArtifactInstallation({ slug, source_repo, source_path, source_ref }) {
   const resolved = String(source_repo || "").trim()
     ? {
+        slug: String(slug || "").trim(),
         source_repo: String(source_repo).trim(),
         source_path: String(source_path || "").trim(),
         source_ref: String(source_ref || "main").trim() || "main",
       }
-    : await lookupArtifactGithubSource(slug)
+    : { slug: String(slug || "").trim() }
   return materializeArtifactFromGithub(resolved)
 }
 
@@ -362,6 +387,7 @@ function resolveArtifactAssetPath(artifactDir, source) {
 
 function defaultTargetForSource(manifest, source, kind) {
   if (kind === "frontend") return `src/dypai-kits/${manifest.slug}/${stripFrontendPrefix(source)}`
+  if (kind === "flow") return `dypai/flows/${source.split("/").pop()}`
   if (kind === "backend") return `dypai/endpoints/${manifest.slug}/${source.split("/").pop()}`
   if (kind === "database") return `dypai/kit-installations/${manifest.slug}/${manifest.version}/${source.split("/").pop()}`
   return `.dypai/kits/${manifest.slug}/${source.split("/").pop()}`
@@ -525,11 +551,17 @@ async function applyProjectArtifact({
 
   const installFrontend = install.frontend !== false
   const studioSafe = isStudioArtifactProfile()
-  const hasBackendAssets = (manifest.backendManifest || []).length > 0
+  const hasLegacyBackendAssets = (manifest.backendManifest || []).length > 0
+  const hasFlowAssets = (manifest.flowManifest || []).length > 0
   const hasDatabaseAssets = Boolean(manifest.databaseManifest?.schema || manifest.databaseManifest?.seed)
-  if (studioSafe && (hasBackendAssets || hasDatabaseAssets)) {
+  if (studioSafe && (hasLegacyBackendAssets || hasDatabaseAssets)) {
     throw new Error(
-      `Artifact "${manifest.slug}" includes backend/database assets. Studio can only apply frontend/UI artifacts; implement backend pieces as Flow first.`,
+      `Artifact "${manifest.slug}" includes legacy YAML backend or database assets. Studio can only apply frontend/UI artifacts until backend is Flow-only.`,
+    )
+  }
+  if (studioSafe && hasFlowAssets && manifest.studio_safe !== true) {
+    throw new Error(
+      `Artifact "${manifest.slug}" has Flow backend but is not marked studio_safe. Complete Flow migration and set studio_safe in module.contract.json.`,
     )
   }
   if (studioSafe && install.backend === true) {
@@ -545,6 +577,7 @@ async function applyProjectArtifact({
     throw new Error(`Artifact "${manifest.slug}" has no frontend files to install in Studio.`)
   }
   const installBackend = studioSafe ? false : install.backend !== false
+  const installFlows = studioSafe ? false : install.flows !== false && install.backend !== false
   const installDatabase = studioSafe ? false : install.database !== false
 
   if (installFrontend) {
@@ -579,6 +612,19 @@ async function applyProjectArtifact({
     }
   }
 
+  if (installFlows) {
+    for (const asset of manifest.flowManifest || []) {
+      const sourceAbs = resolveArtifactAssetPath(dir, asset.source)
+      let targetRel = asset.suggestedTarget || defaultTargetForSource(manifest, asset.source, "flow")
+      if (target.flowDir) {
+        targetRel = join(target.flowDir, basename(asset.source)).split(sep).join("/")
+      }
+      if (writeTemplateFile({ sourceAbs, targetRel, workspaceRoot, manifest, naming, kind: "frontend", overwrite, record, copied, skipped })) {
+        copiedByKind.backend.push(targetRel)
+      }
+    }
+  }
+
   if (installDatabase && isObject(manifest.databaseManifest)) {
     for (const key of ["schema", "seed"]) {
       const source = manifest.databaseManifest[key]
@@ -604,9 +650,14 @@ async function applyProjectArtifact({
     return true
   })
 
-  const backendEndpoints = (manifest.backendManifest || []).map((asset) =>
-    adaptTarget(asset.endpointName || asset.source.split("/").pop().replace(/\.ya?ml$/, ""), manifest, naming),
-  )
+  const backendEndpoints = [
+    ...(manifest.backendManifest || []).map((asset) =>
+      adaptTarget(asset.endpointName || asset.source.split("/").pop().replace(/\.ya?ml$/, ""), manifest, naming),
+    ),
+    ...(manifest.flowManifest || []).map((asset) =>
+      adaptTarget(asset.flowName || asset.source.split("/").pop().replace(/\.flow\.ts$/, ""), manifest, naming),
+    ),
+  ]
   const databaseTables = normalizeList(manifest.databaseManifest?.tables).map((table) =>
     adaptTarget(table, manifest, naming),
   )