@ductape/mcp 0.2.18 → 0.2.20

package/dist/action-contract.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeLiveActionContract(value: unknown): unknown;
+//# sourceMappingURL=action-contract.d.ts.map

package/dist/action-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-contract.d.ts","sourceRoot":"","sources":["../src/action-contract.ts"],"names":[],"mappings":"AAiFA,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAYnE"}

package/dist/action-contract.js

@@ -0,0 +1,109 @@
+function parseSample(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function legacyPairs(value) {
+    const parsed = parseSample(value);
+    if (!Array.isArray(parsed))
+        return null;
+    const result = {};
+    for (const item of parsed) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const key = String(item.key ?? '').trim();
+        if (key)
+            result[key] = item.value;
+    }
+    return Object.keys(result).length ? result : null;
+}
+function schemaType(value) {
+    const type = String(value ?? '').toLowerCase();
+    if (type.includes('bool'))
+        return 'boolean';
+    if (type.includes('int') || type.includes('number') || type.includes('float') || type.includes('double'))
+        return 'number';
+    if (type.includes('array'))
+        return 'array';
+    if (type.includes('object') || type === 'json')
+        return 'object';
+    if (type.includes('string') || type.includes('email') || type.includes('date') || type.includes('uuid') || type.includes('space'))
+        return 'string';
+    return undefined;
+}
+function schemaFromLocation(value) {
+    const location = value && typeof value === 'object' ? value : {};
+    const parsedSample = parseSample(location.sample);
+    const legacyRows = Array.isArray(parsedSample) ? parsedSample : [];
+    const sample = legacyPairs(location.sample) ?? parsedSample;
+    const rows = Array.isArray(location.data) ? location.data : [];
+    const properties = {};
+    const required = [];
+    for (const row of rows) {
+        if (!row || typeof row !== 'object')
+            continue;
+        const item = row;
+        if (Number(item.level ?? 0) > 0 || String(item.parent_key ?? '').trim())
+            continue;
+        const key = String(item.key ?? item.name ?? '').trim();
+        if (!key)
+            continue;
+        const property = {};
+        const type = schemaType(item.type);
+        if (type)
+            property.type = type;
+        if (item.description)
+            property.description = String(item.description);
+        if (item.sampleValue !== undefined && item.sampleValue !== '')
+            property.example = item.sampleValue;
+        properties[key] = property;
+        if (item.required === true)
+            required.push(key);
+    }
+    for (const row of legacyRows) {
+        if (!row || typeof row !== 'object')
+            continue;
+        const item = row;
+        const key = String(item.key ?? '').trim();
+        if (!key || properties[key])
+            continue;
+        const description = String(item.description ?? '').trim();
+        properties[key] = {
+            type: 'string',
+            ...(description ? { description } : {}),
+            ...(item.value !== undefined ? { example: item.value } : {}),
+        };
+        if (/\(required\)|^required\b/i.test(description))
+            required.push(key);
+    }
+    if (!Object.keys(properties).length && sample && typeof sample === 'object' && !Array.isArray(sample)) {
+        for (const [key, example] of Object.entries(sample)) {
+            properties[key] = { type: Array.isArray(example) ? 'array' : example === null ? undefined : typeof example, example };
+        }
+    }
+    return {
+        type: 'object',
+        properties,
+        ...(required.length ? { required } : {}),
+        additionalProperties: false,
+    };
+}
+export function normalizeLiveActionContract(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const action = value;
+    return {
+        ...action,
+        input_schema: {
+            body: schemaFromLocation(action.body),
+            query: schemaFromLocation(action.query),
+            params: schemaFromLocation(action.params),
+            headers: schemaFromLocation(action.headers),
+        },
+    };
+}

package/dist/index.js

@@ -15,6 +15,7 @@ import { parseCliCommand } from './cli-command.js';
 import { homedir } from 'os';
 import { delimiter, join } from 'path';
 import { z } from 'zod';
