@10et/cli 1.0.0

package/dist/lib/flow-engine.js

@@ -0,0 +1,717 @@
+/**
+ * Flow Engine
+ *
+ * Reactive automation for the MAP event bus. Loads declarative flow
+ * definitions and executes actions when trigger patterns match.
+ *
+ * @purpose Execute declarative flows: event trigger → action sequence
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { parse as parseYaml } from "yaml";
+import { telemetry } from "./telemetry.js";
+export class FlowEngine {
+    flows = [];
+    eventBus;
+    projectRoot;
+    subscriptionIds = [];
+    executions = [];
+    maxExecutions = 200;
+    children = [];
+    childAbortControllers = [];
+    cronTimers = [];
+    activeSpawns = new Map();
+    lastSpawnTime = new Map();
+    constructor(eventBus, projectRoot) {
+        this.eventBus = eventBus;
+        this.projectRoot = projectRoot;
+    }
+    setChildren(children) {
+        this.children = children;
+    }
+    async start() {
+        this.flows = this.loadFlows();
+        const enabled = this.flows.filter(f => f.enabled);
+        for (const flow of enabled) {
+            const sub = this.eventBus.subscribe({
+                clientId: `flow:${flow.name}`,
+                patterns: [flow.trigger.pattern],
+                transport: "poll",
+                callback: (event) => this.handleEvent(flow, event),
+            });
+            this.subscriptionIds.push(sub.id);
+        }
+        if (this.children.length > 0) {
+            this.connectToChildren();
+        }
+        this.startCronEmitters(enabled);
+        return enabled.length;
+    }
+    stop() {
+        for (const id of this.subscriptionIds) {
+            this.eventBus.unsubscribe(id);
+        }
+        this.subscriptionIds = [];
+        for (const ac of this.childAbortControllers) {
+            ac.abort();
+        }
+        this.childAbortControllers = [];
+        for (const timer of this.cronTimers) {
+            clearInterval(timer);
+        }
+        this.cronTimers = [];
+    }
+    getFlows() {
+        return [...this.flows];
+    }
+    getExecutions() {
+        return [...this.executions];
+    }
+    toggleFlow(name, enabled) {
+        const flow = this.flows.find(f => f.name === name);
+        if (!flow)
+            return null;
+        flow.enabled = enabled ?? !flow.enabled;
+        if (flow.enabled) {
+            const existing = this.subscriptionIds.find(id => id.includes(name));
+            if (!existing) {
+                const sub = this.eventBus.subscribe({
+                    clientId: `flow:${flow.name}`,
+                    patterns: [flow.trigger.pattern],
+                    transport: "poll",
+                    callback: (event) => this.handleEvent(flow, event),
+                });
+                this.subscriptionIds.push(sub.id);
+            }
+        }
+        else {
+            const subIdx = this.subscriptionIds.findIndex(id => id.includes(name));
+            if (subIdx !== -1) {
+                this.eventBus.unsubscribe(this.subscriptionIds[subIdx]);
+                this.subscriptionIds.splice(subIdx, 1);
+            }
+        }
+        return flow;
+    }
+    async approveGated(flowName, triggerEventId) {
+        const execIdx = this.executions.findIndex(e => e.flow === flowName && e.trigger_event_id === triggerEventId && e.gated);
+        if (execIdx === -1)
+            return null;
+        const exec = this.executions[execIdx];
+        const flow = this.flows.find(f => f.name === flowName);
+        if (!flow)
+            return null;
+        const busEvents = this.eventBus.getEvents({ limit: 500 });
+        const original = busEvents.find((e) => e.id === triggerEventId);
+        const now = new Date().toISOString();
+        const event = original || {
+            id: triggerEventId,
+            ts: now,
+            type: exec.trigger_event_type,
+            source: `approved:${flowName}`,
+            data: {},
+        };
+        exec.gated = undefined;
+        exec.started_at = new Date().toISOString();
+        exec.actions_executed = 0;
+        exec.actions_failed = 0;
+        delete exec.error;
+        for (const action of flow.actions) {
+            try {
+                await this.executeAction(action, event, flow);
+                exec.actions_executed++;
+            }
+            catch (err) {
+                exec.actions_failed++;
+                exec.error = err.message;
+            }
+        }
+        exec.completed_at = new Date().toISOString();
+        this.eventBus.emit({
+            type: "flow:completed",
+            source: `flow:${flow.name}`,
+            data: {
+                flow_name: flow.name,
+                approved: true,
+                trigger_event_id: triggerEventId,
+                actions_executed: exec.actions_executed,
+                actions_failed: exec.actions_failed,
+            },
+        });
+        return exec;
+    }
+    startCronEmitters(enabledFlows) {
+        const cronPatterns = new Set();
+        for (const flow of enabledFlows) {
+            if (flow.trigger.pattern.startsWith("cron:")) {
+                cronPatterns.add(flow.trigger.pattern);
+            }
+        }
+        if (cronPatterns.size === 0)
+            return;
+        const cronIntervals = {
+            "cron:daily": 24 * 60 * 60 * 1000,
+            "cron:hourly": 60 * 60 * 1000,
+            "cron:every-30-minutes": 30 * 60 * 1000,
+        };
+        for (const pattern of cronPatterns) {
+            const intervalMs = cronIntervals[pattern];
+            if (!intervalMs) {
+                console.warn(`[FlowEngine] Unknown cron pattern: ${pattern}`);
+                continue;
+            }
+            console.log(`[FlowEngine] Cron emitter registered: ${pattern} (every ${intervalMs / 1000}s)`);
+            const emitCron = () => {
+                this.eventBus.emit({
+                    type: pattern,
+                    source: "cron",
+                    data: { time: new Date().toISOString(), pattern },
+                });
+            };
+            const timer = setInterval(emitCron, intervalMs);
+            this.cronTimers.push(timer);
+            // Emit once on startup after a short delay so flows are ready
+            setTimeout(emitCron, 5000);
+        }
+    }
+    connectToChildren() {
+        for (const child of this.children) {
+            const ac = new AbortController();
+            this.childAbortControllers.push(ac);
+            this.subscribeToChild(child, ac.signal);
+        }
+    }
+    async subscribeToChild(child, signal) {
+        const url = new URL(`http://localhost:${child.port}/api/events/stream?patterns=*`);
+        if (child.token)
+            url.searchParams.set("token", child.token);
+        const connect = async () => {
+            try {
+                const response = await fetch(url.toString(), { signal });
+                if (!response.ok || !response.body)
+                    return;
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (!signal.aborted) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() || "";
+                    for (const line of lines) {
+                        if (!line.startsWith("data: "))
+                            continue;
+                        try {
+                            const event = JSON.parse(line.slice(6));
+                            if (event.type?.startsWith("flow:"))
+                                continue;
+                            this.eventBus.emit({
+                                type: event.type,
+                                source: `child:${child.name}:${event.source || "unknown"}`,
+                                session: event.session,
+                                data: { ...event.data, _child: child.name, _child_port: child.port },
+                            });
+                        }
+                        catch {
+                            // skip malformed SSE data
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (signal.aborted)
+                    return;
+                console.warn(`[FlowEngine] Child ${child.name} SSE disconnected: ${err.message}`);
+            }
+            if (!signal.aborted) {
+                setTimeout(() => connect(), 5000);
+            }
+        };
+        connect();
+    }
+    loadFlows() {
+        const yamlPath = path.join(this.projectRoot, ".jfl", "flows.yaml");
+        const jsonPath = path.join(this.projectRoot, ".jfl", "flows.json");
+        let config = null;
+        if (fs.existsSync(yamlPath)) {
+            try {
+                const content = fs.readFileSync(yamlPath, "utf-8");
+                config = parseYaml(content);
+            }
+            catch (err) {
+                console.error(`[FlowEngine] Failed to parse ${yamlPath}: ${err.message}`);
+            }
+        }
+        else if (fs.existsSync(jsonPath)) {
+            try {
+                const content = fs.readFileSync(jsonPath, "utf-8");
+                config = JSON.parse(content);
+            }
+            catch (err) {
+                console.error(`[FlowEngine] Failed to parse ${jsonPath}: ${err.message}`);
+            }
+        }
+        const allFlows = [];
+        if (config?.flows && Array.isArray(config.flows)) {
+            // Normalize: trigger.cron → trigger.pattern for consistency
+            for (const f of config.flows) {
+                if (f.trigger && !f.trigger.pattern && f.trigger.cron) {
+                    f.trigger.pattern = `cron:${f.trigger.cron}`;
+                }
+            }
+            const valid = config.flows.filter(f => f.name && f.trigger?.pattern && Array.isArray(f.actions));
+            allFlows.push(...valid);
+        }
+        const flowsDir = path.join(this.projectRoot, ".jfl", "flows");
+        if (fs.existsSync(flowsDir)) {
+            const yamlFiles = fs.readdirSync(flowsDir).filter(f => f.endsWith(".yaml") || f.endsWith(".yml"));
+            for (const file of yamlFiles) {
+                try {
+                    const content = fs.readFileSync(path.join(flowsDir, file), "utf-8");
+                    const extra = parseYaml(content);
+                    if (extra?.flows && Array.isArray(extra.flows)) {
+                        // Normalize: trigger.cron → trigger.pattern
+                        for (const f of extra.flows) {
+                            if (f.trigger && !f.trigger.pattern && f.trigger.cron) {
+                                f.trigger.pattern = `cron:${f.trigger.cron}`;
+                            }
+                        }
+                        const valid = extra.flows.filter(f => f.name && f.trigger?.pattern && Array.isArray(f.actions));
+                        allFlows.push(...valid);
+                    }
+                }
+                catch (err) {
+                    console.error(`[FlowEngine] Failed to parse ${file}: ${err.message}`);
+                }
+            }
+        }
+        if (allFlows.length === 0) {
+            return [];
+        }
+        const valid = allFlows;
+        for (const flow of valid) {
+            if (flow.trigger.condition) {
+                const check = FlowEngine.validateCondition(flow.trigger.condition);
+                if (!check.valid) {
+                    console.warn(`[FlowEngine] Flow "${flow.name}": ${check.error}`);
+                }
+            }
+        }
+        return valid;
+    }
+    async handleEvent(flow, event) {
+        if (event.type.startsWith("flow:"))
+            return;
+        if (flow.trigger.source && event.source !== flow.trigger.source)
+            return;
+        if (flow.trigger.condition && !this.evaluateCondition(flow.trigger.condition, event))
+            return;
+        const gateResult = this.evaluateGate(flow.gate, flow.name);
+        if (gateResult) {
+            const gatedExecution = {
+                flow: flow.name,
+                trigger_event_id: event.id,
+                trigger_event_type: event.type,
+                started_at: new Date().toISOString(),
+                completed_at: new Date().toISOString(),
+                actions_executed: 0,
+                actions_failed: 0,
+                gated: gateResult,
+            };
+            this.executions.push(gatedExecution);
+            if (this.executions.length > this.maxExecutions) {
+                this.executions = this.executions.slice(-this.maxExecutions);
+            }
+            this.eventBus.emit({
+                type: "flow:triggered",
+                source: `flow:${flow.name}`,
+                session: event.session,
+                data: {
+                    flow_name: flow.name,
+                    trigger_event_id: event.id,
+                    gated: gateResult,
+                },
+            });
+            telemetry.track({
+                category: 'hooks',
+                event: 'flow:triggered',
+                flow_name: flow.name,
+                hook_event_name: event.type,
+                actions_failed: 0,
+            });
+            return;
+        }
+        const execution = {
+            flow: flow.name,
+            trigger_event_id: event.id,
+            trigger_event_type: event.type,
+            started_at: new Date().toISOString(),
+            actions_executed: 0,
+            actions_failed: 0,
+        };
+        this.eventBus.emit({
+            type: "flow:triggered",
+            source: `flow:${flow.name}`,
+            session: event.session,
+            data: {
+                flow_name: flow.name,
+                trigger_event_id: event.id,
+                trigger_event_type: event.type,
+            },
+        });
+        telemetry.track({
+            category: 'hooks',
+            event: 'flow:triggered',
+            flow_name: flow.name,
+            hook_event_name: event.type,
+        });
+        for (const action of flow.actions) {
+            try {
+                await this.executeAction(action, event, flow);
+                execution.actions_executed++;
+            }
+            catch (err) {
+                execution.actions_failed++;
+                execution.error = err.message;
+                console.error(`[FlowEngine] Action failed in flow "${flow.name}": ${err.message}`);
+            }
+        }
+        execution.completed_at = new Date().toISOString();
+        this.executions.push(execution);
+        if (this.executions.length > this.maxExecutions) {
+            this.executions = this.executions.slice(-this.maxExecutions);
+        }
+        this.eventBus.emit({
+            type: "flow:completed",
+            source: `flow:${flow.name}`,
+            session: event.session,
+            data: {
+                flow_name: flow.name,
+                trigger_event_id: event.id,
+                actions_executed: execution.actions_executed,
+                actions_failed: execution.actions_failed,
+                duration_ms: new Date(execution.completed_at).getTime() - new Date(execution.started_at).getTime(),
+            },
+        });
+        telemetry.track({
+            category: 'hooks',
+            event: 'flow:completed',
+            flow_name: flow.name,
+            hook_event_name: event.type,
+            actions_failed: execution.actions_failed,
+            duration_ms: new Date(execution.completed_at).getTime() - new Date(execution.started_at).getTime(),
+        });
+    }
+    async executeAction(action, event, flow) {
+        switch (action.type) {
+            case "log": {
+                const message = this.interpolate(action.message, event);
+                const ts = new Date().toISOString();
+                console.log(`[${ts}] [Flow:${flow.name}] ${message}`);
+                break;
+            }
+            case "emit": {
+                const data = {};
+                if (action.data) {
+                    for (const [key, value] of Object.entries(action.data)) {
+                        data[key] = typeof value === "string" ? this.interpolate(value, event) : value;
+                    }
+                }
+                this.eventBus.emit({
+                    type: action.event_type,
+                    source: `flow:${flow.name}`,
+                    session: event.session,
+                    data,
+                });
+                break;
+            }
+            case "journal": {
+                const journalDir = path.join(this.projectRoot, ".jfl", "journal");
+                if (!fs.existsSync(journalDir)) {
+                    fs.mkdirSync(journalDir, { recursive: true });
+                }
+                const entry = {
+                    v: 1,
+                    ts: new Date().toISOString(),
+                    session: event.session || "flow-engine",
+                    type: this.interpolate(action.entry_type, event),
+                    title: this.interpolate(action.title, event),
+                    summary: this.interpolate(action.summary, event),
+                    status: "complete",
+                };
+                const journalFile = path.join(journalDir, "flow-engine.jsonl");
+                fs.appendFileSync(journalFile, JSON.stringify(entry) + "\n");
+                break;
+            }
+            case "webhook": {
+                const url = this.interpolate(action.url, event);
+                const body = action.body ? JSON.stringify(action.body) : JSON.stringify(event.data);
+                await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body,
+                    signal: AbortSignal.timeout(10000),
+                });
+                break;
+            }
+            case "command": {
+                const { execSync, spawn: spawnCmd } = await import("child_process");
+                const cmd = this.interpolate(action.command, event);
+                const args = (action.args || []).map(a => this.interpolate(a, event));
+                const fullCmd = [cmd, ...args].join(" ");
+                // Long-running commands (agent spawns) run detached
+                const isLongRunning = fullCmd.includes("jfl peter") || fullCmd.includes("jfl agent") || action.detach;
+                if (isLongRunning) {
+                    const child = spawnCmd("bash", ["-c", fullCmd], {
+                        cwd: this.projectRoot,
+                        detached: true,
+                        stdio: "ignore",
+                    });
+                    child.unref();
+                    console.log(`[FlowEngine] Spawned detached: ${fullCmd.slice(0, 80)}...`);
+                }
+                else {
+                    execSync(fullCmd, {
+                        cwd: this.projectRoot,
+                        timeout: 60000,
+                        stdio: "pipe",
+                    });
+                }
+                break;
+            }
+            case "spawn": {
+                const { spawn: nodeSpawn, execSync: spawnExecSync } = await import("child_process");
+                if (this.activeSpawns.has(flow.name)) {
+                    const active = this.activeSpawns.get(flow.name);
+                    try {
+                        process.kill(active.pid, 0);
+                        console.log(`[FlowEngine] Spawn skipped for "${flow.name}": already running (PID ${active.pid})`);
+                        break;
+                    }
+                    catch {
+                        this.cleanupSpawn(flow.name);
+                    }
+                }
+                const cooldownHours = action.cooldown_hours ?? 0;
+                if (cooldownHours > 0) {
+                    const lastSpawn = this.lastSpawnTime.get(flow.name) || 0;
+                    const cooldownMs = cooldownHours * 60 * 60 * 1000;
+                    const elapsed = Date.now() - lastSpawn;
+                    if (elapsed < cooldownMs) {
+                        const remaining = Math.round((cooldownMs - elapsed) / 3600000 * 10) / 10;
+                        console.log(`[FlowEngine] Spawn skipped for "${flow.name}": cooldown (${remaining}h remaining)`);
+                        break;
+                    }
+                }
+                const cmd = this.interpolate(action.command, event);
+                const args = (action.args || []).map(a => this.interpolate(a, event));
+                const target = action.target || "worktree";
+                const env = { ...process.env };
+                delete env.CLAUDECODE;
+                delete env.CLAUDE_CODE;
+                if (action.env) {
+                    for (const [k, v] of Object.entries(action.env)) {
+                        env[k] = this.interpolate(v, event);
+                    }
+                }
+                let cwd;
+                let worktreePath;
+                if (target === "worktree") {
+                    const worktreeId = `pp-${flow.name}-${Date.now()}`;
+                    worktreePath = path.join("/tmp", `jfl-${worktreeId}`);
+                    try {
+                        spawnExecSync(`git worktree add "${worktreePath}" -b "${worktreeId}" origin/main`, {
+                            cwd: this.projectRoot,
+                            stdio: "pipe",
+                            timeout: 30000,
+                        });
+                        console.log(`[FlowEngine] Worktree created for "${flow.name}": ${worktreePath}`);
+                    }
+                    catch (err) {
+                        console.error(`[FlowEngine] Worktree creation failed for "${flow.name}": ${err.message}`);
+                        break;
+                    }
+                    cwd = worktreePath;
+                    env.JFL_WORKTREE = worktreePath;
+                    env.JFL_SPAWN_FLOW = flow.name;
+                }
+                else {
+                    cwd = action.cwd ? this.interpolate(action.cwd, event) : this.projectRoot;
+                }
+                const child = nodeSpawn(cmd, args, {
+                    cwd,
+                    env,
+                    stdio: "ignore",
+                    detached: action.detach ?? true,
+                });
+                child.on('error', (err) => {
+                    console.error(`[FlowEngine] Spawn failed in flow "${flow.name}": ${err.message}`);
+                    this.cleanupSpawn(flow.name);
+                });
+                child.on('exit', (code) => {
+                    console.log(`[FlowEngine] Flow "${flow.name}" exited (code=${code})`);
+                    // Delay cleanup slightly to ensure agent has flushed all writes
+                    setTimeout(() => this.cleanupSpawn(flow.name), 2000);
+                });
+                if (action.detach !== false)
+                    child.unref();
+                this.activeSpawns.set(flow.name, {
+                    pid: child.pid,
+                    startedAt: new Date().toISOString(),
+                    worktree: worktreePath,
+                });
+                this.lastSpawnTime.set(flow.name, Date.now());
+                // For detached processes, poll for exit since unref'd children
+                // don't reliably fire 'exit' events on the parent
+                if (action.detach !== false && child.pid) {
+                    const pollPid = child.pid;
+                    const pollFlowName = flow.name;
+                    const pollInterval = setInterval(() => {
+                        try {
+                            process.kill(pollPid, 0); // Just check if alive
+                        }
+                        catch {
+                            // Process exited — clean up
+                            clearInterval(pollInterval);
+                            console.log(`[FlowEngine] Detected exit for detached "${pollFlowName}" (PID ${pollPid})`);
+                            setTimeout(() => this.cleanupSpawn(pollFlowName), 2000);
+                        }
+                    }, 15000); // Check every 15 seconds
+                    pollInterval.unref(); // Don't keep the process alive for this
+                }
+                console.log(`[FlowEngine] Spawned "${flow.name}" (PID ${child.pid}, target=${target}${worktreePath ? `, worktree=${worktreePath}` : ''})`);
+                break;
+            }
+        }
+    }
+    interpolate(template, event) {
+        return template.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (_match, varPath) => {
+            const parts = varPath.split(".");
+            if (parts[0] === "child" && parts.length >= 3) {
+                const childName = parts[1];
+                const field = parts[2];
+                const child = this.children.find(c => c.name === childName);
+                if (!child)
+                    return "";
+                if (field === "port")
+                    return String(child.port);
+                if (field === "path")
+                    return child.path;
+                if (field === "token")
+                    return child.token || "";
+                if (field === "name")
+                    return child.name;
+                return "";
+            }
+            let value = event;
+            for (const part of parts) {
+                if (value == null)
+                    return "";
+                value = value[part];
+            }
+            if (value == null)
+                return "";
+            if (typeof value === "object")
+                return JSON.stringify(value);
+            return String(value);
+        });
+    }
+    cleanupSpawn(flowName) {
+        const active = this.activeSpawns.get(flowName);
+        if (!active)
+            return;
+        if (active.worktree) {
+            try {
+                const { execSync: cleanupExec } = require("child_process");
+                const branchName = active.worktree.split("/").pop() ?? "";
+                // Remove worktree directory
+                cleanupExec(`git worktree remove "${active.worktree}" --force`, {
+                    cwd: this.projectRoot, stdio: "pipe", timeout: 10000,
+                });
+                // Delete the branch created for this worktree
+                if (branchName) {
+                    cleanupExec(`git branch -D "${branchName}"`, {
+                        cwd: this.projectRoot, stdio: "pipe", timeout: 5000,
+                    });
+                }
+                // Prune any orphaned worktree refs
+                cleanupExec("git worktree prune", {
+                    cwd: this.projectRoot, stdio: "pipe", timeout: 5000,
+                });
+                console.log(`[FlowEngine] Cleaned up: worktree + branch "${branchName}"`);
+            }
+            catch {
+                // Non-fatal — doctor --fix will catch stragglers
+            }
+        }
+        this.activeSpawns.delete(flowName);
+    }
+    getActiveSpawns() {
+        return new Map(this.activeSpawns);
+    }
+    evaluateGate(gate, flowName) {
+        if (!gate)
+            return null;
+        const now = new Date();
+        if (gate.after) {
+            const afterDate = new Date(gate.after);
+            if (now < afterDate)
+                return "time";
+        }
+        if (gate.before) {
+            const beforeDate = new Date(gate.before);
+            if (now > beforeDate)
+                return "time";
+        }
+        if (gate.requires_approval)
+            return "approval";
+        // Check cooldown: skip if this flow ran within cooldown_hours
+        if (gate.cooldown_hours && gate.cooldown_hours > 0 && flowName) {
+            const cooldownMs = gate.cooldown_hours * 60 * 60 * 1000;
+            const lastRun = this.executions
+                .filter(e => e.flow === flowName && !e.gated)
+                .sort((a, b) => (b.completed_at || b.started_at).localeCompare(a.completed_at || a.started_at))[0];
+            if (lastRun) {
+                const elapsed = now.getTime() - new Date(lastRun.completed_at || lastRun.started_at).getTime();
+                if (elapsed < cooldownMs)
+                    return "cooldown";
+            }
+        }
+        return null;
+    }
+    evaluateCondition(condition, event) {
+        try {
+            const match = condition.match(/^(\w+(?:\.\w+)*)\s*(==|!=|contains)\s*"([^"]*)"$/);
+            if (!match)
+                return false;
+            const [, fieldPath, operator, expected] = match;
+            const parts = fieldPath.split(".");
+            let value = event;
+            for (const part of parts) {
+                if (value == null)
+                    return false;
+                value = value[part];
+            }
+            const strValue = value == null ? "" : String(value);
+            switch (operator) {
+                case "==": return strValue === expected;
+                case "!=": return strValue !== expected;
+                case "contains": return strValue.includes(expected);
+                default: return false;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    static validateCondition(condition) {
+        const match = condition.match(/^(\w+(?:\.\w+)*)\s*(==|!=|contains)\s*"([^"]*)"$/);
+        if (!match) {
+            return { valid: false, error: `Invalid condition format: "${condition}". Expected: field operator "value" (operators: ==, !=, contains)` };
+        }
+        return { valid: true };
+    }
+}
+//# sourceMappingURL=flow-engine.js.map