@bpmnkit/proxy 0.0.17 → 0.0.21

package/dist/worker.js

@@ -0,0 +1,166 @@
+/**
+ * Worker daemon — polls a local reebe instance for BPMN service task jobs and
+ * dispatches them to built-in handlers (CLI, LLM, FS, JS).
+ *
+ * Activated on proxy startup; respects BPMNKIT_WORKERS=false to opt out.
+ */
+import { getActiveProfile, getAuthHeader } from "@bpmnkit/profiles";
+import { onJobComplete, onJobFail, onJobStart } from "./routes/run-history.js";
+import * as cliWorker from "./workers/cli.js";
+import * as emailWorker from "./workers/email.js";
+import * as fsWorker from "./workers/fs.js";
+import * as httpWorker from "./workers/http.js";
+import * as jsWorker from "./workers/js.js";
+import * as llmWorker from "./workers/llm.js";
+// ── Template variable interpolation ──────────────────────────────────────────
+const VAR_RE = /\{\{([\w.]+)\}\}/g;
+/**
+ * Replace `{{varName}}` and `{{secrets.NAME}}` placeholders in a string.
+ * Secrets are read from `process.env` (proxy runs in Node.js).
+ */
+export function interpolate(template, vars) {
+    return template.replace(VAR_RE, (match, key) => {
+        if (key.startsWith("secrets.")) {
+            const secretName = key.slice("secrets.".length);
+            return process.env[secretName] ?? match;
+        }
+        const val = vars[key];
+        return val !== undefined ? String(val) : match;
+    });
+}
+// ── Registry ──────────────────────────────────────────────────────────────────
+const registry = new Map([
+    [cliWorker.JOB_TYPE, cliWorker.handle],
+    [llmWorker.JOB_TYPE, llmWorker.handle],
+    [fsWorker.JOB_TYPE_READ, fsWorker.handleRead],
+    [fsWorker.JOB_TYPE_WRITE, fsWorker.handleWrite],
+    [fsWorker.JOB_TYPE_APPEND, fsWorker.handleAppend],
+    [fsWorker.JOB_TYPE_LIST, fsWorker.handleList],
+    [jsWorker.JOB_TYPE, jsWorker.handle],
+    [httpWorker.JOB_TYPE, httpWorker.handle],
+    [emailWorker.JOB_TYPE_FETCH, emailWorker.handleFetch],
+    [emailWorker.JOB_TYPE_SEND, emailWorker.handleSend],
+]);
+// ── Daemon state (exported for /status) ──────────────────────────────────────
+export const workerState = {
+    active: false,
+    pollCount: 0,
+    jobTypes: [...registry.keys()],
+    lastError: null,
+};
+async function activateJobs(baseUrl, authHeader, type) {
+    const res = await fetch(`${baseUrl}/v2/jobs/activation`, {
+        method: "POST",
+        headers: { authorization: authHeader, "content-type": "application/json" },
+        body: JSON.stringify({
+            type,
+            timeout: 30_000,
+            maxJobsToActivate: 5,
+            worker: "bpmnkit-worker",
+        }),
+    });
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    return (data.jobs ?? []).map((j) => ({
+        jobKey: j.jobKey,
+        type: j.type,
+        processInstanceKey: j.processInstanceKey,
+        elementInstanceKey: j.elementInstanceKey,
+        variables: j.variables ?? {},
+        customHeaders: j.customHeaders ?? {},
+    }));
+}
+async function completeJob(baseUrl, authHeader, jobKey, variables) {
+    await fetch(`${baseUrl}/v2/jobs/${jobKey}/completion`, {
+        method: "POST",
+        headers: { authorization: authHeader, "content-type": "application/json" },
+        body: JSON.stringify({ variables }),
+    });
+}
+async function failJob(baseUrl, authHeader, jobKey, message, retries) {
+    await fetch(`${baseUrl}/v2/jobs/${jobKey}/failure`, {
+        method: "POST",
+        headers: { authorization: authHeader, "content-type": "application/json" },
+        body: JSON.stringify({ retries, errorMessage: message }),
+    });
+}
+// ── Dispatch ──────────────────────────────────────────────────────────────────
+async function dispatchJob(baseUrl, authHeader, job, handler) {
+    console.log(`[worker] job ${job.jobKey} type=${job.type} pi=${job.processInstanceKey}`);
+    onJobStart(job);
+    const startMs = Date.now();
+    try {
+        const outputs = await handler(job);
+        const durationMs = Date.now() - startMs;
+        await completeJob(baseUrl, authHeader, job.jobKey, outputs);
+        onJobComplete(job, outputs, durationMs);
+        console.log(`[worker] job ${job.jobKey} completed in ${durationMs}ms`);
+    }
+    catch (err) {
+        const durationMs = Date.now() - startMs;
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`[worker] job ${job.jobKey} failed: ${message}`);
+        await failJob(baseUrl, authHeader, job.jobKey, message, 0);
+        onJobFail(job, message, durationMs);
+    }
+}
+async function pollOnce(baseUrl, authHeader) {
+    workerState.pollCount++;
+    const types = [...registry.keys()];
+    await Promise.all(types.map(async (type) => {
+        const handler = registry.get(type);
+        if (!handler)
+            return;
+        let jobs;
+        try {
+            jobs = await activateJobs(baseUrl, authHeader, type);
+        }
+        catch {
+            return; // reebe unreachable, skip
+        }
+        await Promise.all(jobs.map((job) => dispatchJob(baseUrl, authHeader, job, handler)));
+    }));
+}
+// ── Startup ───────────────────────────────────────────────────────────────────
+const POLL_INTERVAL_MS = 1_000;
+export function startWorkerDaemon() {
+    if (process.env.BPMNKIT_WORKERS === "false") {
+        console.log("[worker] disabled via BPMNKIT_WORKERS=false");
+        return;
+    }
+    // Run the poll loop in the background, refreshing profile on each cycle
+    workerState.active = true;
+    console.log(`[worker] daemon starting, polling types: ${[...registry.keys()].join(", ")}`);
+    let running = false;
+    setInterval(async () => {
+        if (running)
+            return; // don't overlap
+        running = true;
+        try {
+            const profile = getActiveProfile();
+            if (!profile?.config.baseUrl)
+                return;
+            // Skip non-reebe profiles (wasm, modeler-only)
+            const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+            if (!baseUrl.startsWith("http"))
+                return;
+            let authHeader = "";
+            try {
+                authHeader = await getAuthHeader(profile.config);
+            }
+            catch {
+                // Unauthenticated reebe — proceed without auth
+            }
+            await pollOnce(baseUrl, authHeader);
+            workerState.lastError = null;
+        }
+        catch (err) {
+            workerState.lastError = err instanceof Error ? err.message : String(err);
+        }
+        finally {
+            running = false;
+        }
+    }, POLL_INTERVAL_MS);
+}
+//# sourceMappingURL=worker.js.map

