@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/apps/server/src/channels/middleware/dispatch/prompt/context.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildChannelContextPrompt = void 0;
+const buildChannelContextPrompt = (inbound, config) => {
+    const lines = [];
+    // Channel platform context
+    const channelLabel = inbound.channelType === 'lark' ? '飞书（Lark）' : inbound.channelType;
+    lines.push(`你正在通过 ${channelLabel} 频道进行对话。`);
+    // Bot's display name on this channel
+    const botName = config?.title;
+    if (botName) {
+        lines.push(`你在此频道上的名字是「${botName}」。`);
+    }
+    // Admin identities
+    const admins = config?.access?.admins;
+    if (admins && admins.length > 0) {
+        lines.push(`以下用户 ID 是本频道的管理员：${admins.join('、')}。`);
+    }
+    return lines.join('\n');
+};
+exports.buildChannelContextPrompt = buildChannelContextPrompt;

package/dist/apps/server/src/channels/middleware/dispatch/prompt/index.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelBaseConfig, ChannelConnection, ChannelInboundEvent } from '@vibe-forge/core/channel';
+import type { ChannelTextMessage } from '#~/channels/middleware/@types/index.js';
+export declare const buildSessionSystemPrompt: (inbound: ChannelInboundEvent, config: ChannelBaseConfig | undefined, connection: ChannelConnection<ChannelTextMessage> | undefined) => Promise<string | undefined>;

package/dist/apps/server/src/channels/middleware/dispatch/prompt/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSessionSystemPrompt = void 0;
+const agent_rules_1 = require("./agent-rules");
+const context_1 = require("./context");
+const buildSessionSystemPrompt = async (inbound, config, connection) => {
+    const [channelRulesPrompt, connectionSystemPrompt] = await Promise.all([
+        (0, agent_rules_1.loadChannelAgentRules)(inbound.channelType),
+        connection?.generateSystemPrompt?.(inbound)
+    ]);
+    return [
+        config?.systemPrompt,
+        (0, context_1.buildChannelContextPrompt)(inbound, config),
+        channelRulesPrompt,
+        connectionSystemPrompt
+    ]
+        .filter(Boolean)
+        .join('\n\n') || undefined;
+};
+exports.buildSessionSystemPrompt = buildSessionSystemPrompt;

package/dist/apps/server/src/channels/middleware/i18n.d.ts

@@ -0,0 +1,14 @@
+import type { ChannelMiddleware } from './@types';
+export type LanguageCode = 'zh' | 'en';
+export type MessageArgs = Record<string, string | number | boolean | undefined>;
+type MessageTemplate = string | ((args: MessageArgs) => string);
+export type MessageCatalog = Record<string, MessageTemplate>;
+/**
+ * Register i18n messages for a given language.
+ * Can be called multiple times — later calls merge into existing entries.
+ */
+export declare const defineMessages: (lang: LanguageCode, messages: MessageCatalog) => void;
+export declare const t: (lang: LanguageCode | undefined, key: string, args?: MessageArgs) => string;
+export declare const createT: (lang: LanguageCode | undefined) => (key: string, args?: MessageArgs) => string;
+export declare const i18nMiddleware: ChannelMiddleware;
+export {};

package/dist/apps/server/src/channels/middleware/i18n.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18nMiddleware = exports.createT = exports.t = exports.defineMessages = void 0;
+const catalogs = {};
+/**
+ * Register i18n messages for a given language.
+ * Can be called multiple times — later calls merge into existing entries.
+ */
+const defineMessages = (lang, messages) => {
+    catalogs[lang] = { ...catalogs[lang], ...messages };
+};
+exports.defineMessages = defineMessages;
+const DEFAULT_LANGUAGE = 'zh';
+const t = (lang, key, args) => {
+    const locale = lang ?? DEFAULT_LANGUAGE;
+    const template = catalogs[locale]?.[key] ?? catalogs[DEFAULT_LANGUAGE]?.[key];
+    if (template == null)
+        return key;
+    if (typeof template === 'function')
+        return template(args ?? {});
+    if (args) {
+        return template.replace(/\{(\w+)\}/g, (_, k) => String(args[k] ?? ''));
+    }
+    return template;
+};
+exports.t = t;
+const createT = (lang) => (key, args) => (0, exports.t)(lang, key, args);
+exports.createT = createT;
+const i18nMiddleware = async (ctx, next) => {
+    ctx.defineMessages = exports.defineMessages;
+    ctx.t = (key, args) => {
+        const language = ctx.config?.language;
+        return (0, exports.t)(language, key, args);
+    };
+    await next();
+};
+exports.i18nMiddleware = i18nMiddleware;

