@bpmnkit/proxy 0.0.25 → 0.0.27

package/dist/aikit-mcp.js

@@ -22,9 +22,12 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { createInterface } from "node:readline";
+import { CamundaClient } from "@bpmnkit/api";
 import { Bpmn, compactify, optimize } from "@bpmnkit/core";
 import { ALL_PATTERNS, findPattern } from "@bpmnkit/patterns";
 import { getActiveProfile, getAuthHeader } from "@bpmnkit/profiles";
+import { CAMUNDA_SPEC } from "./camunda-spec.js";
+import { runSandboxed } from "./sandbox.js";
 // ── Config ────────────────────────────────────────────────────────────────────
 const PROXY_URL = (process.env.BPMNKIT_PROXY_URL ?? "http://localhost:3033").replace(/\/$/, "");
 const ZEEBE_ADDRESS = (process.env.ZEEBE_ADDRESS ?? "http://localhost:26500").replace(/\/$/, "");
@@ -867,7 +870,93 @@ const TOOLS = [
             required: ["bpmnPath"],
         },
     },
+    {
+        name: "camunda_search",
+        description: "Inspect the Camunda 8 REST API spec to discover available operations before calling camunda_execute.\n" +
+            "Receives `spec` — an object keyed by resource group (processInstance, incident, job, etc.).\n" +
+            "Each entry maps method names to { description, endpoint, params, returns }.\n\n" +
+            "Example — list all process instance methods:\n" +
+            "  return Object.keys(spec.processInstance)\n\n" +
+            "Example — find all search operations across resources:\n" +
+            "  return Object.entries(spec).flatMap(([r, ms]) => Object.keys(ms).filter(m => m.startsWith('search')).map(m => r + '.' + m))\n\n" +
+            "Example — get full spec for one method:\n" +
+            "  return spec.incident.resolveIncident",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "JavaScript returning a value. Has `spec` as a global.",
+                },
+            },
+            required: ["code"],
+        },
+    },
+    {
+        name: "camunda_execute",
+        description: "Execute JavaScript against the authenticated Camunda 8 REST API.\n" +
+            "Has access to `camunda` — a proxy over the live CamundaClient.\n" +
+            "Call camunda_search first to discover resource group names and method parameter shapes.\n\n" +
+            "Example — list active process instances:\n" +
+            "  const r = await camunda.processInstance.searchProcessInstances({ filter: { state: 'ACTIVE' } })\n" +
+            "  return r.items.map(i => ({ key: i.processInstanceKey, id: i.bpmnProcessId }))\n\n" +
+            "Example — resolve an incident:\n" +
+            "  await camunda.incident.resolveIncident({ incidentKey: '9007199254741099' })\n" +
+            "  return 'resolved'",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "Async JavaScript. Has `camunda` proxy. Return value is JSON-serialized.",
+                },
+            },
+            required: ["code"],
+        },
+    },
 ];
+export async function handleCamundaSearch(code) {
+    const result = await runSandboxed(code, { data: { spec: CAMUNDA_SPEC } }, 5000);
+    return JSON.stringify(result);
+}
+// Bootstrap injected into the isolate — builds a camunda proxy over __dispatch.
+// The proxy intercepts resource.method(args) calls and routes them to the host client.
+const CAMUNDA_PROXY_BOOTSTRAP = `
+const camunda = new Proxy({}, {
+  get(_, resource) {
+    return new Proxy({}, {
+      get(_, method) {
+        return async (args) => {
+          const json = await __dispatch.apply(
+            undefined,
+            [resource, method, JSON.stringify(args ?? null)],
+            { result: { promise: true, copy: true } }
+          )
+          return JSON.parse(json)
+        }
+      }
+    })
+  }
+})
+`;
+export async function handleCamundaExecute(code) {
+    const profile = getActiveProfile();
+    if (!profile)
+        throw new Error("No active Camunda profile");
+    const client = new CamundaClient(profile.config);
+    const dispatch = async (resource, method, argsJson) => {
+        const rc = client[String(resource)];
+        if (!rc)
+            throw new Error(`Unknown resource: ${resource}`);
+        const fn = rc[String(method)];
+        if (typeof fn !== "function")
+            throw new Error(`Unknown method: ${resource}.${method}`);
+        const result = await fn.call(rc, JSON.parse(String(argsJson)));
+        return JSON.stringify(result ?? null);
+    };
+    const result = await runSandboxed(code, { bootstrap: CAMUNDA_PROXY_BOOTSTRAP, functions: { __dispatch: dispatch } }, 10000);
+    return JSON.stringify(result);
+}
 async function callTool(name, args) {
     process.stderr.write(`[aikit-mcp] tool: ${name} args: ${JSON.stringify(args)}\n`);
     switch (name) {
@@ -908,6 +997,10 @@ async function callTool(name, args) {
             const outDir = args.outputDir ? String(args.outputDir) : undefined;
             return toolDmnCreate(path, outDir);
         }
+        case "camunda_search":
+            return handleCamundaSearch(args.code);
+        case "camunda_execute":
+            return handleCamundaExecute(args.code);
         default:
             throw new Error(`Unknown tool: ${name}`);
     }