botforje 0.0.1

package/dist/flow/executor.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowExecutor = void 0;
+const action_1 = require("../action/action");
+const action_2 = require("../action/action");
+const webhook_1 = require("../action/webhook");
+const fuzzy_1 = require("../helpers/fuzzy");
+const logger_1 = require("../helpers/logger");
+class FlowExecutor {
+    constructor(actionCatalog, flowCatalog, flowStateService, outboxService, defaultTimeout = 300, cooldownService) {
+        this.actionCatalog = actionCatalog;
+        this.flowCatalog = flowCatalog;
+        this.flowStateService = flowStateService;
+        this.outboxService = outboxService;
+        this.defaultTimeout = defaultTimeout;
+        this.cooldownService = cooldownService;
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    updateCatalogs(actionCatalog, flowCatalog) {
+        this.actionCatalog = actionCatalog;
+        this.flowCatalog = flowCatalog;
+    }
+    async handleMessage(bot, message) {
+        this.flowStateService.cleanupExpired();
+        const state = this.flowStateService.findActive(message.from, bot.id);
+        if (state) {
+            return this.handleActiveState(bot, message, state);
+        }
+        return this.handleNewMessage(bot, message);
+    }
+    async handleActiveState(bot, message, state) {
+        const flow = this.flowCatalog.get(state.flowId);
+        if (!flow) {
+            this.flowStateService.destroy(state.id);
+            return false;
+        }
+        const currentStep = flow.steps[state.stepId];
+        if (!currentStep) {
+            this.flowStateService.destroy(state.id);
+            return false;
+        }
+        this.logger.debug(`[active] flow="${flow.id}" step="${state.stepId}" action="${currentStep.action}"`);
+        this.logger.debug(`  message: "${message.content}" from "${message.from}"`);
+        const match = this.findBestBranch(flow, state, message.content);
+        if (!match) {
+            if (flow.fallbackStep && flow.steps[flow.fallbackStep]) {
+                await this.transitionToStep(bot, message, state, flow, flow.fallbackStep);
+                return true;
+            }
+            this.logger.debug(`  no branch matched, ignoring`);
+            return true;
+        }
+        this.logger.debug(`  >> goto="${match.branch.goto}" | node=${match.nodeIndex} score=${match.score.toFixed(3)}`);
+        await this.transitionToStep(bot, message, state, flow, match.branch.goto);
+        return true;
+    }
+    async handleNewMessage(bot, message) {
+        const flowRefs = [...bot.flows].sort((a, b) => b.priority - a.priority);
+        for (const flowRef of flowRefs) {
+            const flow = this.flowCatalog.get(flowRef.id);
+            if (!flow) {
+                this.logger.warn(`Flow "${flowRef.id}" referenced by bot "${bot.id}" not found`);
+                continue;
+            }
+            const entryStep = flow.steps[flow.entryStep];
+            if (!entryStep) {
+                this.logger.warn(`Entry step "${flow.entryStep}" for flow "${flow.id}" not found`);
+                continue;
+            }
+            if (!this.matchesFlowTriggers(flow, message.content)) {
+                this.logger.debug(`new: flow "${flow.id}" triggers no match, skip`);
+                continue;
+            }
+            this.logger.debug(`new: flow "${flow.id}" matched, enter "${flow.entryStep}"`);
+            const consumed = await this.executeStepAction(bot, message, entryStep, {});
+            if (!consumed) {
+                return false;
+            }
+            if (entryStep.branches.length === 0) {
+                this.flowStateService.destroyBySenderBot(message.from, bot.id);
+            }
+            else {
+                const timeout = flow.timeout ?? this.defaultTimeout;
+                this.flowStateService.create(message.from, bot.id, flow.id, flow.entryStep, timeout, Date.now(), { __visitedSteps: [] });
+            }
+            return true;
+        }
+        return false;
+    }
+    async transitionToStep(bot, message, state, flow, stepId) {
+        const step = flow.steps[stepId];
+        if (!step) {
+            this.logger.error(`Step "${stepId}" not found in flow "${flow.id}"`);
+            this.flowStateService.destroy(state.id);
+            return;
+        }
+        const vars = { ...state.variables };
+        const visited = vars.__visitedSteps ?? [];
+        if (stepId === flow.entryStep) {
+            vars.__visitedSteps = [];
+        }
+        else if (stepId !== state.stepId) {
+            const prevStep = flow.steps[state.stepId];
+            const hasNavBranches = prevStep?.branches.some(b => b.when && b.when.length > 0);
+            if (hasNavBranches) {
+                if (visited.includes(state.stepId)) {
+                    const reordered = visited.filter(s => s !== state.stepId);
+                    vars.__visitedSteps = [...reordered, state.stepId];
+                }
+                else {
+                    vars.__visitedSteps = [...visited, state.stepId];
+                }
+            }
+        }
+        await this.executeStepAction(bot, message, step, vars);
+        if (step.branches.length === 0) {
+            this.flowStateService.destroy(state.id);
+        }
+        else {
+            this.flowStateService.updateStep(state.id, stepId, vars);
+            this.logger.debug(`  visited updated: [${(vars.__visitedSteps ?? []).join(', ')}]`);
+        }
+    }
+    findBestBranch(flow, state, message) {
+        const visited = state.variables?.__visitedSteps ?? [];
+        const currentStep = flow.steps[state.stepId];
+        if (!currentStep)
+            return null;
+        this.logger.debug(`  context: "${message}"`);
+        this.logger.debug(`  current: ${state.stepId} | visited: [${visited.join(', ')}]`);
+        const nodes = [];
+        const allStepNames = [...new Set([...visited, state.stepId])];
+        for (const stepName of allStepNames) {
+            const step = flow.steps[stepName];
+            if (step && stepName !== state.stepId) {
+                nodes.push({ branches: step.branches, stepName });
+            }
+        }
+        nodes.push({ branches: currentStep.branches, stepName: state.stepId });
+        let best = null;
+        for (let ni = 0; ni < nodes.length; ni++) {
+            const node = nodes[ni];
+            const branchList = node.branches || [];
+            const condBranches = branchList.filter(b => b.when && b.when.length > 0);
+            if (condBranches.length === 0) {
+                this.logger.debug(`    Node ${ni} ${node.stepName}: 0 conditional branches`);
+                continue;
+            }
+            this.logger.debug(`    Node ${ni} ${node.stepName} — ${condBranches.length} branches:`);
+            for (let bi = 0; bi < condBranches.length; bi++) {
+                const branch = condBranches[bi];
+                const threshold = branch.fuzzyThreshold ?? 0.6;
+                const result = (0, fuzzy_1.matchFuzzyVerbose)(branch.when, message, threshold);
+                if (!result) {
+                    this.logger.debug(`      [${bi}] when="${branch.when}" → ${branch.goto}`);
+                    continue;
+                }
+                const isBest = !best ||
+                    result.score < best.score ||
+                    (result.score === best.score && ni > best.nodeIndex);
+                const marker = isBest ? '◀ BEST' : '◀ worse';
+                this.logger.debug(`      [${bi}] when="${branch.when}" → ${branch.goto} | match="${result.match}" score=${result.score.toFixed(3)} ${marker}`);
+                if (isBest) {
+                    best = { branch, score: result.score, nodeIndex: ni };
+                }
+            }
+        }
+        if (best) {
+            this.logger.debug(`    >> winner: Node ${best.nodeIndex} goto="${best.branch.goto}" score=${best.score.toFixed(3)}`);
+            return best;
+        }
+        const defaultBranch = currentStep.branches.find(b => !b.when || b.when.length === 0);
+        if (defaultBranch) {
+            this.logger.debug(`    >> default → goto="${defaultBranch.goto}"`);
+            return { branch: defaultBranch, score: 1, nodeIndex: nodes.length - 1 };
+        }
+        this.logger.debug(`    >> no match`);
+        return null;
+    }
+    matchesFlowTriggers(flow, message) {
+        if (!flow.triggers || flow.triggers.length === 0) {
+            return false;
+        }
+        this.logger.debug(`  triggers: flow="${flow.id}" ${flow.triggers.length} triggers`);
+        for (let i = 0; i < flow.triggers.length; i++) {
+            const trigger = flow.triggers[i];
+            const threshold = trigger.fuzzyThreshold ?? 0.6;
+            const result = (0, fuzzy_1.matchFuzzyVerbose)(trigger.phrases, message, threshold);
+            if (result) {
+                this.logger.debug(`    [${i}] MATCH: "${result.match}" score=${result.score.toFixed(3)}`);
+                return true;
+            }
+        }
+        return false;
+    }
+    async executeStepAction(bot, message, step, variables) {
+        const context = {
+            botId: bot.id,
+            botName: bot.id,
+            sender: message.from,
+            senderName: message.senderName,
+            message: message.content,
+            variables,
+        };
+        if (this.isActionOnCooldown(bot, step.action, message.from)) {
+            const action = (0, action_1.getAction)(this.actionCatalog, step.action);
+            if (action.cooldownReply) {
+                const reply = (0, action_2.resolveVars)(action.cooldownReply, context);
+                this.outboxService.enqueue(bot.id, message.from, reply);
+                this.logger.info(`Cooldown reply sent for action "${step.action}" to ${message.from}`);
+                return true;
+            }
+            this.logger.warn(`Action "${step.action}" on cooldown, no cooldown_reply defined, skipping`);
+            return false;
+        }
+        const result = (0, action_1.executeAction)(this.actionCatalog, step.action, context);
+        this.setActionCooldown(step.action, message.from);
+        if (result.reply) {
+            this.outboxService.enqueue(bot.id, message.from, result.reply);
+        }
+        if (result.location) {
+            this.outboxService.enqueue(bot.id, message.from, '', {
+                type: 'location',
+                latitude: result.location.latitude,
+                longitude: result.location.longitude,
+                name: result.location.name,
+                address: result.location.address,
+                url: result.location.url,
+                description: result.location.description,
+            });
+        }
+        if (result.webhook) {
+            try {
+                const payload = this.buildWebhookPayload(bot, message, result.webhook.name || 'unnamed');
+                await (0, webhook_1.sendWebhookRequest)({
+                    url: result.webhook.url,
+                    method: result.webhook.method,
+                    headers: result.webhook.headers,
+                    body: payload,
+                    timeout: result.webhook.timeout,
+                    retries: result.webhook.retries,
+                });
+            }
+            catch (error) {
+                this.logger.error(`Failed to trigger webhook action for bot "${bot.id}":`, error);
+            }
+        }
+        return true;
+    }
+    isActionOnCooldown(bot, actionId, sender) {
+        if (!this.cooldownService) {
+            return false;
+        }
+        const action = (0, action_1.getAction)(this.actionCatalog, actionId);
+        if (!action.cooldown || action.cooldown <= 0) {
+            return false;
+        }
+        const cooldownMs = action.cooldown * 1000;
+        const cooldownKey = `action:${actionId}`;
+        return this.cooldownService.isOnCooldown(sender, cooldownKey, cooldownMs);
+    }
+    setActionCooldown(actionId, sender) {
+        if (!this.cooldownService) {
+            return;
+        }
+        const action = (0, action_1.getAction)(this.actionCatalog, actionId);
+        if (!action.cooldown || action.cooldown <= 0) {
+            return;
+        }
+        this.cooldownService.setCooldown(sender, `action:${actionId}`);
+    }
+    buildWebhookPayload(bot, message, webhookName) {
+        return {
+            sender: message.from,
+            message: message.content,
+            timestamp: message.timestamp.toISOString(),
+            botId: bot.id,
+            botName: bot.id,
+            webhookName,
+            metadata: message.metadata || {},
+        };
+    }
+}
+exports.FlowExecutor = FlowExecutor;

package/dist/flow/flow.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/flow/mapper.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapFlowCatalog = mapFlowCatalog;
+function mapFlowCatalog(config) {
+    const catalog = new Map();
+    for (const [id, flowConfig] of Object.entries(config)) {
+        catalog.set(id, mapFlow(id, flowConfig));
+    }
+    return catalog;
+}
+function mapFlow(id, config) {
+    if (!config.steps[config.entry_step]) {
+        throw new Error(`Flow "${id}" entry step "${config.entry_step}" not found`);
+    }
+    const steps = {};
+    for (const [stepId, stepConfig] of Object.entries(config.steps)) {
+        steps[stepId] = mapStep(stepConfig);
+    }
+    if (config.fallback_step && !steps[config.fallback_step]) {
+        throw new Error(`Flow "${id}" fallback step "${config.fallback_step}" not found`);
+    }
+    return {
+        id,
+        entryStep: config.entry_step,
+        triggers: config.triggers ? mapTriggers(config.triggers) : undefined,
+        timeout: config.timeout,
+        fallbackStep: config.fallback_step,
+        steps,
+    };
+}
+function mapStep(config) {
+    return {
+        action: config.action,
+        branches: (config.branches || []).map(mapBranch),
+    };
+}
+function mapTriggers(triggers) {
+    if (typeof triggers === 'string') {
+        return [{ phrases: splitPhrases(triggers) }];
+    }
+    if (triggers.length === 0) {
+        return [];
+    }
+    if (typeof triggers[0] === 'string') {
+        return triggers.map(text => ({ phrases: splitPhrases(text) }));
+    }
+    return triggers.map(item => ({
+        phrases: typeof item.phrases === 'string'
+            ? splitPhrases(item.phrases)
+            : item.phrases.flatMap(splitPhrases),
+        fuzzyThreshold: item.fuzzy_threshold,
+    }));
+}
+function mapBranch(config) {
+    return {
+        when: config.when ? mapWhen(config.when) : undefined,
+        fuzzyThreshold: config.fuzzy_threshold,
+        goto: config.goto,
+    };
+}
+function mapWhen(when) {
+    if (typeof when === 'string') {
+        return splitPhrases(when);
+    }
+    return when.flatMap(splitPhrases);
+}
+function splitPhrases(value) {
+    return value
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+}

package/dist/flow/state.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowStateService = void 0;
+const node_sqlite_1 = require("node:sqlite");
+class FlowStateService {
+    constructor(dbPath) {
+        this.db = new node_sqlite_1.DatabaseSync(dbPath);
+        this.setupSchema();
+    }
+    setupSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS flow_states (
+        id TEXT PRIMARY KEY,
+        sender TEXT NOT NULL,
+        bot_id TEXT NOT NULL,
+        flow_id TEXT NOT NULL,
+        step_id TEXT NOT NULL,
+        variables TEXT NOT NULL DEFAULT '{}',
+        started_at INTEGER NOT NULL,
+        last_activity_at INTEGER NOT NULL,
+        timeout INTEGER NOT NULL
+      );
+
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_flow_states_sender_bot ON flow_states(sender, bot_id);
+      CREATE INDEX IF NOT EXISTS idx_flow_states_last_activity ON flow_states(last_activity_at);
+    `);
+    }
+    findActive(sender, botId, now = Date.now()) {
+        const row = this.db
+            .prepare('SELECT * FROM flow_states WHERE sender = ? AND bot_id = ?')
+            .get(sender, botId);
+        if (!row) {
+            return null;
+        }
+        const state = this.rowToState(row);
+        if (this.isExpired(state, now)) {
+            this.destroy(state.id);
+            return null;
+        }
+        return state;
+    }
+    create(sender, botId, flowId, stepId, timeout, now = Date.now(), initialVariables) {
+        this.destroyBySenderBot(sender, botId);
+        const id = `${botId}-${sender}-${now}`;
+        const state = {
+            id,
+            sender,
+            botId,
+            flowId,
+            stepId,
+            variables: { ...initialVariables },
+            startedAt: now,
+            lastActivityAt: now,
+            timeout,
+        };
+        this.db
+            .prepare('INSERT INTO flow_states (id, sender, bot_id, flow_id, step_id, variables, started_at, last_activity_at, timeout) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(state.id, state.sender, state.botId, state.flowId, state.stepId, JSON.stringify(state.variables), state.startedAt, state.lastActivityAt, state.timeout);
+        return state;
+    }
+    updateStep(id, stepId, variables, now = Date.now()) {
+        const state = this.findById(id);
+        if (!state) {
+            return;
+        }
+        const mergedVariables = variables ? { ...state.variables, ...variables } : state.variables;
+        this.db
+            .prepare('UPDATE flow_states SET step_id = ?, variables = ?, last_activity_at = ? WHERE id = ?')
+            .run(stepId, JSON.stringify(mergedVariables), now, id);
+    }
+    destroy(id) {
+        this.db.prepare('DELETE FROM flow_states WHERE id = ?').run(id);
+    }
+    destroyBySenderBot(sender, botId) {
+        this.db.prepare('DELETE FROM flow_states WHERE sender = ? AND bot_id = ?').run(sender, botId);
+    }
+    cleanupExpired(now = Date.now()) {
+        const cutoff = now;
+        const result = this.db
+            .prepare('DELETE FROM flow_states WHERE (last_activity_at + (timeout * 1000)) < ?')
+            .run(cutoff);
+        return Number(result.changes);
+    }
+    count() {
+        const row = this.db.prepare('SELECT COUNT(*) as count FROM flow_states').get();
+        return row.count;
+    }
+    close() {
+        this.db.close();
+    }
+    findById(id) {
+        const row = this.db.prepare('SELECT * FROM flow_states WHERE id = ?').get(id);
+        return row ? this.rowToState(row) : null;
+    }
+    rowToState(row) {
+        return {
+            id: row.id,
+            sender: row.sender,
+            botId: row.bot_id,
+            flowId: row.flow_id,
+            stepId: row.step_id,
+            variables: JSON.parse(row.variables || '{}'),
+            startedAt: row.started_at,
+            lastActivityAt: row.last_activity_at,
+            timeout: row.timeout,
+        };
+    }
+    isExpired(state, now) {
+        if (state.timeout <= 0) {
+            return false;
+        }
+        return now > state.lastActivityAt + state.timeout * 1000;
+    }
+}
+exports.FlowStateService = FlowStateService;

package/dist/flow/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });