@dypai-ai/mcp 1.0.10 → 1.1.0

package/src/tools/project-context.js

@@ -0,0 +1,84 @@
+/**
+ * Auto-inject project_id into tool calls that accept it.
+ *
+ * The agent shouldn't have to pass project_id manually on every call —
+ * the local MCP already knows it from dypai/dypai.config.yaml. This keeps
+ * the remote MCP's metrics and permission layer happy without polluting
+ * the agent-facing API.
+ *
+ * Strategy:
+ *   1. Detect the dypai/ folder near the workspace (env vars + walk up).
+ *   2. Parse dypai.config.yaml once, cache the resolved project_id in memory.
+ *   3. For remote tool calls: if the tool's inputSchema declares project_id
+ *      and the caller didn't pass one, inject the cached value.
+ */
+
+import { readFileSync, existsSync } from "fs"
+import { join, isAbsolute, dirname, delimiter } from "path"
+import { homedir } from "os"
+import YAML from "yaml"
+
+let _cached = null  // { projectId, configPath } | null
+let _resolved = false
+
+function findDypaiFolder() {
+  const envCandidates = [
+    process.env.CLAUDE_PROJECT_DIR,
+    process.env.DYPAI_WORKSPACE_ROOT,
+    process.env.WORKSPACE_FOLDER_PATHS?.split(delimiter)[0],
+    process.env.PROJECT_ROOT,
+  ].filter(v => v && isAbsolute(v))
+
+  for (const base of envCandidates) {
+    const candidate = join(base, "dypai")
+    if (existsSync(join(candidate, "dypai.config.yaml"))) return candidate
+    if (existsSync(join(base, "dypai.config.yaml"))) return base
+  }
+
+  let cursor = process.cwd()
+  const home = homedir()
+  for (let i = 0; i < 8; i++) {
+    const candidate = join(cursor, "dypai")
+    if (existsSync(join(candidate, "dypai.config.yaml"))) return candidate
+    if (cursor === home || cursor === "/") break
+    const parent = dirname(cursor)
+    if (parent === cursor) break
+    cursor = parent
+  }
+  return null
+}
+
+function resolveProjectId() {
+  if (_resolved) return _cached
+  _resolved = true
+  try {
+    const dypaiDir = findDypaiFolder()
+    if (!dypaiDir) return null
+    const configPath = join(dypaiDir, "dypai.config.yaml")
+    const raw = readFileSync(configPath, "utf8")
+    const doc = YAML.parse(raw)
+    if (doc?.project_id) {
+      _cached = { projectId: doc.project_id, configPath }
+      return _cached
+    }
+  } catch { /* missing or malformed → silent */ }
+  return null
+}
+
+/** Force re-read on next lookup (useful after dypai_pull creates/updates the config). */
+export function invalidateProjectContext() {
+  _resolved = false
+  _cached = null
+}
+
+/**
+ * Inject project_id into args if the tool's schema declares it and the caller
+ * didn't provide one. No-op otherwise. Never overwrites an explicit value.
+ */
+export function withProjectContext(toolDef, args) {
+  if (!toolDef?.inputSchema?.properties?.project_id) return args
+  if (args?.project_id) return args
+  const ctx = resolveProjectId()
+  if (!ctx) return args
+  return { ...args, project_id: ctx.projectId }
+}

package/src/tools/proxy.js