+import { normalizeLiveActionContract } from './action-contract.js';
 import { executeViaProxy, generateExecutablePayload, getAssetSchemas, } from './proxy-client.js';
 import { EVENTS_DELIVERY_SEMANTICS, EVENTS_IMPLEMENTATION_WARNING, eventsCapabilityOverview, inspectEventsComponent, searchEventsCapabilities, } from './events-capabilities.js';
 const MODULES = [
@@ -596,7 +597,7 @@ ALL params are passed as a JSON array in positional order matching the SDK signa
   fallback.dispatch [{ product: string, env: string, tag: string, input: object, session?: string, cache?: string, schedule?: { cron?: string, delay?: number, at?: string } }]  ← CALL ductape_generate_payload FIRST (operation_family="fallback", method="dispatch") — requires redisUrl in ductape initialization
 
 ━━━ MODULE: health ━━━
-  health.create   [product_tag, data: { tag: string, name: string, description?: string, app?: string, event?: string, probe?: { type: "app"|"database"|"feature", app?: string, event?: string, input?: object }, interval: number, retries: number, envs: [{ slug: string, input?: object }], onFailure?: { notifications?: [{ notification: string, message: string, channels: { email?: { recipients: string[] }, push?: { recipients?: string[] }, sms?: { recipients: string[] } } }], webhooks?: [{ url: string, method?: "GET"|"POST", headers?: object, body?: object }] } }]
+  health.create   [product_tag, data: { tag: string, name: string, description?: string, probe: { type: "app"|"database"|"feature"|"graph"|"events"|"storage"|"cache"|"vector"|"notification", app?: string, database?: string, feature?: string, graph?: string, events?: string, storage?: string, cache?: string, vector?: string, notification?: string, channels?: ("sms"|"email"|"push")[], event?: string, input?: object }, interval: number, retries: number, envs: [{ slug: string, input?: object }], onFailure?: object }]
   health.update   [product_tag, health_tag, data: { name?: string, description?: string, app?: string, event?: string, probe?: { type: "app"|"database"|"feature", app?: string, event?: string, input?: object }, interval?: number, retries?: number, envs?: [{ slug: string, input?: object }], onFailure?: object }]
   health.fetch    [product_tag, health_tag]
   health.list     [product_tag]
@@ -3134,7 +3135,7 @@ CONFIGURATION BOUNDARY
   Workbench is also supported. Never route their administrative create/update methods through
   ductape_execute: its publishable-key runtime proxy will fail.
 
-QUOTAS — rate-limited multi-provider pools:
+QUOTAS — weighted/provider-capacity routing pools (NOT request rate limiting):
   Workbench definition shape:
   {
     tag: "sms-quota",
@@ -3152,6 +3153,8 @@ QUOTAS — rate-limited multi-provider pools:
     ],
   }
   Providers are tried in order until quota is not exhausted.
+  Never use quota to protect OTP, login, or public endpoints. Use sdk.rateLimit.define/run and the
+  Nest @RateLimit + DuctapeRateLimitGuard for atomic keyed request enforcement.
   quotas.run      [{ product, env, tag, input }]  ← CALL ductape_generate_payload FIRST
   quotas.dispatch [{ product, env, tag, input, schedule? }]
 
@@ -3188,7 +3191,13 @@ HEALTHCHECKS — continuous probe with failure notifications:
   health.check  [{ product, env, tag }]   → same as run
   health.status [{ product, env, tag }]   → current health status
 
-Probe types: app | database | feature | graph | events | storage
+Probe types: app | database | feature | graph | events | storage | cache | vector | notification
+Code-first connectivity probes:
+  ctx.probe().cache("cache-tag").action("test_connection")
+  ctx.probe().vector("vector-tag").action("test_connection")
+  ctx.probe().notification("notification-tag").channels(["sms","email","push"]).action("test_connection")
+Notification test_connection validates configuration and uses non-delivering credential/account
+checks for SendGrid, Vonage/Nexmo, and Firebase. It never sends a message.
 Canonical Events probe:
   { type: "events", events: "statecraft-events", event: "health" }
 Do not create new probes with type/field message_broker or messageBroker; those names are deprecated
@@ -3225,6 +3234,7 @@ Provider status: available | unavailable
 
 DECISION MATRIX
   Rate/capacity allocation across providers       → quota
