@bpmnkit/proxy 0.0.16 → 0.0.21

package/dist/prompt.js

@@ -222,6 +222,63 @@ export function buildOperateChatSystemPrompt(stats) {
     lines.push("## Available actions (user performs these in the UI)", "- View and cancel running instances → Instances page", "- View and retry failed incidents → Incidents page", "- Claim and complete user tasks → Tasks page", "- Start new process instances → Definitions page → Start Instance button", "- Deploy new processes → Models page → Deploy button", "", "When asked to do something, explain which UI page to visit and what to click.", "If asked about a specific instance/incident/task, say you can only see aggregate counts unless you query for details.");
     return lines.join("\n");
 }
+// ── Improve prompt builders ───────────────────────────────────────────────────
+const OPERATIONS_FORMAT = `
+BpmnOperation types (use stable element IDs, never array positions):
+  { "op": "rename",        "id": "...", "name": "new name" }
+  { "op": "update",        "id": "...", "patch": { /* partial CompactElement fields */ } }
+  { "op": "delete",        "id": "..." }
+  { "op": "insert",        "element": { /* full CompactElement with new unique id */ }, "after"?: "id", "before"?: "id", "parent"?: "sub-process-id" }
+  { "op": "add_flow",      "from": "id", "to": "id", "condition"?: "FEEL expr", "name"?: "...", "parent"?: "sub-process-id" }
+  { "op": "delete_flow",   "id": "..." }
+  { "op": "redirect_flow", "id": "...", "from"?: "new-source-id", "to"?: "new-target-id" }`.trim();
+export function buildImproveSystemPrompt() {
+    return [
+        "You are a BPMN 2.0 process improvement expert.",
+        "",
+        "Output format — follow this EXACTLY:",
+        "1. Write 2–4 sentences explaining what you will change and why.",
+        "2. Then output a single ```json block containing ONLY a JSON array of BpmnOperation objects.",
+        "",
+        OPERATIONS_FORMAT,
+        "",
+        "Rules:",
+        "- Reference only IDs that exist in the provided model (except 'insert' adds new IDs).",
+        "- For 'insert': generate a short, unique camelCase ID (e.g. 'task_notify', 'gw_valid').",
+        "- Output ONLY the operations array in the ```json block — no prose inside it.",
+        "- If no changes are needed, output [].",
+        "",
+        "Apply Camunda BPMN best practices:",
+        '  • Tasks: "Verb Object" — "Verify Invoice", "Send Notification"',
+        '  • Start events: past participle — "Order Received", "Payment Initiated"',
+        '  • End events: object + state — "Order Fulfilled", "Payment Failed"',
+        '  • XOR split gateways: yes/no question ending in "?" — "Invoice valid?"',
+        '  • XOR split outgoing flows: label with condition — "Yes"/"No", "Approved"/"Rejected"',
+        "  • Join gateways: no label",
+        "  • Never send >1 incoming flow to a task without a join gateway first",
+    ].join("\n");
+}
+export function buildImproveUserMessage(ctx) {
+    const lines = [];
+    if (ctx.autoFixCount > 0) {
+        lines.push(`Note: ${ctx.autoFixCount} structural issue(s) were already auto-fixed before this analysis.`, "");
+    }
+    lines.push("Current process model:", "```json", JSON.stringify(ctx.compact, null, 2), "```", "");
+    if (ctx.findings.length > 0) {
+        lines.push("Detected issues to fix:");
+        for (const f of ctx.findings) {
+            const els = f.elementIds.length > 0 ? ` [elements: ${f.elementIds.join(", ")}]` : "";
+            lines.push(`- [${f.severity}/${f.category}] ${f.message}${els}`);
+            lines.push(`  → ${f.suggestion}`);
+        }
+        lines.push("");
+    }
+    if (ctx.instruction) {
+        lines.push(`Additional instructions: ${ctx.instruction}`, "");
+    }
+    lines.push("Explain your changes, then output the BpmnOperation array in a ```json block.");
+    return lines.join("\n");
+}
 // ── Fallback prompt builders (for non-MCP adapters like Gemini) ───────────────
 /** Full system prompt for non-MCP adapters that must return a CompactDiagram JSON block. */
 export function buildSystemPrompt(context) {

package/dist/routes/run-history.js

@@ -0,0 +1,307 @@
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getActiveProfile, getAuthHeader } from "@bpmnkit/profiles";
+/**
+ * Run history store — persists worker job execution history to SQLite.
+ *
+ * Schema:
+ *   runs  — one row per process instance (groups all steps for an instance)
+ *   steps — one row per job execution (CLI, LLM, FS, JS, etc.)
+ *
+ * Routes:
+ *   GET /run-history           — paginated list of runs (most recent first)
+ *   GET /run-history/:id       — single run with all steps
+ *   DELETE /run-history        — clear all history
+ */
+import Database from "better-sqlite3";
+// ── DB init ───────────────────────────────────────────────────────────────────
+const DB_DIR = join(homedir(), ".bpmnkit");
+const DB_PATH = join(DB_DIR, "run-history.db");
+let db = null;
+function getDb() {
+    if (db)
+        return db;
+    mkdirSync(DB_DIR, { recursive: true });
+    db = new Database(DB_PATH);
+    db.pragma("journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS runs (
+      id                 TEXT PRIMARY KEY,
+      processInstanceKey TEXT NOT NULL,
+      processId          TEXT,
+      startedAt          TEXT NOT NULL,
+      endedAt            TEXT,
+      state              TEXT NOT NULL DEFAULT 'active',
+      variablesSnapshot  TEXT NOT NULL DEFAULT '{}'
+    );
+    CREATE TABLE IF NOT EXISTS steps (
+      id           TEXT PRIMARY KEY,
+      runId        TEXT NOT NULL REFERENCES runs(id),
+      elementId    TEXT NOT NULL,
+      jobType      TEXT NOT NULL,
+      startedAt    TEXT NOT NULL,
+      endedAt      TEXT,
+      durationMs   INTEGER,
+      state        TEXT NOT NULL DEFAULT 'active',
+      inputs       TEXT NOT NULL DEFAULT '{}',
+      outputs      TEXT NOT NULL DEFAULT '{}',
+      errorMessage TEXT
+    );
+    CREATE INDEX IF NOT EXISTS steps_runId ON steps(runId);
+    CREATE INDEX IF NOT EXISTS runs_startedAt ON runs(startedAt DESC);
+  `);
+    return db;
+}
+// ── Interpolation (minimal copy to avoid circular imports) ────────────────────
+const VAR_RE = /\{\{([\w.]+)\}\}/g;
+function interpolate(template, vars) {
+    return template.replace(VAR_RE, (_match, key) => {
+        if (key.startsWith("secrets."))
+            return "***";
+        const val = vars[key];
+        return val !== undefined ? String(val) : `{{${key}}}`;
+    });
+}
+// ── Step input extraction ─────────────────────────────────────────────────────
+function extractInputs(job) {
+    try {
+        switch (job.type) {
+            case "io.bpmnkit:llm:1": {
+                const rawPrompt = job.variables.prompt ?? job.customHeaders.prompt ?? "";
+                return JSON.stringify({
+                    prompt: interpolate(rawPrompt, job.variables),
+                    system: job.customHeaders.system
+                        ? interpolate(job.customHeaders.system, job.variables)
+                        : undefined,
+                    model: job.customHeaders.model ?? "auto",
+                });
+            }
+            case "io.bpmnkit:cli:1": {
+                const cmd = interpolate(job.customHeaders.command ?? "", job.variables);
+                return JSON.stringify({
+                    command: cmd,
+                    cwd: job.customHeaders.cwd ? interpolate(job.customHeaders.cwd, job.variables) : "~",
+                });
+            }
+            case "io.bpmnkit:fs:read:1":
+            case "io.bpmnkit:fs:write:1":
+            case "io.bpmnkit:fs:append:1":
+            case "io.bpmnkit:fs:list:1": {
+                const path = job.variables.path ?? job.customHeaders.path ?? "";
+                return JSON.stringify({ path: interpolate(path, job.variables) });
+            }
+            case "io.bpmnkit:js:1": {
+                return JSON.stringify({ expression: job.customHeaders.expression ?? "" });
+            }
+            case "io.bpmnkit:http:scrape:1": {
+                const url = interpolate(job.customHeaders.url ?? "", job.variables);
+                return JSON.stringify({ url });
+            }
+            case "io.bpmnkit:email:fetch:1": {
+                return JSON.stringify({
+                    folder: job.customHeaders.folder ?? "INBOX",
+                    limit: job.customHeaders.limit ?? "10",
+                    unreadOnly: job.customHeaders.unreadOnly ?? "true",
+                });
+            }
+            case "io.bpmnkit:email:send:1": {
+                const to = String(job.variables.to ?? job.customHeaders.to ?? "");
+                const subject = String(job.variables.subject ?? job.customHeaders.subject ?? "");
+                return JSON.stringify({ to, subject });
+            }
+            default:
+                return JSON.stringify({ headers: job.customHeaders });
+        }
+    }
+    catch {
+        return "{}";
+    }
+}
+// ── Public logging API (called from worker.ts) ────────────────────────────────
+/** Called before a job handler is invoked. */
+export function onJobStart(job) {
+    try {
+        const d = getDb();
+        const now = new Date().toISOString();
+        // Upsert the run (create on first job for this process instance)
+        d.prepare(`INSERT INTO runs (id, processInstanceKey, processId, startedAt, state, variablesSnapshot)
+       VALUES (?, ?, ?, ?, 'active', ?)
+       ON CONFLICT(id) DO NOTHING`).run(job.processInstanceKey, job.processInstanceKey, job.type.split(":")[1] ?? job.type, now, JSON.stringify(job.variables));
+        // Insert step
+        d.prepare(`INSERT INTO steps (id, runId, elementId, jobType, startedAt, state, inputs)
+       VALUES (?, ?, ?, ?, ?, 'active', ?)`).run(job.jobKey, job.processInstanceKey, job.elementInstanceKey, job.type, now, extractInputs(job));
+    }
+    catch (err) {
+        console.error("[run-history] onJobStart failed:", err);
+    }
+}
+/** Called after a job handler succeeds. */
+export function onJobComplete(job, outputs, durationMs) {
+    try {
+        const d = getDb();
+        const now = new Date().toISOString();
+        d.prepare(`UPDATE steps SET endedAt=?, durationMs=?, state='completed', outputs=? WHERE id=?`).run(now, durationMs, JSON.stringify(outputs), job.jobKey);
+        d.prepare(`UPDATE runs SET endedAt=?, state='completed' WHERE id=?`).run(now, job.processInstanceKey);
+    }
+    catch (err) {
+        console.error("[run-history] onJobComplete failed:", err);
+    }
+}
+/** Called after a job handler throws. */
+export function onJobFail(job, errorMessage, durationMs) {
+    try {
+        const d = getDb();
+        const now = new Date().toISOString();
+        d.prepare(`UPDATE steps SET endedAt=?, durationMs=?, state='failed', errorMessage=? WHERE id=?`).run(now, durationMs, errorMessage, job.jobKey);
+        d.prepare(`UPDATE runs SET endedAt=?, state='failed' WHERE id=?`).run(now, job.processInstanceKey);
+    }
+    catch (err) {
+        console.error("[run-history] onJobFail failed:", err);
+    }
+}
+function jsonResp(res, data, status = 200) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+/** GET /run-history — list of runs, most recent first. */
+export function handleGetRunHistory(req, res) {
+    try {
+        const url = new URL(req.url ?? "/", "http://x");
+        const limit = Math.min(Number(url.searchParams.get("limit") ?? "50"), 200);
+        const offset = Number(url.searchParams.get("offset") ?? "0");
+        const d = getDb();
+        const rows = d
+            .prepare(`SELECT r.*,
+              COUNT(s.id)                        AS stepCount,
+              SUM(CASE WHEN s.state='failed' THEN 1 ELSE 0 END) AS failedSteps
+       FROM   runs r
+       LEFT JOIN steps s ON s.runId = r.id
+       GROUP BY r.id
+       ORDER BY r.startedAt DESC
+       LIMIT ? OFFSET ?`)
+            .all(limit, offset);
+        const total = d.prepare("SELECT COUNT(*) AS n FROM runs").get().n;
+        jsonResp(res, { items: rows, total, limit, offset });
+    }
+    catch (err) {
+        jsonResp(res, { error: String(err) }, 500);
+    }
+}
+/** GET /run-history/:id — single run with steps. */
+export function handleGetRunHistoryDetail(req, res, runId) {
+    try {
+        const d = getDb();
+        const run = d.prepare("SELECT * FROM runs WHERE id=?").get(runId);
+        if (!run) {
+            jsonResp(res, { error: "Not found" }, 404);
+            return;
+        }
+        const steps = d
+            .prepare("SELECT * FROM steps WHERE runId=? ORDER BY startedAt ASC")
+            .all(runId);
+        jsonResp(res, { ...run, steps });
+    }
+    catch (err) {
+        jsonResp(res, { error: String(err) }, 500);
+    }
+}
+/** DELETE /run-history — clear all history. */
+export function handleDeleteRunHistory(_req, res) {
+    try {
+        const d = getDb();
+        d.exec("DELETE FROM steps; DELETE FROM runs;");
+        jsonResp(res, { deleted: true });
+    }
+    catch (err) {
+        jsonResp(res, { error: String(err) }, 500);
+    }
+}
+/** Route matcher — returns the run ID if the URL matches /run-history/:id */
+export function matchRunHistoryRoute(req) {
+    const url = new URL(req.url ?? "/", "http://x");
+    const m = url.pathname.match(/^\/run-history\/([^/]+)$/);
+    if (m?.[1])
+        return { id: m[1] };
+    return null;
+}
+// ── Re-run handler ────────────────────────────────────────────────────────────
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}
+/** POST /run-history/:id/rerun — start a new process instance from a historical run. */
+export async function handleRerunHistory(req, res, runId) {
+    try {
+        const d = getDb();
+        const run = d.prepare("SELECT * FROM runs WHERE id=?").get(runId);
+        if (!run) {
+            jsonResp(res, { error: "Not found" }, 404);
+            return;
+        }
+        const profile = getActiveProfile();
+        if (!profile?.config.baseUrl) {
+            jsonResp(res, { error: "No active reebe profile" }, 503);
+            return;
+        }
+        const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+        let authHeader = "";
+        try {
+            authHeader = await getAuthHeader(profile.config);
+        }
+        catch {
+            // proceed without auth
+        }
+        // Parse optional variableOverrides from request body.
+        let variableOverrides = {};
+        try {
+            const raw = await readBody(req);
+            if (raw.trim()) {
+                const parsed = JSON.parse(raw);
+                variableOverrides = parsed.variableOverrides ?? {};
+            }
+        }
+        catch {
+            // ignore parse errors — no overrides
+        }
+        // Merge original snapshot with overrides.
+        let variables = {};
+        try {
+            variables = JSON.parse(run.variablesSnapshot);
+        }
+        catch {
+            // use empty object
+        }
+        variables = { ...variables, ...variableOverrides };
+        const processId = run.processId ?? "";
+        const startRes = await fetch(`${baseUrl}/v2/process-instances`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ processDefinitionId: processId, variables }),
+        });
+        if (!startRes.ok) {
+            jsonResp(res, { error: "Failed to start process instance" }, 502);
+            return;
+        }
+        const newPi = (await startRes.json());
+        jsonResp(res, { processInstanceKey: newPi.processInstanceKey });
+    }
+    catch (err) {
+        jsonResp(res, { error: String(err) }, 500);
+    }
+}
+/** Route matcher — returns run ID if URL matches /run-history/:id/rerun */
+export function matchRerunHistoryRoute(req) {
+    if (req.method !== "POST")
+        return null;
+    const url = new URL(req.url ?? "/", "http://x");
+    const m = url.pathname.match(/^\/run-history\/([^/]+)\/rerun$/);
+    if (m?.[1])
+        return { id: m[1] };
+    return null;
+}
+//# sourceMappingURL=run-history.js.map

package/dist/triggers/file-watcher.js

@@ -0,0 +1,215 @@
+/**
+ * File-watcher trigger — watches filesystem paths and starts a process
+ * instance when files are created or modified.
+ *
+ * Convention: service tasks with job type `io.bpmnkit:trigger:file-watch:1`
+ * and task header `watchPath` (and optionally `glob`, `events`) are picked up
+ * from deployed processes and set up as filesystem watchers.
+ *
+ * Uses Node's native `fs.watch` — no extra dependencies.
+ */
+import { existsSync, readFileSync, readdirSync, statSync, watch } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, relative } from "node:path";
+import { getActiveProfile, getAuthHeader } from "@bpmnkit/profiles";
+// ── Active watchers ───────────────────────────────────────────────────────────
+const watchers = new Map();
+function stopAll() {
+    for (const w of watchers.values())
+        w.close();
+    watchers.clear();
+}
+// ── Glob matcher (basename only) ──────────────────────────────────────────────
+function matchesGlob(filename, glob) {
+    const re = new RegExp(`^${glob
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".")}$`);
+    return re.test(filename);
+}
+// ── Start a process instance ──────────────────────────────────────────────────
+async function fireProcess(processId, variables) {
+    const profile = getActiveProfile();
+    if (!profile?.config.baseUrl)
+        return;
+    const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+    if (!baseUrl.startsWith("http"))
+        return;
+    let authHeader = "";
+    try {
+        authHeader = await getAuthHeader(profile.config);
+    }
+    catch {
+        // proceed unauthenticated
+    }
+    const res = await fetch(`${baseUrl}/v2/process-instances`, {
+        method: "POST",
+        headers: { authorization: authHeader, "content-type": "application/json" },
+        body: JSON.stringify({ processDefinitionId: processId, variables }),
+    });
+    if (res.ok) {
+        const data = (await res.json());
+        console.log(`[trigger:file-watch] fired ${processId} for ${String(variables.filePath)} → ${data.processInstanceKey ?? "?"}`);
+    }
+    else {
+        console.error(`[trigger:file-watch] failed to start ${processId}: ${res.status}`);
+    }
+}
+// ── Path helpers ──────────────────────────────────────────────────────────────
+function resolvePath(raw) {
+    if (raw === "~" || raw.startsWith("~/"))
+        return homedir() + raw.slice(1);
+    return raw;
+}
+// Track file modification times to distinguish add vs change
+const mtimeCache = new Map();
+function startWatcher(def) {
+    const dir = resolvePath(def.watchPath);
+    if (!existsSync(dir)) {
+        console.warn(`[trigger:file-watch] path not found, skipping: ${dir}`);
+        return;
+    }
+    // Seed mtime cache so existing files don't fire as "add" on startup
+    try {
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            try {
+                mtimeCache.set(full, statSync(full).mtimeMs);
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+    catch {
+        // skip
+    }
+    const watcher = watch(dir, { persistent: false }, (event, filename) => {
+        if (!filename)
+            return;
+        const file = basename(filename);
+        if (def.glob && !matchesGlob(file, def.glob))
+            return;
+        const filePath = join(dir, filename);
+        let mtime = 0;
+        try {
+            mtime = statSync(filePath).mtimeMs;
+        }
+        catch {
+            return; // file deleted — skip
+        }
+        const prev = mtimeCache.get(filePath);
+        const isAdd = prev === undefined;
+        const isChange = !isAdd && mtime !== prev;
+        mtimeCache.set(filePath, mtime);
+        if (def.events === "add" && !isAdd)
+            return;
+        if (def.events === "change" && !isChange)
+            return;
+        let content = "";
+        try {
+            if (statSync(filePath).size < 1_000_000) {
+                content = readFileSync(filePath, "utf8");
+            }
+        }
+        catch {
+            // ignore read errors
+        }
+        void fireProcess(def.processId, {
+            filePath,
+            fileName: file,
+            fileContent: content,
+            relativePath: relative(dir, filePath),
+            eventType: isAdd ? "add" : "change",
+        });
+    });
+    watchers.set(`${def.processId}:${dir}`, watcher);
+    console.log(`[trigger:file-watch] watching ${dir} for process ${def.processId}`);
+}
+// ── BPMN scanning ─────────────────────────────────────────────────────────────
+async function fetchDeployedProcesses(baseUrl, authHeader) {
+    const res = await fetch(`${baseUrl}/v2/process-definitions/search`, {
+        method: "POST",
+        headers: { authorization: authHeader, "content-type": "application/json" },
+        body: JSON.stringify({ pageSize: 100 }),
+    });
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    return data.items ?? [];
+}
+async function fetchProcessXml(baseUrl, authHeader, processId) {
+    const res = await fetch(`${baseUrl}/v2/process-definitions/${encodeURIComponent(processId)}/xml`, { headers: { authorization: authHeader } });
+    if (!res.ok)
+        return null;
+    const data = (await res.json());
+    return data.bpmnXml ?? null;
+}
+/**
+ * Extract file-watch trigger definitions from BPMN XML.
+ * Looks for service tasks with job type `io.bpmnkit:trigger:file-watch:1`
+ * and task headers `watchPath`, `glob?`, `events?`.
+ */
+function extractWatchDefs(processId, xml) {
+    const defs = [];
+    const taskRe = /<serviceTask[^>]*>[\s\S]*?<zeebe:taskDefinition[^>]*type="io\.bpmnkit:trigger:file-watch:1"[\s\S]*?<\/serviceTask>/g;
+    let m;
+    // biome-ignore lint/suspicious/noAssignInExpressions: standard regex loop
+    while ((m = taskRe.exec(xml)) !== null) {
+        const block = m[0];
+        const watchPath = /zeebe:header key="watchPath"\s+value="([^"]+)"/.exec(block)?.[1];
+        if (!watchPath)
+            continue;
+        const glob = /zeebe:header key="glob"\s+value="([^"]+)"/.exec(block)?.[1];
+        const eventsRaw = /zeebe:header key="events"\s+value="(add|change|all)"/.exec(block)?.[1];
+        const events = (eventsRaw ?? "all");
+        defs.push({ processId, watchPath, glob, events });
+    }
+    return defs;
+}
+// ── Scan and (re)apply watchers ───────────────────────────────────────────────
+async function scanAndApply() {
+    const profile = getActiveProfile();
+    if (!profile?.config.baseUrl)
+        return;
+    const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+    if (!baseUrl.startsWith("http"))
+        return;
+    let authHeader = "";
+    try {
+        authHeader = await getAuthHeader(profile.config);
+    }
+    catch {
+        // proceed unauthenticated
+    }
+    let processes;
+    try {
+        processes = await fetchDeployedProcesses(baseUrl, authHeader);
+    }
+    catch {
+        return;
+    }
+    const newDefs = [];
+    for (const proc of processes) {
+        const xml = await fetchProcessXml(baseUrl, authHeader, proc.processDefinitionId);
+        if (xml) {
+            newDefs.push(...extractWatchDefs(proc.processDefinitionId, xml));
+        }
+    }
+    if (newDefs.length === 0)
+        return;
+    // Restart all watchers with the fresh set
+    stopAll();
+    for (const def of newDefs) {
+        startWatcher(def);
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+const SCAN_INTERVAL_MS = 60_000;
+export function startFileWatchTrigger() {
+    void scanAndApply();
+    setInterval(() => {
+        void scanAndApply();
+    }, SCAN_INTERVAL_MS);
+}
+//# sourceMappingURL=file-watcher.js.map

package/dist/triggers/index.js

@@ -0,0 +1,18 @@
+/**
+ * Trigger orchestrator — starts all trigger types on proxy startup.
+ *
+ * Respects `BPMNKIT_TRIGGERS=false` to opt out of all triggers.
+ */
+import { startFileWatchTrigger } from "./file-watcher.js";
+import { startTimerTrigger } from "./timer.js";
+export { matchWebhookRoute, handleWebhook } from "./webhook.js";
+export function startTriggers() {
+    if (process.env.BPMNKIT_TRIGGERS === "false") {
+        console.log("[triggers] disabled via BPMNKIT_TRIGGERS=false");
+        return;
+    }
+    startTimerTrigger();
+    startFileWatchTrigger();
+    console.log("[triggers] timer and file-watch triggers started");
+}
+//# sourceMappingURL=index.js.map