package/dist/workers/cli.js

@@ -0,0 +1,72 @@
+import { exec } from "node:child_process";
+import { homedir } from "node:os";
+import { promisify } from "node:util";
+import { interpolate } from "../worker.js";
+const execAsync = promisify(exec);
+export const JOB_TYPE = "io.bpmnkit:cli:1";
+/**
+ * CLI worker — runs a shell command and returns stdout/stderr/exitCode.
+ *
+ * Task headers:
+ *   command       (required) — shell command, supports {{varName}} and {{secrets.NAME}} interpolation
+ *   cwd           (optional) — working directory; default ~
+ *   timeout       (optional) — timeout in seconds; default 60
+ *   ignoreExitCode (optional) — "true" to complete even on non-zero exit; default false
+ *   resultVariable (optional) — if set, wraps result under this key; default outputs at root
+ */
+export async function handle(job) {
+    const commandTemplate = job.customHeaders.command;
+    if (!commandTemplate) {
+        throw new Error('CLI worker requires a "command" task header');
+    }
+    const cwd = job.customHeaders.cwd
+        ? expandHome(interpolate(job.customHeaders.cwd, job.variables))
+        : homedir();
+    const timeoutSec = Number(job.customHeaders.timeout ?? "60");
+    const ignoreExitCode = job.customHeaders.ignoreExitCode === "true";
+    const command = interpolate(commandTemplate, job.variables);
+    const allowed = process.env.BPMNKIT_CLI_ALLOWED;
+    if (allowed) {
+        const prefixes = allowed
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        const commandName = command.trimStart().split(/\s+/)[0] ?? "";
+        if (!prefixes.some((p) => commandName === p || commandName.startsWith(`${p}/`))) {
+            throw new Error(`CLI command "${commandName}" is not in the allowlist. Set BPMNKIT_CLI_ALLOWED to allow it.`);
+        }
+    }
+    console.log(`[worker:cli] running: ${command}`);
+    let stdout = "";
+    let stderr = "";
+    let exitCode = 0;
+    try {
+        const result = await execAsync(command, {
+            cwd,
+            timeout: timeoutSec * 1000,
+            shell: "/bin/sh",
+        });
+        stdout = result.stdout;
+        stderr = result.stderr;
+    }
+    catch (err) {
+        const e = err;
+        stdout = e.stdout ?? "";
+        stderr = e.stderr ?? e.message ?? String(err);
+        exitCode = e.code ?? 1;
+        if (!ignoreExitCode) {
+            throw new Error(`Command exited with code ${exitCode}: ${stderr.trim() || stdout.trim()}`);
+        }
+    }
+    const result = { stdout, stderr, exitCode };
+    const rv = job.customHeaders.resultVariable;
+    if (rv)
+        return { [rv]: result };
+    return result;
+}
+function expandHome(p) {
+    if (p === "~" || p.startsWith("~/"))
+        return homedir() + p.slice(1);
+    return p;
+}
+//# sourceMappingURL=cli.js.map