+  Request frequency keyed by actor/IP/device      → rateLimit
   Equivalent provider after operational failure   → fallback
   Detect failure before routing provider traffic  → health check
   Transient failure of one operation              → bounded retry + idempotency policy
@@ -5125,7 +5135,8 @@ function handleCliFlags() {
 }
 async function main() {
     const { McpServer, StdioServerTransport } = await loadMcpSdk();
-    const server = new McpServer({ name: 'ductape-mcp', version: '0.1.0' });
+    const { version: mcpVersion } = createRequire(import.meta.url)('../package.json');
+    const server = new McpServer({ name: 'ductape-mcp', version: mcpVersion });
     const transport = new StdioServerTransport();
     const cliHandler = async (args) => {
         const cli = checkCli();
@@ -5152,7 +5163,8 @@ async function main() {
         const isAuthCommand = firstWord === 'login' || firstWord === 'logout';
         const isLocalMigrationGuidance = (firstWord === 'migrate-codebase' && !args.command.includes('--ensure-product')) ||
             firstWord.startsWith('migration-');
-        if (!isAuthCommand && !isLocalMigrationGuidance) {
+        const isDiagnostic = firstWord === 'doctor';
+        if (!isAuthCommand && !isLocalMigrationGuidance && !isDiagnostic) {
             // Cache successful authentication, but re-check a missing/expired session on every call.
             // The user may complete `ductape login` in another terminal while this MCP process remains
             // alive; caching "none" would otherwise make the MCP blind to the newly written session.
@@ -5439,7 +5451,7 @@ async function main() {
                 const raw = response.content[0]?.type === 'text' ? response.content[0].text : '';
                 let action = raw;
                 try {
-                    action = JSON.parse(raw);
+                    action = normalizeLiveActionContract(JSON.parse(raw));
                 }
                 catch { /* Preserve the CLI diagnostic verbatim. */ }
                 return {
@@ -5514,6 +5526,11 @@ async function main() {
         }
     };
     if (typeof server.registerTool === 'function') {
+        server.registerTool('ductape_doctor', {
+            title: 'Ductape Compatibility Doctor',
+            description: 'Report CLI, SDK, NestJS, MCP, API/schema revision, authentication, workspace, and project linkage facts without exposing credentials.',
+            inputSchema: z.object({}).shape,
+        }, async () => cliHandler({ command: 'doctor --json' }));
         server.registerTool('ductape_execute', {
             title: 'Ductape SDK Execute',
             description: 'Execute a Ductape SDK RUNTIME operation via the backend proxy (publishable key).\n\n' +
@@ -5757,6 +5774,7 @@ async function main() {
         }, cliHandler);
     }
     else if (typeof server.tool === 'function') {
+        server.tool('ductape_doctor', z.object({}).shape, async () => cliHandler({ command: 'doctor --json' }));
         server.tool('ductape_execute', executeInputSchema.shape, executeHandler);
         server.tool('ductape_generate_payload', payloadGenerateInputSchema.shape, payloadGenerateHandler);
         server.tool('ductape_generate_snippet', snippetGenerateInputSchema.shape, snippetGenerateHandler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/mcp",
-  "version": "0.2.18",
+  "version": "0.2.20",
   "description": "MCP server that exposes Ductape SDK operations via the backend proxy",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && node scripts/check-cli-command-security.mjs && node scripts/check-frontend-analytics-guidance.mjs && node scripts/check-events-discovery.mjs && node scripts/check-schema-fallback.mjs && node scripts/check-portable-functions.mjs && node scripts/check-project-link-guidance.mjs && node scripts/check-graph-vector-projection-guidance.mjs",
+    "test": "npm run build && node scripts/check-cli-command-security.mjs && node scripts/check-frontend-analytics-guidance.mjs && node scripts/check-events-discovery.mjs && node scripts/check-schema-fallback.mjs && node scripts/check-paystack-action-schema.mjs && node scripts/check-portable-functions.mjs && node scripts/check-project-link-guidance.mjs && node scripts/check-graph-vector-projection-guidance.mjs",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts"
   },