@bpmnkit/proxy 0.0.26 → 0.0.27

package/dist/mcp-server.js

@@ -18,6 +18,7 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline";
 import vm from "node:vm";
 import { Bpmn, Dmn, Form, compactify, compactifyDmn, compactifyForm, expand, expandDmn, expandForm, layoutDmn, layoutProcess, } from "@bpmnkit/core";
+import { handleSdkExecute, handleSdkSearch } from "./sdk-code-mode.js";
 // ── CLI args ──────────────────────────────────────────────────────────────────
 function getArg(flag) {
     const idx = process.argv.indexOf(flag);
@@ -316,6 +317,52 @@ const BPMN_TOOLS = [
             required: ["diagram"],
         },
     },
+    {
+        name: "sdk_search",
+        description: "Inspect the @bpmnkit/core SDK to discover available functions and the CompactDiagram format.\n" +
+            "Receives `spec.functions` (available operations) and `spec.compactDiagram` (input/output shape).\n\n" +
+            "Example — list all available functions:\n" +
+            "  return Object.entries(spec.functions).map(([name, s]) => name + ': ' + s.description)\n\n" +
+            "Example — get element type list:\n" +
+            "  return spec.compactDiagram.shape.processes[0].elements[0].type",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "JavaScript returning a value. Has `spec` as a global.",
+                },
+            },
+            required: ["code"],
+        },
+    },
+    {
+        name: "sdk_execute",
+        description: "Execute JavaScript using @bpmnkit/core SDK functions. Has `sdk` with parse, exportXml, optimize, layout, analyzeVariables.\n" +
+            "All sdk functions take/return strings (XML or JSON). Pass input XML via the `xml` argument.\n" +
+            "Call sdk_search first to see function signatures and the CompactDiagram shape.\n\n" +
+            "Example — parse, optimize, and re-export:\n" +
+            "  const compact = sdk.parse(xml)\n" +
+            "  const { diagram, findings } = JSON.parse(sdk.optimize(compact))\n" +
+            "  return { findings, xml: sdk.exportXml(JSON.stringify(diagram)) }\n\n" +
+            "Example — analyze variable flow:\n" +
+            "  const compact = sdk.parse(xml)\n" +
+            "  return JSON.parse(sdk.analyzeVariables(compact))",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "JavaScript with access to `sdk` and optional `xml` global.",
+                },
+                xml: {
+                    type: "string",
+                    description: "Optional BPMN XML injected as `xml` global inside the sandbox.",
+                },
+            },
+            required: ["code"],
+        },
+    },
 ];
 const DMN_TOOLS = [
     {
@@ -507,6 +554,15 @@ function callTool(name, args) {
                 throw new Error(`Code execution failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
+        case "sdk_search": {
+            const code = args.code;
+            return handleSdkSearch(code);
+        }
+        case "sdk_execute": {
+            const code = args.code;
+            const xml = args.xml;
+            return handleSdkExecute(code, xml);
+        }
         default:
             throw new Error(`Unknown tool: ${name}`);
     }

package/dist/sandbox.js

@@ -0,0 +1,27 @@
+import ivm from "isolated-vm";
+export async function runSandboxed(code, ctx, timeoutMs = 5000) {
+    const isolate = new ivm.Isolate({ memoryLimit: 64 });
+    try {
+        const context = await isolate.createContext();
+        const jail = context.global;
+        await jail.set("global", jail.derefInto());
+        for (const [key, value] of Object.entries(ctx.data ?? {})) {
+            await jail.set(key, new ivm.ExternalCopy(value).copyInto());
+        }
+        for (const [key, fn] of Object.entries(ctx.functions ?? {})) {
+            await jail.set(key, new ivm.Reference(async (...args) => {
+                const result = await fn(...args);
+                return new ivm.ExternalCopy(result).copyInto();
+            }));
+        }
+        const fullCode = ctx.bootstrap ? `${ctx.bootstrap}\n${code}` : code;
+        return await context.evalClosure(`return (async function() {\n${fullCode}\n})()`, [], {
+            result: { promise: true, copy: true },
+            timeout: timeoutMs,
+        });
+    }
+    finally {
+        isolate.dispose();
+    }
+}
+//# sourceMappingURL=sandbox.js.map

package/dist/sdk-code-mode.js

@@ -0,0 +1,60 @@
+import vm from "node:vm";
+import { Bpmn, analyzeVariableFlow, applyAutoLayout, compactify, expand, optimize, } from "@bpmnkit/core";
+import { SDK_SPEC } from "./sdk-spec.js";
+function buildSdkContext(xml) {
+    return {
+        xml: xml ?? "",
+        sdk: {
+            parse: (rawXml) => {
+                const defs = Bpmn.parse(String(rawXml));
+                return JSON.stringify(compactify(defs));
+            },
+            exportXml: (compactJson) => {
+                const defs = expand(JSON.parse(String(compactJson)));
+                const laidOut = applyAutoLayout(defs);
+                return Bpmn.export(laidOut);
+            },
+            optimize: (compactJson) => {
+                const compact = JSON.parse(String(compactJson));
+                const defs = expand(compact);
+                const report = optimize(defs);
+                return JSON.stringify({
+                    diagram: compact,
+                    findings: report.findings,
+                });
+            },
+            layout: (compactJson) => {
+                const defs = expand(JSON.parse(String(compactJson)));
+                const laidOut = applyAutoLayout(defs);
+                return JSON.stringify(compactify(laidOut));
+            },
+            analyzeVariables: (compactJson) => {
+                const defs = expand(JSON.parse(String(compactJson)));
+                // analyzeVariableFlow operates per-process; run on each and collect
+                const results = defs.processes.map((p) => analyzeVariableFlow(p));
+                return JSON.stringify(results);
+            },
+        },
+    };
+}
+function runInVm(code, ctx, timeoutMs) {
+    const context = vm.createContext(ctx);
+    try {
+        return vm.runInContext(`(function(){\n${code}\n})()`, context, {
+            timeout: timeoutMs,
+        });
+    }
+    catch (err) {
+        throw new Error(`Code execution failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export function handleSdkSearch(code) {
+    // JSON round-trip ensures Object.keys works on plain objects inside the vm context
+    const result = runInVm(code, { spec: JSON.parse(JSON.stringify(SDK_SPEC)) }, 5000);
+    return JSON.stringify(result);
+}
+export function handleSdkExecute(code, xml) {
+    const result = runInVm(code, buildSdkContext(xml), 10000);
+    return JSON.stringify(result);
+}
+//# sourceMappingURL=sdk-code-mode.js.map

package/dist/sdk-spec.js

@@ -0,0 +1,67 @@
+// apps/proxy/src/sdk-spec.ts
+// Describes functions available in sdk_execute and the CompactDiagram shape.
+export const SDK_SPEC = {
+    functions: {
+        "sdk.parse": {
+            description: "Parse BPMN XML into a CompactDiagram JSON string.",
+            params: "xml: string",
+            returns: "string (CompactDiagram JSON)",
+            example: "const compact = sdk.parse(xml)",
+        },
+        "sdk.exportXml": {
+            description: "Convert a CompactDiagram JSON string to BPMN XML with auto-layout applied.",
+            params: "compactJson: string",
+            returns: "string (BPMN XML)",
+            example: "const xml = sdk.exportXml(compact)",
+        },
+        "sdk.optimize": {
+            description: "Run the pattern advisor on a CompactDiagram. Returns findings and an optimized diagram.",
+            params: "compactJson: string",
+            returns: "string (JSON: { diagram: CompactDiagram, findings: Finding[] })",
+            example: "const { diagram, findings } = JSON.parse(sdk.optimize(compact))",
+        },
+        "sdk.layout": {
+            description: "Apply automatic ELK layout to a CompactDiagram. Returns updated CompactDiagram JSON.",
+            params: "compactJson: string",
+            returns: "string (CompactDiagram JSON)",
+            example: "const laidOut = JSON.parse(sdk.layout(compact))",
+        },
+        "sdk.analyzeVariables": {
+            description: "Analyze FEEL variable flow across a process. Identifies undeclared inputs and output variable paths.",
+            params: "compactJson: string",
+            returns: "string (JSON: VariableFlowAnalysis)",
+            example: "const analysis = JSON.parse(sdk.analyzeVariables(compact))",
+        },
+    },
+    compactDiagram: {
+        description: "Lightweight JSON representation of a BPMN diagram. Input/output format for all sdk functions.",
+        shape: {
+            processes: [
+                {
+                    id: "string — process id, e.g. 'order-flow'",
+                    name: "string? — display name",
+                    elements: [
+                        {
+                            id: "string",
+                            type: "startEvent | endEvent | serviceTask | userTask | businessRuleTask | scriptTask | callActivity | exclusiveGateway | parallelGateway | inclusiveGateway | eventBasedGateway | subProcess | adHocSubProcess | intermediateThrowEvent | intermediateCatchEvent | boundaryEvent",
+                            name: "string?",
+                            jobType: "string? — Zeebe job worker type (serviceTask only)",
+                            decisionId: "string? — DMN decision id (businessRuleTask only)",
+                            formId: "string? — Camunda form id (userTask only)",
+                            calledElement: "string? — process id of called process (callActivity only)",
+                        },
+                    ],
+                    flows: [
+                        {
+                            id: "string",
+                            sourceRef: "string — source element id",
+                            targetRef: "string — target element id",
+                            condition: "string? — FEEL expression (exclusive gateway outgoing flows only)",
+                        },
+                    ],
+                },
+            ],
+        },
+    },
+};
+//# sourceMappingURL=sdk-spec.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/proxy",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "Local proxy server for BPMN Kit — AI bridge (SSE/MCP) and Camunda API proxy using stored CLI profiles",
   "type": "module",
   "bin": {
@@ -26,11 +26,12 @@
   "dependencies": {
     "better-sqlite3": "^12.8.0",
     "imapflow": "^1.2.18",
+    "isolated-vm": "^7.0.0",
     "nodemailer": "^6.10.1",
-    "@bpmnkit/api": "0.0.18",
-    "@bpmnkit/core": "0.0.23",
-    "@bpmnkit/patterns": "0.0.3",
-    "@bpmnkit/profiles": "0.0.16"
+    "@bpmnkit/api": "0.0.19",
+    "@bpmnkit/core": "0.0.24",
+    "@bpmnkit/patterns": "0.0.4",
+    "@bpmnkit/profiles": "0.0.17"
   },
   "publishConfig": {
     "access": "public"