package/dist/apps/server/src/channels/middleware/index.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelContext } from './@types';
+export declare const pipeline: (ctx: ChannelContext) => Promise<void>;

package/dist/apps/server/src/channels/middleware/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipeline = void 0;
+const compose_js_1 = require("#~/utils/compose.js");
+const access_control_1 = require("./access-control");
+const ack_1 = require("./ack");
+const admin_gate_1 = require("./admin-gate");
+const bind_session_1 = require("./bind-session");
+const commands_1 = require("./commands");
+const deduplicate_1 = require("./deduplicate");
+const dispatch_1 = require("./dispatch");
+const i18n_1 = require("./i18n");
+const parse_content_1 = require("./parse-content");
+const resolve_session_1 = require("./resolve-session");
+exports.pipeline = (0, compose_js_1.compose)(deduplicate_1.deduplicateMiddleware, i18n_1.i18nMiddleware, parse_content_1.parseContentMiddleware, access_control_1.accessControlMiddleware, resolve_session_1.resolveSessionMiddleware, commands_1.channelCommandMiddleware, ack_1.ackMiddleware, admin_gate_1.adminGateMiddleware, dispatch_1.dispatchMiddleware, bind_session_1.bindSessionMiddleware);

package/dist/apps/server/src/channels/middleware/parse-content.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelMiddleware } from './@types';
+export declare const parseContentMiddleware: ChannelMiddleware;

package/dist/apps/server/src/channels/middleware/parse-content.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseContentMiddleware = void 0;
+const _utils_1 = require("./@utils");
+const parseContentMiddleware = async (ctx, next) => {
+    ctx.contentItems = (0, _utils_1.getInboundContentItems)(ctx.inbound);
+    const hasContent = ctx.contentItems != null && ctx.contentItems.length > 0;
+    if ((ctx.inbound.text == null || ctx.inbound.text === '') && !hasContent)
+        return;
+    ctx.commandText = (0, _utils_1.stripLeadingAtTags)((0, _utils_1.stripSpeakerPrefix)(ctx.inbound.text ?? '')).trim();
+    await next();
+};
+exports.parseContentMiddleware = parseContentMiddleware;

package/dist/apps/server/src/channels/middleware/resolve-session.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelMiddleware } from './@types';
+export declare const resolveSessionMiddleware: ChannelMiddleware;

package/dist/apps/server/src/channels/middleware/resolve-session.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSessionMiddleware = void 0;
+const index_js_1 = require("#~/db/index.js");
+const resolveSessionMiddleware = async (ctx, next) => {
+    const db = (0, index_js_1.getDb)();
+    const result = db.getChannelSession(ctx.inbound.channelType, ctx.inbound.sessionType, ctx.inbound.channelId);
+    const preference = db.getChannelPreference(ctx.inbound.channelType, ctx.inbound.sessionType, ctx.inbound.channelId);
+    ctx.sessionId = result?.sessionId;
+    ctx.channelAdapter = preference?.adapter;
+    ctx.channelPermissionMode = preference?.permissionMode;
+    await next();
+};
+exports.resolveSessionMiddleware = resolveSessionMiddleware;

package/dist/apps/server/src/channels/state.d.ts