package/dist/workers/email.js

@@ -0,0 +1,102 @@
+import { interpolate } from "../worker.js";
+export const JOB_TYPE_FETCH = "io.bpmnkit:email:fetch:1";
+export const JOB_TYPE_SEND = "io.bpmnkit:email:send:1";
+/**
+ * Email fetch worker — connects via IMAP and retrieves messages.
+ *
+ * Task headers (all support {{secrets.X}} interpolation):
+ *   imapHost, imapPort (default 993), imapUser, imapPassword, imapSecure (default "true")
+ *   folder (default "INBOX"), limit (default 10), unreadOnly (default "true")
+ *   resultVariable (default "emails")
+ */
+export async function handleFetch(job) {
+    const h = job.customHeaders;
+    const vars = job.variables;
+    const imapHost = interpolate(h.imapHost ?? "", vars);
+    const imapPort = Number(interpolate(h.imapPort ?? "993", vars));
+    const imapUser = interpolate(h.imapUser ?? "", vars);
+    const imapPassword = interpolate(h.imapPassword ?? "", vars);
+    const imapSecure = interpolate(h.imapSecure ?? "true", vars) !== "false";
+    const folder = interpolate(h.folder ?? "INBOX", vars);
+    const limit = Number(interpolate(h.limit ?? "10", vars));
+    const unreadOnly = interpolate(h.unreadOnly ?? "true", vars) !== "false";
+    const resultVariable = interpolate(h.resultVariable ?? "emails", vars);
+    console.log(`[worker:email:fetch] folder=${folder} limit=${limit}`);
+    const { ImapFlow } = await import("imapflow");
+    const client = new ImapFlow({
+        host: imapHost,
+        port: imapPort,
+        secure: imapSecure,
+        auth: { user: imapUser, pass: imapPassword },
+        logger: false,
+    });
+    await client.connect();
+    const emails = [];
+    try {
+        const lock = await client.getMailboxLock(folder);
+        try {
+            const searchCriteria = unreadOnly ? { seen: false } : { all: true };
+            const uidsResult = await client.search(searchCriteria, { uid: true });
+            const uids = Array.isArray(uidsResult) ? uidsResult : [];
+            const fetchUids = uids.slice(-limit);
+            if (fetchUids.length > 0) {
+                for await (const msg of client.fetch(fetchUids, { envelope: true, bodyParts: ["TEXT"] }, { uid: true })) {
+                    const env = msg.envelope;
+                    if (!env)
+                        continue;
+                    const bodyPart = msg.bodyParts?.get("TEXT");
+                    const body = bodyPart ? Buffer.from(bodyPart).toString("utf-8") : "";
+                    emails.push({
+                        uid: msg.uid,
+                        subject: env.subject ?? "",
+                        from: env.from?.[0]?.address ?? "",
+                        to: env.to?.[0]?.address ?? "",
+                        date: env.date?.toISOString() ?? "",
+                        body,
+                    });
+                }
+            }
+        }
+        finally {
+            lock.release();
+        }
+    }
+    finally {
+        await client.logout();
+    }
+    return { [resultVariable]: emails };
+}
+/**
+ * Email send worker — sends a message via SMTP using nodemailer.
+ *
+ * Task headers (support interpolation):
+ *   smtpHost, smtpPort (default 587), smtpUser, smtpPassword, smtpSecure (default "false")
+ *   from (optional, defaults to smtpUser)
+ *
+ * Input variables (job.variables, headers as fallback):
+ *   to, subject, body
+ */
+export async function handleSend(job) {
+    const h = job.customHeaders;
+    const vars = job.variables;
+    const smtpHost = interpolate(h.smtpHost ?? "", vars);
+    const smtpPort = Number(interpolate(h.smtpPort ?? "587", vars));
+    const smtpUser = interpolate(h.smtpUser ?? "", vars);
+    const smtpPassword = interpolate(h.smtpPassword ?? "", vars);
+    const smtpSecure = interpolate(h.smtpSecure ?? "false", vars) !== "false";
+    const from = interpolate(h.from ?? smtpUser, vars);
+    const to = String(vars.to ?? h.to ?? "");
+    const subject = String(vars.subject ?? h.subject ?? "");
+    const body = String(vars.body ?? h.body ?? "");
+    console.log(`[worker:email:send] to=${to} subject=${subject}`);
+    const nodemailer = await import("nodemailer");
+    const transporter = nodemailer.createTransport({
+        host: smtpHost,
+        port: smtpPort,
+        secure: smtpSecure,
+        auth: { user: smtpUser, pass: smtpPassword },
+    });
+    await transporter.sendMail({ from, to, subject, text: body });
+    return { sent: true, to, subject };
+}
+//# sourceMappingURL=email.js.map

