@dypai-ai/mcp 1.6.5 → 1.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dypai-ai/mcp",
-  "version": "1.6.5",
+  "version": "1.6.7",
   "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.7" },
       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,16 @@ function loadArtifactFromDir(artifactDir) {
   return { dir: artifactDir, manifest }
 }
 
-async function materializeArtifactFromGithub({ 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 path = String(source_path || "").trim()
-  const ref = String(source_ref || "main").trim() || "main"
+async function materializeArtifactFromCatalog({ slug }) {
+  const wantedSlug = String(slug || "").trim()
+  if (!wantedSlug) throw new Error("slug is required.")
 
-  const remote = await proxyToolCall("fetch_project_artifact", {
-    source_repo: repo,
-    source_path: path,
-    source_ref: ref,
-  })
+  const remote = await proxyToolCall("fetch_project_artifact", { 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(`${wantedSlug}|${remote.content_hash || remote.version || "latest"}`).digest("hex")
   const artifactDir = join(tmpdir(), "dypai-artifact-fetch", key)
   rmSync(artifactDir, { recursive: true, force: true })
   mkdirSync(artifactDir, { recursive: true })
@@ -199,63 +218,27 @@ async function materializeArtifactFromGithub({ source_repo, source_path, source_
   const loaded = loadArtifactFromDir(artifactDir)
   return {
     ...loaded,
-    source: "github",
-    source_repo: repo,
-    source_path: path,
-    source_ref: ref,
+    source: remote.source || "catalog",
     agentNotes: typeof remote.agent_notes === "string" ? remote.agent_notes : undefined,
     checklist: typeof remote.checklist === "string" ? remote.checklist : undefined,
   }
 }
 
-async function lookupArtifactGithubSource(slug) {
-  const wanted = String(slug || "").trim()
-  if (!wanted) throw new Error("slug is required.")
-
-  const remote = await proxyToolCall("search_project_artifacts", { query: wanted, limit: 20 })
-  if (!isObject(remote) || remote.ok === false) {
-    throw new Error(isObject(remote) && remote.error ? remote.error : "search_project_artifacts failed")
-  }
-
-  const pools = [remote.artifacts, remote.features, remote.bases].filter(Array.isArray)
-  for (const pool of pools) {
-    const hit = pool.find((item) => isObject(item) && String(item.slug || "").trim() === wanted)
-    if (hit?.source_repo) {
-      return {
-        source_repo: String(hit.source_repo).trim(),
-        source_path: String(hit.source_path || "").trim(),
-        source_ref: String(hit.source_ref || "main").trim() || "main",
-      }
-    }
-  }
-  throw new Error(`Artifact "${wanted}" not found in catalog. Call search_project_artifacts first.`)
-}
-
 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()
-    ? {
-        source_repo: String(source_repo).trim(),
-        source_path: String(source_path || "").trim(),
-        source_ref: String(source_ref || "main").trim() || "main",
-      }
-    : await lookupArtifactGithubSource(slug)
-  return materializeArtifactFromGithub(resolved)
+async function resolveArtifactInstallation({ slug }) {
+  return materializeArtifactFromCatalog({ slug: String(slug || "").trim() })
 }
 
 function resolveWorkspaceRoot(inputRoot) {
@@ -362,6 +345,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()}`
@@ -480,13 +464,11 @@ function writeTemplateFile({ sourceAbs, targetRel, workspaceRoot, manifest, nami
   return true
 }
 
-async function inspectProjectArtifact({ slug, version = "1.0.0", source_repo, source_path, source_ref }) {
-  const { dir, manifest, source, agentNotes, checklist } = await resolveArtifactInstallation({ slug, source_repo, source_path, source_ref })
+async function inspectProjectArtifact({ slug, version = "1.0.0" }) {
+  const { dir, manifest, agentNotes, checklist } = await resolveArtifactInstallation({ slug })
   return {
     ok: true,
     operation: "inspect",
-    source,
-    artifactRoot: dir,
     artifact: manifest,
     assets: assetIndex(dir),
     agentNotes: agentNotes || (existsSync(join(dir, "agent.md")) ? readFileSync(join(dir, "agent.md"), "utf8") : undefined),
@@ -505,11 +487,8 @@ async function applyProjectArtifact({
   target = {},
   overwrite = "skip",
   workspace_root,
-  source_repo,
-  source_path,
-  source_ref,
 }) {
-  const { dir, manifest, source } = await resolveArtifactInstallation({ slug, source_repo, source_path, source_ref })
+  const { dir, manifest } = await resolveArtifactInstallation({ slug })
   const workspaceRoot = resolveWorkspaceRoot(workspace_root)
   const record = readInstallRecord(workspaceRoot)
   const previousEntries = (record.artifacts || []).filter((item) => item.slug === manifest.slug && item.version === manifest.version)
@@ -525,11 +504,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 +530,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 +565,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 +603,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),
   )
@@ -646,7 +650,6 @@ async function applyProjectArtifact({
   return {
     ok: true,
     operation: "apply",
-    source,
     slug: manifest.slug,
     version: manifest.version,
     workspaceRoot,
@@ -689,7 +692,7 @@ async function applyProjectArtifact({
 
 export const manageProjectArtifactTool = {
   name: "manage_project_artifact",
-  description: "Inspect or install a project artifact into the workspace. Call search_project_artifacts first, then pass the exact slug; the platform resolves GitHub source server-side. Apply never executes SQL, publishes backend, deploys frontend, or installs npm packages.",
+  description: "Inspect or install a project artifact into the workspace. Call search_project_artifacts first, then pass the exact slug. Apply copies files into the workspace; it never executes SQL, publishes backend, deploys frontend, or installs npm packages.",
   inputSchema: {
     type: "object",
     properties: {
@@ -741,11 +744,7 @@ export const searchProjectArtifactsTool = {
     type: "object",
     properties: {
       query: { type: "string", description: "Natural language need, e.g. 'hero section for a florist landing'." },
-      surface: { type: "string", enum: ["public", "private", "mixed", "agnostic"], description: "Optional surface filter." },
-      kind: { type: "string", enum: ["shell", "feature"], description: "Optional kind filter. Studio normally uses feature artifacts." },
-      compatible_shell: { type: "string", description: "Optional shell slug compatibility filter." },
-      frontend_only: { type: "boolean", default: true, description: "When true, return only frontend/UI artifacts safe to install in Studio." },
-      limit: { type: "integer", default: 20, minimum: 1, maximum: 50 },
+      limit: { type: "integer", default: 3, minimum: 1, maximum: 5 },
     },
     required: ["query"],
   },