@@ -0,0 +1,7 @@
+import type { ChannelSessionBinding } from './types';
+export declare const resolveBinding: (sessionId: string) => ChannelSessionBinding | undefined;
+export declare const setBinding: (sessionId: string, binding: ChannelSessionBinding) => void;
+export declare const deleteBinding: (sessionId: string) => void;
+export declare const setPendingUnack: (sessionId: string, unack?: () => Promise<void>) => void;
+export declare const consumePendingUnack: (sessionId: string) => (() => Promise<void>) | undefined;
+export declare const isDuplicateMessage: (key: string) => boolean;

package/dist/apps/server/src/channels/state.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDuplicateMessage = exports.consumePendingUnack = exports.setPendingUnack = exports.deleteBinding = exports.setBinding = exports.resolveBinding = void 0;
+const index_js_1 = require("#~/db/index.js");
+const sessionBindings = new Map();
+const pendingSessionUnack = new Map();
+const seenMessageIds = new Map();
+const maxSeenMessageIds = 5000;
+const resolveBinding = (sessionId) => {
+    const cached = sessionBindings.get(sessionId);
+    if (cached)
+        return cached;
+    const row = (0, index_js_1.getDb)().getChannelSessionBySessionId(sessionId);
+    if (!row)
+        return;
+    const binding = {
+        channelType: row.channelType,
+        channelKey: row.channelKey,
+        channelId: row.channelId,
+        sessionType: row.sessionType,
+        replyReceiveId: row.replyReceiveId,
+        replyReceiveIdType: row.replyReceiveIdType
+    };
+    sessionBindings.set(sessionId, binding);
+    return binding;
+};
+exports.resolveBinding = resolveBinding;
+const setBinding = (sessionId, binding) => {
+    sessionBindings.set(sessionId, binding);
+};
+exports.setBinding = setBinding;
+const deleteBinding = (sessionId) => {
+    sessionBindings.delete(sessionId);
+};
+exports.deleteBinding = deleteBinding;
+const setPendingUnack = (sessionId, unack) => {
+    pendingSessionUnack.set(sessionId, unack);
+};
+exports.setPendingUnack = setPendingUnack;
+const consumePendingUnack = (sessionId) => {
+    const unack = pendingSessionUnack.get(sessionId);
+    if (unack) {
+        pendingSessionUnack.delete(sessionId);
+    }
+    return unack;
+};
+exports.consumePendingUnack = consumePendingUnack;
+const isDuplicateMessage = (key) => {
+    if (seenMessageIds.has(key))
+        return true;
+    seenMessageIds.set(key, Date.now());
+    if (seenMessageIds.size > maxSeenMessageIds) {
+        seenMessageIds.clear();
+    }
+    return false;
+};
+exports.isDuplicateMessage = isDuplicateMessage;

package/dist/apps/server/src/channels/types.d.ts

@@ -0,0 +1,25 @@
+import type { ConfigSource, WSEvent } from '@vibe-forge/core';
+import type { ChannelBaseConfig, ChannelConnection } from '@vibe-forge/core/channel';
+import type { ChannelTextMessage } from './middleware/@types';
+export interface ChannelRuntimeState {
+    key: string;
+    type: string;
+    status: 'connected' | 'disabled' | 'error';
+    connection?: ChannelConnection<ChannelTextMessage>;
+    config?: ChannelBaseConfig;
+    configSource?: ConfigSource;
+    error?: string;
+}
+export interface ChannelSessionBinding {
+    channelType: string;
+    channelKey: string;
+    channelId: string;
+    sessionType: string;
+    replyReceiveId?: string;
+    replyReceiveIdType?: string;
+}
+export interface ChannelManager {
+    states: Map<string, ChannelRuntimeState>;
+    handleSessionEvent: (sessionId: string, event: WSEvent) => Promise<void>;
+    closeAll: () => Promise<void>;
+}

package/dist/apps/server/src/channels/types.js

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

package/dist/apps/server/src/db/automation/repo.d.ts

