@dypai-ai/mcp 1.3.0 → 1.3.1

package/package.json

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

package/src/index.js

@@ -817,7 +817,7 @@ async function handleRequest(msg) {
     return makeResponse(id, {
       protocolVersion: "2024-11-05",
       capabilities: { tools: {} },
-      serverInfo: { name: "dypai", version: "1.3.0" },
+      serverInfo: { name: "dypai", version: "1.3.1" },
       instructions: SERVER_INSTRUCTIONS,
     })
   }

package/src/tools/sync/describe.js

@@ -12,7 +12,10 @@
 import { proxyToolCall } from "../proxy.js"
 
 async function execSql(projectId, sql) {
-  const args = projectId ? { project_id: projectId, sql } : { sql }
+  // Bypass remote execute_sql auto-LIMIT 20 so describe counts match reality.
+  const hasLimit = /\bLIMIT\b/i.test(sql)
+  const finalSql = hasLimit ? sql : `${sql.replace(/;?\s*$/, "")} LIMIT 100000`
+  const args = projectId ? { project_id: projectId, sql: finalSql } : { sql: finalSql }
   const result = await proxyToolCall("execute_sql", args)
   if (result?.error) return null
   if (!result?.rows) return null
@@ -54,7 +57,6 @@ export const dypaiDescribeTool = {
                jsonb_array_length(e.workflow_code->'nodes') AS node_count
         FROM system.endpoints e
         LEFT JOIN system.endpoints_group g ON g.id = e.group_id
-        WHERE e.is_active = true
         ORDER BY e.name
       `),
       execSql(project_id, "SELECT name, type FROM system.credentials ORDER BY name"),

package/src/tools/sync/planner.js

@@ -17,7 +17,13 @@ import { deserializeEndpoint, serializeEndpoint } from "./codec.js"
 // ─── Remote ────────────────────────────────────────────────────────────────
 
 async function execSql(projectId, sql) {
-  const args = projectId ? { project_id: projectId, sql } : { sql }
+  // Bypass the remote execute_sql safety that injects `LIMIT 20` when no LIMIT
+  // is present. Planner needs the FULL endpoint/credential/group lists to
+  // compute an accurate diff — truncation here would mean invisible deletes
+  // (local thinks "remote has only X" when it actually has X+N).
+  const hasLimit = /\bLIMIT\b/i.test(sql)
+  const finalSql = hasLimit ? sql : `${sql.replace(/;?\s*$/, "")} LIMIT 100000`
+  const args = projectId ? { project_id: projectId, sql: finalSql } : { sql: finalSql }
   const result = await proxyToolCall("execute_sql", args)
   if (result?.error) throw new Error(`SQL error: ${result.error}`)
   if (!result?.rows) throw new Error(`Unexpected SQL response: ${JSON.stringify(result).slice(0, 300)}`)
@@ -116,9 +122,8 @@ export async function fetchRemoteState(projectId) {
   const [endpoints, credentials, groups] = await Promise.all([
     execSql(projectId, `
       SELECT id, name, method, description, workflow_code, input, output,
-             allowed_roles, is_tool, tool_description, group_id, updated_at
+             allowed_roles, is_tool, tool_description, group_id, is_active, updated_at
       FROM system.endpoints
-      WHERE is_active = true
       ORDER BY name
     `),
     execSql(projectId, "SELECT id, name, type FROM system.credentials"),

package/src/tools/sync/pull.js

@@ -441,7 +441,15 @@ workflow:
 `
 
 async function execSql(projectId, sql) {
-  const args = projectId ? { project_id: projectId, sql } : { sql }
+  // The remote `execute_sql` silently injects `LIMIT 20` whenever a query has no
+  // LIMIT of its own — intended as a guard against ad-hoc queries returning
+  // gigantic result sets. For pull we want the COMPLETE lists of endpoints,
+  // credentials, groups, realtime policies, etc. Without an explicit LIMIT
+  // here, a project with >20 of any resource would silently lose rows.
+  // We append a generous cap (100k) only when the caller didn't specify one.
+  const hasLimit = /\bLIMIT\b/i.test(sql)
+  const finalSql = hasLimit ? sql : `${sql.replace(/;?\s*$/, "")} LIMIT 100000`
+  const args = projectId ? { project_id: projectId, sql: finalSql } : { sql: finalSql }
   const result = await proxyToolCall("execute_sql", args)
   if (result?.error) throw new Error(`SQL error: ${result.error}`)
   if (!result?.rows) {
@@ -553,9 +561,8 @@ export const dypaiPullTool = {
     const [endpoints, credentials, groups, schemaSql, nodeCatalogResult, realtimePolicies] = await Promise.all([
       execSql(project_id, `
         SELECT id, name, method, description, workflow_code, input, output,
-               allowed_roles, is_tool, tool_description, group_id, updated_at
+               allowed_roles, is_tool, tool_description, group_id, is_active, updated_at
         FROM system.endpoints
-        WHERE is_active = true
         ORDER BY name
       `),
       execSql(project_id, "SELECT id, name, type FROM system.credentials"),
@@ -650,7 +657,22 @@ export const dypaiPullTool = {
         const relPath = groupName
           ? `endpoints/${groupName}/${row.name}.yaml`
           : `endpoints/${row.name}.yaml`
-        await writeFileEnsured(join(outDir, relPath), renderYaml(doc))
+
+        // Inactive endpoints ARE pulled (user needs to see them), but flagged
+        // with a visible header so the agent/user knows the endpoint won't
+        // execute until re-enabled in the dashboard. `is_active` isn't
+        // serialized into the YAML itself — push only updates content, never
+        // the active flag, so editing + pushing an inactive endpoint keeps it
+        // inactive (safe default).
+        const yamlBody = renderYaml(doc)
+        const content = row.is_active === false
+          ? "# ⚠️ INACTIVE on the engine — this endpoint will NOT execute until re-enabled in the dashboard.\n" +
+            "# Edits applied via `dypai_push` are still saved, but the endpoint stays paused.\n" +
+            "# To reactivate: go to the project dashboard → Endpoints → toggle this one back on.\n\n" +
+            yamlBody
+          : yamlBody
+
+        await writeFileEnsured(join(outDir, relPath), content)
         filesWritten.push(relPath)
       } catch (e) {
         errors.push({ endpoint: row.name, error: e.message })
@@ -730,6 +752,9 @@ export const dypaiPullTool = {
     const toolEndpoints = (endpoints || [])
       .filter(e => e.is_tool)
       .map(e => ({ name: e.name, description: e.tool_description || null }))
+    const inactiveEndpoints = (endpoints || [])
+      .filter(e => e.is_active === false)
+      .map(e => e.name)
 
     const overview = {
       project: projectInfo ? {
@@ -739,9 +764,12 @@ export const dypaiPullTool = {
       } : { id: resolvedProjectId || "(from token)" },
       endpoints: {
         total: (endpoints || []).length,
+        active: (endpoints || []).filter(e => e.is_active !== false).length,
+        inactive: inactiveEndpoints.length,
         groups: Object.keys(byGroup).filter(g => g !== "(no group)").sort(),
         by_group: byGroup,
         tool_endpoints: toolEndpoints,
+        inactive_endpoints: inactiveEndpoints.length > 0 ? inactiveEndpoints : undefined,
       },
       credentials: (credentials || []).map(c => ({ name: c.name, type: c.type })),
       realtime_policies: (realtimePolicies || []).length,

package/src/tools/sync/schema-dump.js

@@ -7,7 +7,13 @@
 import { proxyToolCall } from "../proxy.js"
 
 async function execSql(projectId, sql) {
-  const args = projectId ? { project_id: projectId, sql } : { sql }
+  // Bypass remote execute_sql auto-LIMIT 20 so the schema dump is complete.
+  // Without this, a project with >20 columns across public.* (very normal)
+  // would produce a truncated schema.sql silently — breaks the validator and
+  // any agent that reads schema.sql before writing SQL.
+  const hasLimit = /\bLIMIT\b/i.test(sql)
+  const finalSql = hasLimit ? sql : `${sql.replace(/;?\s*$/, "")} LIMIT 100000`
+  const args = projectId ? { project_id: projectId, sql: finalSql } : { sql: finalSql }
   const result = await proxyToolCall("execute_sql", args)
   if (result?.error) throw new Error(`SQL error: ${result.error}`)
   if (!result?.rows) throw new Error(`Unexpected SQL response: ${JSON.stringify(result).slice(0, 300)}`)