@@ -115,13 +115,21 @@ export async function proxyToolCall(toolName, args) {
 
   // Extract result from JSON-RPC response
   if (response.result) {
-    const content = response.result.content
-    if (Array.isArray(content) && content[0]?.text) {
-      try {
-        return JSON.parse(content[0].text)
-      } catch {
-        return content[0].text
+    const { content, isError } = response.result
+    const text = Array.isArray(content) && content[0]?.text ? content[0].text : null
+
+    if (isError) {
+      throw new Error(text || "Remote tool call failed with isError=true")
+    }
+
+    if (text != null) {
+      let parsed
+      try { parsed = JSON.parse(text) } catch { parsed = text }
+      // Some remote errors come as a plain string without isError flag
+      if (typeof parsed === "string" && /^(Error:|Input validation error:|You don't have)/i.test(parsed)) {
+        throw new Error(parsed)
       }
+      return parsed
     }
     return response.result
   }

package/src/tools/sql-side-effects.js

@@ -0,0 +1,97 @@
+/**
+ * Side effects we run client-side after a remote `execute_sql` succeeds.
+ *
+ * Right now: if the SQL was schema-affecting DDL on public.*, re-dump the
+ * public schema and overwrite local dypai/schema.sql so the validator
+ * doesn't give false "table not found" errors on the next check.
+ *
+ * Runs synchronously (the caller awaits) so the agent can trust the state.
+ */
+
+import { existsSync } from "fs"
+import { writeFile } from "fs/promises"
+import { join, isAbsolute, dirname, delimiter } from "path"
+import { homedir } from "os"
+import { dumpPublicSchema } from "./sync/schema-dump.js"
+import { regenerateTypes } from "./codegen.js"
+
+// Matches CREATE/ALTER/DROP/TRUNCATE/RENAME on TABLE — the only DDL shapes we
+// currently reflect in schema.sql. CREATE INDEX / FUNCTION / TYPE are skipped.
+const SCHEMA_AFFECTING_DDL = /\b(CREATE|ALTER|DROP|TRUNCATE|RENAME)\s+TABLE\b/i
+
+/** Detect whether a SQL statement would change what schema.sql captures. */
+export function affectsPublicSchema(sql) {
+  if (!sql || typeof sql !== "string") return false
+  return SCHEMA_AFFECTING_DDL.test(sql)
+}
+
+/**
+ * Find the dypai/ folder near the current workspace. We follow the same
+ * signals as pull.js so users don't have to configure twice:
+ *   1. CLAUDE_PROJECT_DIR / WORKSPACE_FOLDER_PATHS env vars
+ *   2. Walk up from cwd looking for a dypai/ folder that contains schema.sql
+ */
+function findDypaiFolder() {
+  const envCandidates = [
+    process.env.CLAUDE_PROJECT_DIR,
+    process.env.DYPAI_WORKSPACE_ROOT,
+    process.env.WORKSPACE_FOLDER_PATHS?.split(delimiter)[0],
+    process.env.PROJECT_ROOT,
+  ].filter(v => v && isAbsolute(v))
+
+  for (const base of envCandidates) {
+    const candidate = join(base, "dypai")
+    if (existsSync(join(candidate, "schema.sql"))) return candidate
+    // Maybe the user already opened directly into the dypai folder
+    if (existsSync(join(base, "schema.sql")) && existsSync(join(base, "endpoints"))) return base
+  }
+
+  // Walk up from cwd
+  let cursor = process.cwd()
+  const home = homedir()
+  for (let i = 0; i < 8; i++) {
+    const candidate = join(cursor, "dypai")
+    if (existsSync(join(candidate, "schema.sql"))) return candidate
+    if (cursor === home || cursor === "/") break
+    const parent = dirname(cursor)
+    if (parent === cursor) break
+    cursor = parent
+  }
+
+  return null
+}
+
+/**
+ * After a successful execute_sql, rewrite dypai/schema.sql if the query
+ * affected the schema AND a dypai/ folder is present locally.
+ * Returns { refreshed: boolean, path?: string, reason?: string, error?: string }.
+ */
+export async function maybeRefreshSchemaAfterExecuteSql(args, result) {
+  if (result?.isError) return { refreshed: false, reason: "execute_sql failed" }
+  const sql = args?.sql
+  if (!affectsPublicSchema(sql)) return { refreshed: false, reason: "non-DDL query" }
+
+  const dypaiDir = findDypaiFolder()
+  if (!dypaiDir) return { refreshed: false, reason: "no local dypai/ folder found" }
+
+  try {
+    const newSchema = await dumpPublicSchema(args.project_id)
+    const target = join(dypaiDir, "schema.sql")
+    await writeFile(target, newSchema, "utf8")
+
+    // Schema changed → frontend TS types need to follow. Best-effort.
+    let codegen
+    try { codegen = await regenerateTypes(dypaiDir) }
+    catch (e) { codegen = { skipped: true, reason: e.message } }
+
+    return {
+      refreshed: true,
+      path: target,
+      types_regenerated: !!codegen?.regenerated,
+      types_output: codegen?.output_dir,
+    }
+  } catch (e) {
+    // Don't fail the execute_sql call itself — just report the side-effect failure.
+    return { refreshed: false, error: e.message }
+  }
+}

package/src/tools/sync/codec.js

@@ -0,0 +1,185 @@
+/**
+ * Endpoint-level codec: DB row ↔ YAML doc.
+ *
+ * The bidirectional field transforms live in transforms.js. This module
+ * handles the structural shape: nodes, edges, triggers, workflow_code wrapping.
+ *
+ * Exports:
+ *   serializeEndpoint(row, mapsCtx)   → { doc, extractedFiles }
+ *   deserializeEndpoint(doc, mapsCtx) → row-shaped object
+ *
+ * "row" is the DB row shape (workflow_code as object, not string).
+ * "doc" is the YAML-ready declarative object.
+ */
+
+import { pullNodeParams, pushNodeParams } from "./transforms.js"
+
+// ─── Triggers (execution_config.triggers ↔ doc.trigger) ─────────────────────
+
+function triggersToYaml(triggers = {}) {
+  const out = {}
+  for (const [kind, cfg] of Object.entries(triggers)) {
+    if (!cfg) continue
+    if (kind === "http_api" && cfg.enabled !== false) {
+      out.http_api = { auth_mode: cfg.auth_mode || "jwt" }
+    } else if (kind === "webhook" && cfg.enabled) {
+      out.webhook = { path: cfg.path || "" }
+    } else if (kind === "schedule" && cfg.enabled) {
+      const s = { cron: cfg.cron }
+      if (cfg.timezone) s.timezone = cfg.timezone
+      out.schedule = s
+    } else if (kind === "manual" && cfg.enabled) {
+      out.manual = true
+    }
+  }
+  if (!Object.keys(out).length) out.http_api = { auth_mode: "jwt" }
+  return out
+}
+
+function triggersToDb(trigger = {}) {
+  // Default: http_api jwt enabled, others disabled
+  const out = {
+    webhook: { path: "", enabled: false },
+    http_api: { enabled: true, auth_mode: "jwt" },
+    schedule: { enabled: false },
+  }
+  if (trigger.http_api) {
+    out.http_api = { enabled: true, auth_mode: trigger.http_api.auth_mode || "jwt" }
+  } else if (trigger.webhook || trigger.schedule || trigger.manual) {
+    // Non-HTTP trigger: disable http_api
+    out.http_api = { enabled: false, auth_mode: "jwt" }
+  }
+  if (trigger.webhook) {
+    out.webhook = { path: trigger.webhook.path || "", enabled: true }
+  }
+  if (trigger.schedule) {
+    out.schedule = { ...trigger.schedule, enabled: true }
+  }
+  if (trigger.manual) {
+    out.manual = { enabled: true }
+  }
+  return out
+}
+
+// ─── Edges (source/target ↔ from/to) ────────────────────────────────────────
+
+function edgesToYaml(edges = []) {
+  return edges.map(e => {
+    const out = { from: e.source, to: e.target }
+    if (e.condition) out.condition = e.condition
+    if (e.source_handle) out.source_handle = e.source_handle
+    if (e.target_handle) out.target_handle = e.target_handle
+    return out
+  })
+}
+
+function edgesToDb(edges = []) {
+  return edges.map(e => {
+    const out = { source: e.from, target: e.to }
+    if (e.condition) out.condition = e.condition
+    if (e.source_handle) out.source_handle = e.source_handle
+    if (e.target_handle) out.target_handle = e.target_handle
+    return out
+  })
+}
+
+// ─── Public codec ───────────────────────────────────────────────────────────
+
+export function serializeEndpoint(row, mapsCtx) {
+  const wf = row.workflow_code || {}
+  const extractedFiles = []
+  const emitFile = (path, content) => extractedFiles.push({ path, content })
+
+  // Pre-count nodes that produce extracted files — used to decide flat vs dotted filenames
+  const rawNodes = wf.nodes || []
+  const sqlNodeCount = rawNodes.filter(n => n.node_type === "dypai_database" && n.parameters?.query).length
+  const promptNodeCount = rawNodes.filter(n => n.node_type === "agent" && n.parameters?.system_prompt).length
+  const codeNodeCount = rawNodes.filter(n =>
+    (n.node_type === "javascript_code" || n.node_type === "python_code") && n.parameters?.code
+  ).length
+
+  const nodes = rawNodes.map(node => {
+    const nodeCtx = {
+      ...mapsCtx,
+      endpointName: row.name,
+      nodeId: node.id,
+      nodeType: node.node_type,
+      emitFile,
+      sqlNodeCount,
+      promptNodeCount,
+      codeNodeCount,
+    }
+    const transformedParams = pullNodeParams(node.parameters || {}, nodeCtx, node.node_type)
+
+    const clean = { id: node.id, type: node.node_type }
+    if (node.variable && node.variable !== node.id) clean.variable = node.variable
+    if (node.is_return) clean.return = true
+    Object.assign(clean, transformedParams)
+    return clean
+  })
+
+  const doc = { name: row.name, method: row.method || "GET" }
+  if (row.description) doc.description = row.description
+  if (row.group_id && mapsCtx.groupIdToName[row.group_id]) {
+    doc.group = mapsCtx.groupIdToName[row.group_id]
+  }
+  if (row.is_tool) {
+    doc.tool = true
+    if (row.tool_description) doc.tool_description = row.tool_description
+  }
+  if (row.allowed_roles && row.allowed_roles.length) {
+    doc.allowed_roles = row.allowed_roles
+  }
+  if (row.input) doc.input = row.input
+  if (row.output) doc.output = row.output
+  doc.trigger = triggersToYaml(wf.execution_config?.triggers)
+
+  const workflow = { nodes }
+  const edges = edgesToYaml(wf.edges)
+  if (edges.length) workflow.edges = edges
+  if (wf.on_error && wf.on_error !== "stop") workflow.on_error = wf.on_error
+  doc.workflow = workflow
+
+  return { doc, extractedFiles }
+}
+
+export function deserializeEndpoint(doc, mapsCtx) {
+  const readFile = mapsCtx.readFile || (() => "")
+
+  const nodes = (doc.workflow?.nodes || []).map(clean => {
+    const { id, type, variable, return: isReturn, ...params } = clean
+    const nodeCtx = {
+      ...mapsCtx,
+      endpointName: doc.name,
+      nodeId: id,
+      readFile,
+    }
+    const transformedParams = pushNodeParams(params, nodeCtx, type)
+
+    const node = { id, node_type: type, parameters: transformedParams }
+    if (variable) node.variable = variable
+    if (isReturn) node.is_return = true
+    return node
+  })
+
+  const workflow_code = {
+    nodes,
+    edges: edgesToDb(doc.workflow?.edges),
+    execution_config: { triggers: triggersToDb(doc.trigger) },
+    schema_version: "2.0",
+  }
+  if (doc.workflow?.on_error) workflow_code.on_error = doc.workflow.on_error
+
+  return {
+    name: doc.name,
+    method: doc.method || "GET",
+    description: doc.description || null,
+    workflow_code,
+    input: doc.input || null,
+    output: doc.output || null,
+    allowed_roles: doc.allowed_roles || [],
+    is_tool: !!doc.tool,
+    tool_description: doc.tool_description || null,
+    group_id: doc.group && mapsCtx.groupNameToId ? (mapsCtx.groupNameToId[doc.group] || null) : null,
+  }
+}

package/src/tools/sync/describe.js

@@ -0,0 +1,149 @@
+/**
+ * dypai_describe — one-shot project snapshot for AI agents.
+ *
+ * Returns everything the agent needs to understand a project in a single call:
+ * tables, endpoints, credentials, roles, buckets, SDK config, and suggested
+ * next steps. Designed to replace the 5-6 discovery calls a cold agent has to
+ * make at the start of every session.
+ *
+ * This is the "boot" call. Run it first, get the lay of the land, then act.
+ */
+
+import { proxyToolCall } from "../proxy.js"
+
+async function execSql(projectId, sql) {
+  const args = projectId ? { project_id: projectId, sql } : { sql }
+  const result = await proxyToolCall("execute_sql", args)
+  if (result?.error) return null
+  if (!result?.rows) return null
+  return result.rows
+}
+
+export const dypaiDescribeTool = {
+  name: "dypai_describe",
+  description:
+    "ALWAYS RUN FIRST when working on a DYPAI project you haven't seen yet. " +
+    "Returns a one-shot snapshot: tables, endpoints (with groups + tools), credentials, " +
+    "roles, buckets, SDK config, and suggested next steps. Replaces 5-6 discovery calls. " +
+    "Complementary to dypai_pull (which materializes files locally) — describe just reads.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: {
+        type: "string",
+        description: "Project UUID. Optional if your token is project-scoped.",
+      },
+    },
+  },
+
+  async execute({ project_id } = {}) {
+    const [tables, endpoints, creds, roles, buckets, project] = await Promise.all([
+      execSql(project_id, `
+        SELECT c.table_name,
+               COUNT(*) AS column_count,
+               BOOL_OR(c.column_name = 'user_id') AS has_user_id,
+               BOOL_OR(c.column_name IN ('created_at','updated_at')) AS has_timestamps
+        FROM information_schema.columns c
+        WHERE c.table_schema = 'public'
+        GROUP BY c.table_name
+        ORDER BY c.table_name
+      `),
+      execSql(project_id, `
+        SELECT e.name, e.method, e.is_tool, e.tool_description,
+               e.allowed_roles, g.name AS group_name,
+               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"),
+      execSql(project_id, "SELECT name, description FROM system.roles ORDER BY name"),
+      execSql(project_id, `
+        SELECT id, name, public FROM storage.buckets ORDER BY name
+      `).catch(() => null),
+      project_id ? proxyToolCall("get_project", { project_id }).catch(() => null) : null,
+    ])
+
+    // Aggregate groups
+    const groupSet = new Set((endpoints || []).map(e => e.group_name).filter(Boolean))
+    const toolEndpoints = (endpoints || []).filter(e => e.is_tool).map(e => ({
+      name: e.name,
+      description: e.tool_description || null,
+    }))
+
+    // Next steps chosen based on project state
+    const nextSteps = []
+    if (!endpoints || endpoints.length === 0) {
+      nextSteps.push("Project is empty. Run dypai_pull to create ./dypai/, then add endpoints in endpoints/<name>.yaml")
+    } else {
+      nextSteps.push("Run dypai_pull to materialize ./dypai/ locally (endpoints, SQL, code)")
+      nextSteps.push("Read dypai/schema.sql for DB structure when writing queries")
+      nextSteps.push("Edit dypai/endpoints/<name>.yaml, then dypai_diff → dypai_push")
+    }
+    if (toolEndpoints.length > 0) {
+      nextSteps.push(`${toolEndpoints.length} tool endpoints exist — agents can call them via tools: [...] in agent nodes`)
+    }
+
+    return {
+      success: true,
+      project: project ? {
+        id: project.id,
+        name: project.name,
+        engine_url: project.engine_url,
+        plan: project.plan,
+      } : { id: project_id || "(from token)" },
+
+      database: {
+        table_count: (tables || []).length,
+        tables: (tables || []).map(t => ({
+          name: t.table_name,
+          columns: Number(t.column_count),
+          has_user_id: t.has_user_id,
+          has_timestamps: t.has_timestamps,
+        })),
+      },
+
+      endpoints: {
+        total: (endpoints || []).length,
+        groups: [...groupSet].sort(),
+        by_group: (endpoints || []).reduce((acc, e) => {
+          const g = e.group_name || "(no group)"
+          if (!acc[g]) acc[g] = []
+          acc[g].push({ name: e.name, method: e.method, nodes: Number(e.node_count), is_tool: e.is_tool })
+          return acc
+        }, {}),
+        tool_endpoints: toolEndpoints,
+      },
+
+      credentials: (creds || []).map(c => ({ name: c.name, type: c.type })),
+
+      roles: (roles || []).map(r => ({ name: r.name, description: r.description })),
+
+      buckets: (buckets || []).map(b => ({ name: b.name, public: b.public })),
+
+      placeholders_available: [
+        "${input.<field>}  — request body / query params",
+        "${nodes.<node_id>.<field>}  — output of a previous node",
+        "${current_user_id}  — uuid of the authenticated user (jwt auth only)",
+        "${current_user_role}  — role name of the authenticated user",
+      ],
+
+      common_node_types: [
+        "dypai_database  — SQL queries / inserts / updates",
+        "dypai_storage   — file upload / download / delete",
+        "agent           — LLM call with tools",
+        "javascript_code — custom JS logic (async function main(data, ctx))",
+        "set_fields      — shape output / map values",
+        "http_request    — call external APIs",
+        "logic           — conditional branching",
+      ],
+
+      next_steps: nextSteps,
+
+      hint: (endpoints || []).length > 0
+        ? "This project has existing endpoints. Run dypai_pull to edit them, or use search_endpoints for quick inspection."
+        : "This is a fresh project. Create tables first with execute_sql, then add endpoints via dypai_push after creating YAMLs.",
+    }
+  },
+}

package/src/tools/sync/diff.js

@@ -0,0 +1,83 @@
+/**
+ * dypai_diff — preview what dypai_push would change. Read-only, safe.
+ */
+
+import { resolve as resolvePath } from "path"
+import { fetchRemoteState, readLocalState, readLocalStateSnapshot, readLocalConfig, computePlan } from "./planner.js"
+
+export const dypaiDiffTool = {
+  name: "dypai_diff",
+  description:
+    "Compare the local ./dypai/ folder against the remote project state without applying anything. " +
+    "Returns a plan: endpoints to create, update (with changed fields), delete, and unchanged. " +
+    "Always call this before dypai_push to preview changes safely.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: {
+        type: "string",
+        description: "Project UUID. Optional if your token is project-scoped.",
+      },
+      root_dir: {
+        type: "string",
+        description: "Root of the dypai/ folder (default: ./dypai).",
+        default: "./dypai",
+      },
+      delete_orphans: {
+        type: "boolean",
+        description: "If true, endpoints present in remote but missing locally are queued for deletion. Default: false (safe).",
+        default: false,
+      },
+    },
+  },
+
+  async execute({ project_id, root_dir = "./dypai", delete_orphans = false } = {}) {
+    const rootDir = resolvePath(process.cwd(), root_dir)
+
+    const config = await readLocalConfig(rootDir)
+    const targetProjectId = project_id || config?.project_id || null
+
+    const [local, remote, stateSnapshot] = await Promise.all([
+      readLocalState(rootDir),
+      fetchRemoteState(targetProjectId),
+      readLocalStateSnapshot(rootDir),
+    ])
+
+    if (local.errors.length) {
+      return {
+        success: false,
+        phase: "read_local",
+        errors: local.errors,
+        hint: "Fix the YAML/file errors before running diff again.",
+      }
+    }
+
+    const plan = computePlan(local, remote, remote.mapsCtx, {
+      deleteOrphans: delete_orphans,
+      stateSnapshot,
+    })
+
+    const totalChanges = plan.create.length + plan.update.length + plan.delete.length
+    const hasConflicts = (plan.warnings || []).some(w => w.type === "remote_changed_since_pull")
+
+    return {
+      success: true,
+      summary: {
+        create: plan.create.length,
+        update: plan.update.length,
+        delete: plan.delete.length,
+        unchanged: plan.unchanged.length,
+        orphans_ignored: plan.orphansIgnored?.length || 0,
+        warnings: plan.warnings?.length || 0,
+      },
+      // Only include plan details when there are actual changes or warnings
+      plan: (totalChanges > 0 || plan.warnings?.length) ? plan : undefined,
+      // Conflicts and missing creds deserve surfacing; no-op diffs don't
+      hint: hasConflicts
+        ? "Remote changed since your last pull — dypai_pull first, or dypai_push will be blocked."
+        : (plan.warnings || []).some(w => w.type === "missing_credential")
+          ? "Some YAMLs reference credentials missing remotely. Create them in the dashboard before pushing."
+          : undefined,
+    }
+  },
+}

package/src/tools/sync/index.js

@@ -0,0 +1,18 @@
+/**
+ * Git-first source-of-truth tooling for DYPAI projects.
+ *
+ * Architecture:
+ *   transforms.js — bidirectional field transforms (symmetric by construction)
+ *   codec.js      — endpoint-level serialize / deserialize (structural shape)
+ *   pull.js       — DB → filesystem (uses codec.serializeEndpoint)
+ *   push.js       — filesystem → DB (uses codec.deserializeEndpoint)  [pending]
+ *   diff.js       — compares both sides without writing                [pending]
+ */
+
+export { dypaiPullTool } from "./pull.js"
+export { dypaiDiffTool } from "./diff.js"
+export { dypaiPushTool } from "./push.js"
+export { dypaiDescribeTool } from "./describe.js"
+export { dypaiValidateTool } from "./validate.js"
+export { dypaiTestTool } from "./test.js"
+export { dypaiTestEndpointTool } from "./test-endpoint.js"