@@ -0,0 +1,70 @@
+import type { SqliteDatabase } from '../sqlite';
+export interface AutomationRule {
+    id: string;
+    name: string;
+    description?: string | null;
+    type: 'interval' | 'webhook' | 'cron';
+    intervalMs?: number | null;
+    webhookKey?: string | null;
+    cronExpression?: string | null;
+    prompt: string;
+    enabled: boolean;
+    createdAt: number;
+    lastRunAt?: number | null;
+    lastSessionId?: string | null;
+}
+export interface AutomationRuleDetail extends AutomationRule {
+    triggers: AutomationTrigger[];
+    tasks: AutomationTask[];
+}
+export interface AutomationTrigger {
+    id: string;
+    ruleId: string;
+    type: 'interval' | 'webhook' | 'cron';
+    intervalMs?: number | null;
+    cronExpression?: string | null;
+    webhookKey?: string | null;
+    createdAt: number;
+}
+export interface AutomationTask {
+    id: string;
+    ruleId: string;
+    title: string;
+    prompt: string;
+    createdAt: number;
+}
+export interface AutomationRun {
+    id: string;
+    ruleId: string;
+    sessionId: string;
+    runAt: number;
+    taskId?: string | null;
+    taskTitle?: string | null;
+    status?: string;
+    title?: string;
+    lastMessage?: string;
+    lastUserMessage?: string;
+}
+type AutomationRuleUpdate = Partial<Omit<AutomationRule, 'id' | 'createdAt'>>;
+export declare function createAutomationRepo(db: SqliteDatabase): {
+    createRule: (rule: AutomationRule) => void;
+    createRun: (ruleId: string, sessionId: string, taskId?: string | null, taskTitle?: string | null) => void;
+    getRule: (id: string) => AutomationRule | undefined;
+    getRuleDetail: (id: string) => AutomationRuleDetail | undefined;
+    getTrigger: (id: string) => AutomationTrigger | undefined;
+    listRuleDetails: () => AutomationRuleDetail[];
+    listRules: () => AutomationRule[];
+    listRuns: (ruleId: string, limit?: number) => AutomationRun[];
+    listTasks: (ruleId: string) => AutomationTask[];
+    listTriggers: (ruleId: string) => AutomationTrigger[];
+    removeRule: (id: string) => boolean;
+    replaceTasks: (ruleId: string, tasks: Array<Omit<AutomationTask, "id" | "ruleId" | "createdAt"> & {
+        id?: string;
+    }>) => void;
+    replaceTriggers: (ruleId: string, triggers: Array<Omit<AutomationTrigger, "id" | "ruleId" | "createdAt"> & {
+        id?: string;
+    }>) => void;
+    updateRule: (id: string, updates: AutomationRuleUpdate) => void;
+};
+export type AutomationRepo = ReturnType<typeof createAutomationRepo>;
+export {};