package/dist/workers/fs.js

@@ -0,0 +1,90 @@
+import { appendFileSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { interpolate } from "../worker.js";
+export const JOB_TYPE_READ = "io.bpmnkit:fs:read:1";
+export const JOB_TYPE_WRITE = "io.bpmnkit:fs:write:1";
+export const JOB_TYPE_APPEND = "io.bpmnkit:fs:append:1";
+export const JOB_TYPE_LIST = "io.bpmnkit:fs:list:1";
+function resolvePath(raw, vars) {
+    const p = interpolate(raw, vars);
+    const resolved = p.startsWith("~/") || p === "~" ? homedir() + p.slice(1) : resolve(p);
+    const root = process.env.BPMNKIT_FS_ROOT;
+    if (root) {
+        const rootResolved = resolve(root);
+        if (!resolved.startsWith(`${rootResolved}/`) && resolved !== rootResolved) {
+            throw new Error(`Path "${resolved}" is outside the allowed root "${rootResolved}". Set BPMNKIT_FS_ROOT to change this.`);
+        }
+    }
+    return resolved;
+}
+/**
+ * io.bpmnkit:fs:read:1
+ * Variables: path (string)
+ * Outputs:   content (string)
+ */
+export async function handleRead(job) {
+    const raw = job.variables.path ?? job.customHeaders.path;
+    if (!raw)
+        throw new Error('fs:read requires variable or header "path"');
+    const path = resolvePath(raw, job.variables);
+    console.log(`[worker:fs:read] ${path}`);
+    const content = readFileSync(path, "utf8");
+    const rv = job.customHeaders.resultVariable;
+    if (rv)
+        return { [rv]: content };
+    return { content };
+}
+/**
+ * io.bpmnkit:fs:write:1
+ * Variables: path (string), content (string)
+ * Outputs:   bytesWritten (number)
+ */
+export async function handleWrite(job) {
+    const rawPath = job.variables.path ?? job.customHeaders.path;
+    if (!rawPath)
+        throw new Error('fs:write requires variable or header "path"');
+    const path = resolvePath(rawPath, job.variables);
+    const content = String(job.variables.content ?? "");
+    console.log(`[worker:fs:write] ${path} (${content.length} chars)`);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, "utf8");
+    return { bytesWritten: Buffer.byteLength(content, "utf8") };
+}
+/**
+ * io.bpmnkit:fs:append:1
+ * Variables: path (string), content (string)
+ * Outputs:   bytesWritten (number)
+ */
+export async function handleAppend(job) {
+    const rawPath = job.variables.path ?? job.customHeaders.path;
+    if (!rawPath)
+        throw new Error('fs:append requires variable or header "path"');
+    const path = resolvePath(rawPath, job.variables);
+    const content = String(job.variables.content ?? "");
+    console.log(`[worker:fs:append] ${path}`);
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, content, "utf8");
+    return { bytesWritten: Buffer.byteLength(content, "utf8") };
+}
+/**
+ * io.bpmnkit:fs:list:1
+ * Variables: path (string)
+ * Outputs:   files (string[])
+ */
+export async function handleList(job) {
+    const raw = job.variables.path ?? job.customHeaders.path;
+    if (!raw)
+        throw new Error('fs:list requires variable or header "path"');
+    const path = resolvePath(raw, job.variables);
+    console.log(`[worker:fs:list] ${path}`);
+    const entries = readdirSync(path, { withFileTypes: true });
+    const files = entries
+        .filter((e) => !e.name.startsWith("."))
+        .map((e) => (e.isDirectory() ? `${e.name}/` : e.name));
+    const rv = job.customHeaders.resultVariable;
+    if (rv)
+        return { [rv]: files };
+    return { files };
+}
+//# sourceMappingURL=fs.js.map