package/dist/apps/server/src/db/automation/repo.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAutomationRepo = createAutomationRepo;
+const uuid_1 = require("uuid");
+const repo_utils_1 = require("../repo.utils");
+const automationRuleUpdateFields = [
+    { key: 'name' },
+    { key: 'description', toParam: value => value ?? null },
+    { key: 'type' },
+    { key: 'intervalMs', toParam: value => value ?? null },
+    { key: 'webhookKey', toParam: value => value ?? null },
+    { key: 'cronExpression', toParam: value => value ?? null },
+    { key: 'prompt' },
+    { key: 'enabled', toParam: value => value ? 1 : 0 },
+    { key: 'lastRunAt', toParam: value => value ?? null },
+    { key: 'lastSessionId', toParam: value => value ?? null }
+];
+function mapAutomationType(value) {
+    return value === 'webhook' ? 'webhook' : value === 'cron' ? 'cron' : 'interval';
+}
+function mapAutomationRuleRow(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        description: row.description ?? null,
+        type: mapAutomationType(row.type),
+        intervalMs: row.intervalMs ?? null,
+        webhookKey: row.webhookKey ?? null,
+        cronExpression: row.cronExpression ?? null,
+        prompt: row.prompt,
+        enabled: row.enabled === 1,
+        createdAt: row.createdAt,
+        lastRunAt: row.lastRunAt ?? null,
+        lastSessionId: row.lastSessionId ?? null
+    };
+}
+function mapAutomationTriggerRow(row) {
+    return {
+        id: row.id,
+        ruleId: row.ruleId,
+        type: mapAutomationType(row.type),
+        intervalMs: row.intervalMs ?? null,
+        cronExpression: row.cronExpression ?? null,
+        webhookKey: row.webhookKey ?? null,
+        createdAt: row.createdAt
+    };
+}
+function mapAutomationTaskRow(row) {
+    return {
+        id: row.id,
+        ruleId: row.ruleId,
+        title: row.title,
+        prompt: row.prompt,
+        createdAt: row.createdAt
+    };
+}
+function createAutomationRepo(db) {
+    const listRules = () => {
+        const stmt = db.prepare('SELECT * FROM automation_rules ORDER BY createdAt DESC');
+        const rows = stmt.all();
+        return rows.map(mapAutomationRuleRow);
+    };
+    const listRuleDetails = () => {
+        const rules = listRules();
+        const triggerRows = db.prepare('SELECT * FROM automation_triggers').all();
+        const taskRows = db.prepare('SELECT * FROM automation_tasks').all();
+        const triggerMap = new Map();
+        const taskMap = new Map();
+        for (const row of triggerRows) {
+            const list = triggerMap.get(row.ruleId) ?? [];
+            list.push(mapAutomationTriggerRow(row));
+            triggerMap.set(row.ruleId, list);
+        }
+        for (const row of taskRows) {
+            const list = taskMap.get(row.ruleId) ?? [];
+            list.push(mapAutomationTaskRow(row));
+            taskMap.set(row.ruleId, list);
+        }
+        return rules.map(rule => ({
+            ...rule,
+            triggers: triggerMap.get(rule.id) ?? [],
+            tasks: taskMap.get(rule.id) ?? []
+        }));
+    };
+    const getRule = (id) => {
+        const stmt = db.prepare('SELECT * FROM automation_rules WHERE id = ?');
+        const row = stmt.get(id);
+        if (row == null)
+            return undefined;
+        return mapAutomationRuleRow(row);
+    };
+    const listTriggers = (ruleId) => {
+        const stmt = db.prepare('SELECT * FROM automation_triggers WHERE ruleId = ? ORDER BY createdAt ASC');
+        const rows = stmt.all(ruleId);
+        return rows.map(mapAutomationTriggerRow);
+    };
+    const listTasks = (ruleId) => {
+        const stmt = db.prepare('SELECT * FROM automation_tasks WHERE ruleId = ? ORDER BY createdAt ASC');
+        const rows = stmt.all(ruleId);
+        return rows.map(mapAutomationTaskRow);
+    };
+    const getRuleDetail = (id) => {
+        const rule = getRule(id);
+        if (!rule)
+            return undefined;
+        return {
+            ...rule,
+            triggers: listTriggers(id),
+            tasks: listTasks(id)
+        };
+    };
+    const createRule = (rule) => {
+        const stmt = db.prepare(`
+      INSERT INTO automation_rules (id, name, description, type, intervalMs, webhookKey, cronExpression, prompt, enabled, createdAt, lastRunAt, lastSessionId)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(rule.id, rule.name, rule.description ?? null, rule.type, rule.intervalMs ?? null, rule.webhookKey ?? null, rule.cronExpression ?? null, rule.prompt, rule.enabled ? 1 : 0, rule.createdAt, rule.lastRunAt ?? null, rule.lastSessionId ?? null);
+    };
+    const updateRule = (id, updates) => {
+        const statement = (0, repo_utils_1.buildUpdateStatement)('automation_rules', 'id', id, updates, automationRuleUpdateFields);
+        if (!statement)
+            return;
+        const stmt = db.prepare(statement.sql);
+        stmt.run(...statement.params);
+    };
+    const removeRule = (id) => {
+        const stmt = db.prepare('DELETE FROM automation_rules WHERE id = ?');
+        const result = stmt.run(id);
+        return result.changes > 0;
+    };
+    const getTrigger = (id) => {
+        const stmt = db.prepare('SELECT * FROM automation_triggers WHERE id = ?');
+        const row = stmt.get(id);
+        if (!row)
+            return undefined;
+        return mapAutomationTriggerRow(row);
+    };
+    const replaceTriggers = (ruleId, triggers) => {
+        const transaction = db.transaction(() => {
+            db.prepare('DELETE FROM automation_triggers WHERE ruleId = ?').run(ruleId);
+            const stmt = db.prepare(`
+        INSERT INTO automation_triggers (id, ruleId, type, intervalMs, cronExpression, webhookKey, createdAt)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `);
+            for (const trigger of triggers) {
+                stmt.run(trigger.id ?? (0, uuid_1.v4)(), ruleId, trigger.type, trigger.intervalMs ?? null, trigger.cronExpression ?? null, trigger.webhookKey ?? null, Date.now());
+            }
+        });
+        transaction();
+    };
+    const replaceTasks = (ruleId, tasks) => {
+        const transaction = db.transaction(() => {
+            db.prepare('DELETE FROM automation_tasks WHERE ruleId = ?').run(ruleId);
+            const stmt = db.prepare(`
+        INSERT INTO automation_tasks (id, ruleId, title, prompt, createdAt)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+            for (const task of tasks) {
+                stmt.run(task.id ?? (0, uuid_1.v4)(), ruleId, task.title, task.prompt, Date.now());
+            }
+        });
+        transaction();
+    };
+    const createRun = (ruleId, sessionId, taskId, taskTitle) => {
+        const stmt = db.prepare(`
+      INSERT INTO automation_runs (id, ruleId, sessionId, taskId, taskTitle, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run((0, uuid_1.v4)(), ruleId, sessionId, taskId ?? null, taskTitle ?? null, Date.now());
+    };
+    const listRuns = (ruleId, limit = 50) => {
+        const stmt = db.prepare(`
+      SELECT r.id,
+             r.ruleId,
+             r.sessionId,
+             r.taskId,
+             r.taskTitle,
+             r.createdAt,
+             s.status,
+             s.title,
+             s.lastMessage,
+             s.lastUserMessage
+      FROM automation_runs r
+      LEFT JOIN sessions s ON s.id = r.sessionId
+      WHERE r.ruleId = ?
+      ORDER BY r.createdAt DESC
+      LIMIT ?
+    `);
+        const rows = stmt.all(ruleId, limit);
+        return rows.map(row => ({
+            id: row.id,
+            ruleId: row.ruleId,
+            sessionId: row.sessionId,
+            runAt: row.createdAt,
+            taskId: row.taskId ?? null,
+            taskTitle: row.taskTitle ?? null,
+            status: row.status ?? undefined,
+            title: row.title ?? undefined,
+            lastMessage: row.lastMessage ?? undefined,
+            lastUserMessage: row.lastUserMessage ?? undefined
+        }));
+    };
+    return {
+        createRule,
+        createRun,
+        getRule,
+        getRuleDetail,
+        getTrigger,
+        listRuleDetails,
+        listRules,
+        listRuns,
+        listTasks,
+        listTriggers,
+        removeRule,
+        replaceTasks,
+        replaceTriggers,
+        updateRule
+    };
+}

package/dist/apps/server/src/db/automation/schema.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaModule } from '../schema';
+export declare const automationSchemaModule: SchemaModule;

package/dist/apps/server/src/db/automation/schema.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.automationSchemaModule = void 0;
+exports.automationSchemaModule = {
+    name: 'automation',
+    apply({ exec, ensureColumn, getColumns }) {
+        exec(`
+      CREATE TABLE IF NOT EXISTS automation_rules (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        type TEXT NOT NULL,
+        intervalMs INTEGER,
+        webhookKey TEXT,
+        cronExpression TEXT,
+        prompt TEXT NOT NULL,
+        enabled INTEGER DEFAULT 1,
+        createdAt INTEGER NOT NULL,
+        lastRunAt INTEGER,
+        lastSessionId TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS automation_triggers (
+        id TEXT PRIMARY KEY,
+        ruleId TEXT NOT NULL,
+        type TEXT NOT NULL,
+        intervalMs INTEGER,
+        cronExpression TEXT,
+        webhookKey TEXT,
+        createdAt INTEGER NOT NULL,
+        FOREIGN KEY(ruleId) REFERENCES automation_rules(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS automation_tasks (
+        id TEXT PRIMARY KEY,
+        ruleId TEXT NOT NULL,
+        title TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        createdAt INTEGER NOT NULL,
+        FOREIGN KEY(ruleId) REFERENCES automation_rules(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS automation_runs (
+        id TEXT PRIMARY KEY,
+        ruleId TEXT NOT NULL,
+        sessionId TEXT NOT NULL,
+        taskId TEXT,
+        taskTitle TEXT,
+        createdAt INTEGER NOT NULL,
+        FOREIGN KEY(ruleId) REFERENCES automation_rules(id) ON DELETE CASCADE,
+        FOREIGN KEY(sessionId) REFERENCES sessions(id) ON DELETE CASCADE
+      );
+    `);
+        if (getColumns('automation_rules').length > 0) {
+            ensureColumn('automation_rules', 'description', 'TEXT');
+            ensureColumn('automation_rules', 'intervalMs', 'INTEGER');
+            ensureColumn('automation_rules', 'webhookKey', 'TEXT');
+            ensureColumn('automation_rules', 'cronExpression', 'TEXT');
+            ensureColumn('automation_rules', 'enabled', 'INTEGER DEFAULT 1');
+            ensureColumn('automation_rules', 'createdAt', 'INTEGER NOT NULL DEFAULT 0');
+            ensureColumn('automation_rules', 'lastRunAt', 'INTEGER');
+            ensureColumn('automation_rules', 'lastSessionId', 'TEXT');
+        }
+        if (getColumns('automation_triggers').length > 0) {
+            ensureColumn('automation_triggers', 'intervalMs', 'INTEGER');
+            ensureColumn('automation_triggers', 'cronExpression', 'TEXT');
+            ensureColumn('automation_triggers', 'webhookKey', 'TEXT');
+            ensureColumn('automation_triggers', 'createdAt', 'INTEGER NOT NULL DEFAULT 0');
+        }
+        if (getColumns('automation_tasks').length > 0) {
+            ensureColumn('automation_tasks', 'title', 'TEXT NOT NULL DEFAULT ""');
+            ensureColumn('automation_tasks', 'prompt', 'TEXT NOT NULL DEFAULT ""');
+            ensureColumn('automation_tasks', 'createdAt', 'INTEGER NOT NULL DEFAULT 0');
+        }
+        if (getColumns('automation_runs').length > 0) {
+            ensureColumn('automation_runs', 'taskId', 'TEXT');
+            ensureColumn('automation_runs', 'taskTitle', 'TEXT');
+        }
+    }
+};

package/dist/apps/server/src/db/channelSessions/repo.d.ts

@@ -0,0 +1,31 @@
+import type { SessionPermissionMode } from '@vibe-forge/core';
+import type { SqliteDatabase } from '../sqlite';
+export interface ChannelSessionRow {
+    channelType: string;
+    sessionType: string;
+    channelId: string;
+    channelKey: string;
+    replyReceiveId?: string;
+    replyReceiveIdType?: string;
+    sessionId: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface ChannelPreferenceRow {
+    channelType: string;
+    sessionType: string;
+    channelId: string;
+    channelKey: string;
+    adapter?: string;
+    permissionMode?: SessionPermissionMode;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare function createChannelSessionsRepo(db: SqliteDatabase): {
+    get: (channelType: string, sessionType: string, channelId: string) => ChannelSessionRow | undefined;
+    getPreference: (channelType: string, sessionType: string, channelId: string) => ChannelPreferenceRow | undefined;
+    getBySessionId: (sessionId: string) => ChannelSessionRow | undefined;
+    removeBySessionId: (sessionId: string) => number;
+    upsert: (row: Omit<ChannelSessionRow, "createdAt" | "updatedAt">) => void;
+    upsertPreference: (row: Omit<ChannelPreferenceRow, "createdAt" | "updatedAt">) => void;
+};