package/dist/workers/http.js

@@ -0,0 +1,46 @@
+import { interpolate } from "../worker.js";
+export const JOB_TYPE = "io.bpmnkit:http:scrape:1";
+/**
+ * HTTP scraper worker — fetches a URL and extracts text content.
+ *
+ * Task headers:
+ *   url            (required) — URL to fetch, supports {{varName}} interpolation
+ *   timeout        (optional) — timeout in seconds; default 30
+ *   resultVariable (optional) — if set, wraps result under this key; default outputs at root
+ */
+export async function handle(job) {
+    const urlTemplate = job.customHeaders.url;
+    if (!urlTemplate) {
+        throw new Error('HTTP worker requires a "url" task header');
+    }
+    const url = interpolate(urlTemplate, job.variables);
+    const timeoutSec = Number(job.customHeaders.timeout ?? "30");
+    const resultVariable = job.customHeaders.resultVariable ?? "";
+    console.log(`[worker:http] GET ${url}`);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutSec * 1000);
+    let html;
+    let statusCode;
+    try {
+        const res = await fetch(url, { signal: controller.signal });
+        statusCode = res.status;
+        html = await res.text();
+        if (!res.ok) {
+            throw new Error(`HTTP ${statusCode} from ${url}`);
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    const title = titleMatch?.[1]?.trim() ?? "";
+    const text = html
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const result = { url, html, text, title, statusCode };
+    if (resultVariable)
+        return { [resultVariable]: result };
+    return result;
+}
+//# sourceMappingURL=http.js.map

package/dist/workers/js.js

@@ -0,0 +1,21 @@
+import { runInNewContext } from "node:vm";
+export const JOB_TYPE = "io.bpmnkit:js:1";
+/**
+ * JavaScript eval worker — evaluates an expression with process variables in scope.
+ *
+ * Task headers:
+ *   expression     (required) — JS expression; receives `variables` object in scope
+ *   resultVariable (optional) — variable name to store result; default "result"
+ *
+ * Example expression:  variables.items.filter(x => x.score > 0.5).length
+ */
+export async function handle(job) {
+    const expression = job.customHeaders.expression;
+    if (!expression) {
+        throw new Error('js worker requires an "expression" task header');
+    }
+    const resultVariable = job.customHeaders.resultVariable ?? "result";
+    const result = runInNewContext(`(${expression})`, { variables: job.variables });
+    return { [resultVariable]: result };
+}
+//# sourceMappingURL=js.js.map

package/dist/workers/llm.js

@@ -0,0 +1,55 @@
+import * as claude from "../adapters/claude.js";
+import * as copilot from "../adapters/copilot.js";
+import * as gemini from "../adapters/gemini.js";
+import { interpolate } from "../worker.js";
+export const JOB_TYPE = "io.bpmnkit:llm:1";
+/**
+ * LLM worker — calls the first available LLM adapter with a prompt.
+ *
+ * Variables:
+ *   prompt         (required) — prompt text; supports {{varName}} interpolation
+ *
+ * Task headers:
+ *   system         (optional) — system prompt
+ *   model          (optional) — "claude" | "copilot" | "gemini"; auto-detects if omitted
+ *   resultVariable (optional) — variable to store response; default "response"
+ */
+export async function handle(job) {
+    const rawPrompt = job.variables.prompt ?? job.customHeaders.prompt;
+    if (!rawPrompt)
+        throw new Error('llm worker requires a "prompt" variable or task header');
+    const prompt = interpolate(rawPrompt, job.variables);
+    const system = job.customHeaders.system
+        ? interpolate(job.customHeaders.system, job.variables)
+        : "";
+    const preferredModel = job.customHeaders.model?.toLowerCase();
+    const resultVariable = job.customHeaders.resultVariable ?? "response";
+    const adapter = await pickAdapter(preferredModel);
+    if (!adapter)
+        throw new Error("No LLM adapter available (claude, copilot, or gemini)");
+    console.log(`[worker:llm] using ${adapter.name}, prompt length=${prompt.length}`);
+    let response = "";
+    await adapter.instance.stream([{ role: "user", content: prompt }], system, null, (token) => {
+        response += token;
+    });
+    return { [resultVariable]: response.trim() };
+}
+async function pickAdapter(preferred) {
+    const candidates = [
+        { name: "claude", instance: claude },
+        { name: "copilot", instance: copilot },
+        { name: "gemini", instance: gemini },
+    ];
+    if (preferred) {
+        const found = candidates.find((c) => c.name === preferred);
+        if (found && (await found.instance.available()))
+            return found;
+        console.warn(`[worker:llm] preferred adapter "${preferred}" not available, falling back`);
+    }
+    for (const c of candidates) {
+        if (await c.instance.available())
+            return c;
+    }
+    return null;
+}
+//# sourceMappingURL=llm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/proxy",
-  "version": "0.0.17",
+  "version": "0.0.21",
   "description": "Local proxy server for BPMN Kit — AI bridge (SSE/MCP) and Camunda API proxy using stored CLI profiles",
   "type": "module",
   "bin": {
@@ -16,9 +16,12 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@bpmnkit/api": "0.0.13",
-    "@bpmnkit/core": "0.0.16",
-    "@bpmnkit/profiles": "0.0.11"
+    "better-sqlite3": "^12.8.0",
+    "imapflow": "^1.2.18",
+    "nodemailer": "^6.10.1",
+    "@bpmnkit/api": "0.0.16",
+    "@bpmnkit/core": "0.0.20",
+    "@bpmnkit/profiles": "0.0.14"
   },
   "publishConfig": {
     "access": "public"
@@ -47,6 +50,7 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "check": "biome check .",
+    "test": "vitest run",
     "dev": "node --watch dist/index.js",
     "bridge": "esbuild src/bridge.ts --bundle --format=iife --global-name=Bridge --platform=neutral --outfile=dist/bridge.bundle.js",
     "bundle": "esbuild src/index.ts --bundle --platform=node --format=cjs --outfile=dist/bundle.cjs && esbuild src/mcp-server.ts --bundle --platform=node --format=cjs --outfile=dist/mcp-server.cjs && pnpm run bridge"