flex-mcp 1.0.0

package/dist/script/context.js

@@ -0,0 +1,786 @@
+/**
+ * 脚本执行上下文
+ * 提供脚本执行时可用的 API
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import crypto from 'crypto';
+import axios from 'axios';
+import { rgPath } from '@lvce-editor/ripgrep';
+import { db, sqlite } from '../db/index.js';
+import { tableDefinitions, tableData } from '../db/schema.js';
+import { eq, and } from 'drizzle-orm';
+import { getUserById } from '../auth/index.js';
+import { resolveUserPath, getFileSystemDir } from '../config.js';
+import { generateId } from '../utils/id.js';
+const execAsync = promisify(exec);
+export async function createScriptContext(config, mcpClientConfig, aggregator) {
+    // 获取用户信息
+    const user = await getUserById(config.userId);
+    if (!user) {
+        throw new Error(`User ${config.userId} not found`);
+    }
+    // 确保用户隔离目录存在
+    const userDir = path.join(getFileSystemDir(), user.id);
+    try {
+        await fs.access(userDir);
+    }
+    catch {
+        await fs.mkdir(userDir, { recursive: true });
+    }
+    return {
+        // 当前用户信息（包含邮箱）
+        user: {
+            id: user.id,
+            email: user.email,
+            role: user.role,
+            createdAt: user.createdAt,
+            updatedAt: user.updatedAt,
+        },
+        // MCP 客户端配置（来自 Cursor mcp.json）
+        mcpClient: {
+            headers: mcpClientConfig?.headers || {},
+            config: mcpClientConfig?.config || {},
+        },
+        // HTTP 请求
+        http: {
+            async get(url, options) {
+                const response = await axios.get(url, options);
+                return response.data;
+            },
+            async post(url, data, options) {
+                const response = await axios.post(url, data, options);
+                return response.data;
+            },
+            async put(url, data, options) {
+                const response = await axios.put(url, data, options);
+                return response.data;
+            },
+            async delete(url, options) {
+                const response = await axios.delete(url, options);
+                return response.data;
+            },
+        },
+        // 文件操作（用户隔离）
+        fs: {
+            async readFile(filePath) {
+                const resolvedPath = resolveUserPath(filePath, user.id);
+                return await fs.readFile(resolvedPath, 'utf-8');
+            },
+            async writeFile(filePath, content) {
+                const resolvedPath = resolveUserPath(filePath, user.id);
+                // 确保父目录存在
+                const dir = path.dirname(resolvedPath);
+                await fs.mkdir(dir, { recursive: true });
+                await fs.writeFile(resolvedPath, content, 'utf-8');
+            },
+            async exists(filePath) {
+                try {
+                    const resolvedPath = resolveUserPath(filePath, user.id);
+                    await fs.access(resolvedPath);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+            async listDir(dirPath) {
+                const resolvedPath = resolveUserPath(dirPath, user.id);
+                return await fs.readdir(resolvedPath);
+            },
+            async mkdir(dirPath) {
+                const resolvedPath = resolveUserPath(dirPath, user.id);
+                await fs.mkdir(resolvedPath, { recursive: true });
+            },
+        },
+        // 命令执行（在用户隔离目录中执行）
+        cmd: {
+            async exec(command, options) {
+                const userDir = path.join(getFileSystemDir(), user.id);
+                const cwd = options?.cwd
+                    ? path.resolve(userDir, options.cwd.startsWith('/') ? options.cwd.substring(1) : options.cwd)
+                    : userDir;
+                // 确保工作目录在用户目录内
+                if (!cwd.startsWith(path.resolve(userDir))) {
+                    throw new Error(`Working directory must be within user directory`);
+                }
+                const timeout = options?.timeout || 30000; // 默认 30 秒超时
+                try {
+                    const { stdout, stderr } = await Promise.race([
+                        execAsync(command, {
+                            cwd,
+                            maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                        }),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error(`Command timeout after ${timeout}ms`)), timeout))
+                    ]);
+                    return {
+                        stdout: stdout || '',
+                        stderr: stderr || '',
+                        exitCode: 0,
+                    };
+                }
+                catch (error) {
+                    // execAsync 在命令失败时会抛出错误，但包含 stdout 和 stderr
+                    if (error.stdout !== undefined || error.stderr !== undefined) {
+                        return {
+                            stdout: error.stdout || '',
+                            stderr: error.stderr || '',
+                            exitCode: error.code || 1,
+                        };
+                    }
+                    throw error;
+                }
+            },
+        },
+        // 工具函数
+        utils: {
+            md5(input) {
+                return crypto.createHash('md5').update(input).digest('hex');
+            },
+        },
+        // ripgrep 搜索
+        ripgrep: {
+            /**
+             * 使用 ripgrep 搜索文件内容
+             * @param pattern 搜索模式（支持正则表达式）
+             * @param options 搜索选项
+             * @param options.cwd 工作目录（相对于用户隔离目录，默认：用户根目录）
+             * @param options.caseSensitive 是否大小写敏感（默认：false）
+             * @param options.multiline 是否启用多行匹配（默认：false）
+             * @param options.files 文件过滤模式（glob 模式数组，默认：[]，匹配所有文件）
+             * @param options.excludeFiles 排除文件模式（glob 模式数组，默认：[]）
+             * @param options.maxCount 每个文件的最大匹配数（默认：无限制）
+             * @param options.maxResults 总结果数的最大限制（默认：无限制）
+             * @param options.maxDepth 最大递归深度（默认：无限制）
+             * @param options.contextBefore 匹配行之前显示的行数（默认：0）
+             * @param options.contextAfter 匹配行之后显示的行数（默认：0）
+             * @param options.context 匹配行前后显示的行数（等同于同时设置 contextBefore 和 contextAfter，默认：0）
+             * @param options.fixedStrings 将模式视为固定字符串而非正则表达式（默认：false）
+             * @param options.wordRegexp 只匹配完整的单词（默认：false）
+             * @param options.fileTypes 文件类型过滤（如：['js', 'ts']，默认：[]，匹配所有类型）
+             * @param options.excludeTypes 排除的文件类型（默认：[]）
+             * @param options.filesWithMatches 只返回包含匹配的文件名（默认：false）
+             * @param options.count 只返回每个文件的匹配数量（默认：false）
+             * @param options.noIgnore 忽略 .gitignore 和 .ignore 文件（默认：false）
+             * @param options.smartCase 智能大小写：如果模式包含大写字母则大小写敏感（默认：false）
+             * @returns 匹配结果数组
+             */
+            async search(pattern, options) {
+                const userDir = path.join(getFileSystemDir(), user.id);
+                const cwd = options?.cwd
+                    ? path.resolve(userDir, options.cwd.startsWith('/') ? options.cwd.substring(1) : options.cwd)
+                    : userDir;
+                // 确保工作目录在用户目录内
+                if (!cwd.startsWith(path.resolve(userDir))) {
+                    throw new Error(`Working directory must be within user directory`);
+                }
+                const args = [
+                    '--json',
+                    '--no-heading',
+                ];
+                // 大小写选项（优先级：smartCase > caseSensitive > 默认忽略大小写）
+                if (options?.smartCase) {
+                    args.push('--smart-case');
+                }
+                else if (options?.caseSensitive === true) {
+                    // 明确指定大小写敏感时不添加 --ignore-case
+                }
+                else {
+                    args.push('--ignore-case');
+                }
+                // 多行匹配
+                if (options?.multiline) {
+                    args.push('--multiline');
+                }
+                // 固定字符串模式
+                if (options?.fixedStrings) {
+                    args.push('--fixed-strings');
+                }
+                // 单词边界
+                if (options?.wordRegexp) {
+                    args.push('--word-regexp');
+                }
+                // 最大匹配数
+                if (options?.maxCount) {
+                    args.push('--max-count', options.maxCount.toString());
+                }
+                // 最大深度
+                if (options?.maxDepth) {
+                    args.push('--max-depth', options.maxDepth.toString());
+                }
+                // 上下文行
+                const contextBefore = options?.contextBefore ?? options?.context ?? 0;
+                const contextAfter = options?.contextAfter ?? options?.context ?? 0;
+                if (contextBefore > 0) {
+                    args.push('-B', contextBefore.toString());
+                }
+                if (contextAfter > 0) {
+                    args.push('-A', contextAfter.toString());
+                }
+                // 文件过滤
+                if (options?.files && options.files.length > 0) {
+                    for (const file of options.files) {
+                        args.push('--glob', file);
+                    }
+                }
+                // 排除文件
+                if (options?.excludeFiles && options.excludeFiles.length > 0) {
+                    for (const file of options.excludeFiles) {
+                        args.push('--glob', `!${file}`);
+                    }
+                }
+                // 文件类型过滤
+                if (options?.fileTypes && options.fileTypes.length > 0) {
+                    for (const type of options.fileTypes) {
+                        args.push('--type', type);
+                    }
+                }
+                // 排除文件类型
+                if (options?.excludeTypes && options.excludeTypes.length > 0) {
+                    for (const type of options.excludeTypes) {
+                        args.push('--type-not', type);
+                    }
+                }
+                // 只显示文件名
+                if (options?.filesWithMatches) {
+                    args.push('--files-with-matches');
+                }
+                // 只显示匹配数量
+                if (options?.count) {
+                    args.push('--count');
+                }
+                // 忽略 .gitignore
+                if (options?.noIgnore) {
+                    args.push('--no-ignore');
+                }
+                args.push(pattern);
+                args.push('.');
+                return new Promise((resolve, reject) => {
+                    const results = [];
+                    const rgProcess = spawn(rgPath, args, { cwd });
+                    let stdout = '';
+                    let stderr = '';
+                    rgProcess.stdout.on('data', (data) => {
+                        stdout += data.toString();
+                    });
+                    rgProcess.stderr.on('data', (data) => {
+                        stderr += data.toString();
+                    });
+                    rgProcess.on('close', (code) => {
+                        if (code === 0 || code === 1) {
+                            // ripgrep 返回 0 表示找到匹配，1 表示未找到匹配
+                            try {
+                                const lines = stdout.trim().split('\n').filter(line => line.trim());
+                                let currentMatch = null;
+                                const maxResults = options?.maxResults;
+                                for (const line of lines) {
+                                    // 如果设置了 maxResults，检查是否已达到限制
+                                    if (maxResults && results.length >= maxResults) {
+                                        break;
+                                    }
+                                    try {
+                                        const data = JSON.parse(line);
+                                        if (data.type === 'match') {
+                                            // 保存之前的匹配
+                                            if (currentMatch) {
+                                                results.push(currentMatch);
+                                                // 检查是否达到限制
+                                                if (maxResults && results.length >= maxResults) {
+                                                    break;
+                                                }
+                                            }
+                                            const filePath = data.data.path.text;
+                                            const relativePath = path.relative(cwd, filePath);
+                                            const userPath = relativePath.startsWith('..')
+                                                ? filePath
+                                                : `/${relativePath.replace(/\\/g, '/')}`;
+                                            currentMatch = {
+                                                file: userPath,
+                                                line: data.data.line_number,
+                                                text: data.data.lines.text.trimEnd(),
+                                                column: data.data.submatches?.[0]?.start,
+                                                contextBefore: [],
+                                                contextAfter: [],
+                                            };
+                                        }
+                                        else if (data.type === 'context' && currentMatch) {
+                                            // 上下文行
+                                            const lineText = data.data.lines.text.trimEnd();
+                                            const lineNumber = data.data.line_number;
+                                            if (lineNumber < currentMatch.line) {
+                                                currentMatch.contextBefore.push(lineText);
+                                            }
+                                            else if (lineNumber > currentMatch.line) {
+                                                currentMatch.contextAfter.push(lineText);
+                                            }
+                                        }
+                                    }
+                                    catch (e) {
+                                        // 忽略无效的 JSON 行
+                                    }
+                                }
+                                // 添加最后一个匹配（如果未达到限制）
+                                if (currentMatch && (!maxResults || results.length < maxResults)) {
+                                    results.push(currentMatch);
+                                }
+                                resolve(results);
+                            }
+                            catch (error) {
+                                reject(new Error(`Failed to parse ripgrep output: ${error.message}`));
+                            }
+                        }
+                        else {
+                            reject(new Error(`ripgrep failed with code ${code}: ${stderr}`));
+                        }
+                    });
+                    rgProcess.on('error', (error) => {
+                        reject(new Error(`Failed to spawn ripgrep: ${error.message}`));
+                    });
+                });
+            },
+            /**
+             * 通过文件名模式搜索文件
+             */
+            async searchByPath(pattern, options) {
+                const userDir = path.join(getFileSystemDir(), user.id);
+                const cwd = options?.cwd
+                    ? path.resolve(userDir, options.cwd.startsWith('/') ? options.cwd.substring(1) : options.cwd)
+                    : userDir;
+                // 确保工作目录在用户目录内
+                if (!cwd.startsWith(path.resolve(userDir))) {
+                    throw new Error(`Working directory must be within user directory`);
+                }
+                const args = [
+                    '--files',
+                ];
+                // 大小写选项
+                if (options?.caseSensitive === true) {
+                    // 明确指定大小写敏感时不添加 --ignore-case
+                }
+                else {
+                    args.push('--ignore-case');
+                }
+                // 最大深度
+                if (options?.maxDepth) {
+                    args.push('--max-depth', options.maxDepth.toString());
+                }
+                // 文件类型过滤
+                if (options?.fileTypes && options.fileTypes.length > 0) {
+                    for (const type of options.fileTypes) {
+                        args.push('--type', type);
+                    }
+                }
+                // 排除文件类型
+                if (options?.excludeTypes && options.excludeTypes.length > 0) {
+                    for (const type of options.excludeTypes) {
+                        args.push('--type-not', type);
+                    }
+                }
+                // 文件名模式过滤（使用 glob）
+                args.push('--glob', pattern);
+                // 排除文件
+                if (options?.excludeFiles && options.excludeFiles.length > 0) {
+                    for (const file of options.excludeFiles) {
+                        args.push('--glob', `!${file}`);
+                    }
+                }
+                // 忽略 .gitignore
+                if (options?.noIgnore) {
+                    args.push('--no-ignore');
+                }
+                args.push('.');
+                return new Promise((resolve, reject) => {
+                    const results = [];
+                    const rgProcess = spawn(rgPath, args, { cwd });
+                    let stdout = '';
+                    let stderr = '';
+                    rgProcess.stdout.on('data', (data) => {
+                        stdout += data.toString();
+                    });
+                    rgProcess.stderr.on('data', (data) => {
+                        stderr += data.toString();
+                    });
+                    rgProcess.on('close', (code) => {
+                        if (code === 0 || code === 1) {
+                            // ripgrep 返回 0 表示找到文件，1 表示未找到文件
+                            try {
+                                const lines = stdout.trim().split('\n').filter(line => line.trim());
+                                const maxResults = options?.maxResults;
+                                for (const line of lines) {
+                                    // 如果设置了 maxResults，检查是否已达到限制
+                                    if (maxResults && results.length >= maxResults) {
+                                        break;
+                                    }
+                                    if (line.trim()) {
+                                        const filePath = path.resolve(cwd, line.trim());
+                                        // 确保文件路径在用户目录内
+                                        if (filePath.startsWith(path.resolve(userDir))) {
+                                            const relativePath = path.relative(cwd, filePath);
+                                            // 转换为用户可见的路径格式（以 / 开头）
+                                            const userPath = relativePath.startsWith('..')
+                                                ? filePath
+                                                : `/${relativePath.replace(/\\/g, '/')}`;
+                                            results.push(userPath);
+                                        }
+                                    }
+                                }
+                                resolve(results);
+                            }
+                            catch (error) {
+                                reject(new Error(`Failed to parse ripgrep output: ${error.message}`));
+                            }
+                        }
+                        else {
+                            reject(new Error(`ripgrep failed with code ${code}: ${stderr}`));
+                        }
+                    });
+                    rgProcess.on('error', (error) => {
+                        reject(new Error(`Failed to spawn ripgrep: ${error.message}`));
+                    });
+                });
+            },
+        },
+        // 调用其他 MCP 工具
+        mcp: {
+            async callTool(toolName, args) {
+                if (!aggregator) {
+                    throw new Error('MCP aggregator not available. Tool calling is only available after initialization.');
+                }
+                // 确保聚合器已初始化
+                if (!aggregator.initialized) {
+                    throw new Error('MCP aggregator not initialized yet. Tool calling is only available after initialization.');
+                }
+                // Context 中的调用允许使用禁用的组件，因为这是用户在自己的脚本中主动调用的
+                return await aggregator.callTool(toolName, args, true);
+            },
+            async listTools() {
+                if (!aggregator) {
+                    return [];
+                }
+                if (!aggregator.initialized) {
+                    return [];
+                }
+                return await aggregator.getAllTools().then(tools => tools.map(t => t.name));
+            },
+        },
+        // 变量引用
+        vars: {
+            get(name) {
+                const variable = config.variables.find((v) => v.name === name);
+                return variable?.value || '';
+            },
+            has(name) {
+                return config.variables.some((v) => v.name === name);
+            },
+            getAll() {
+                const result = {};
+                for (const variable of config.variables) {
+                    result[variable.name] = variable.value;
+                }
+                return result;
+            },
+            set(name, value, description) {
+                const existingIndex = config.variables.findIndex((v) => v.name === name);
+                if (existingIndex >= 0) {
+                    // 更新现有变量
+                    config.variables[existingIndex].value = value;
+                    if (description !== undefined) {
+                        config.variables[existingIndex].description = description;
+                    }
+                }
+                else {
+                    // 创建新变量
+                    config.variables.push({
+                        id: generateId(),
+                        name,
+                        value,
+                        ...(description !== undefined && { description }),
+                    });
+                }
+            },
+        },
+        // 日志
+        log: {
+            info(message, ...args) {
+                console.log(`[INFO] ${message}`, ...args);
+            },
+            error(message, ...args) {
+                console.error(`[ERROR] ${message}`, ...args);
+            },
+            warn(message, ...args) {
+                console.warn(`[WARN] ${message}`, ...args);
+            },
+            debug(message, ...args) {
+                console.debug(`[DEBUG] ${message}`, ...args);
+            },
+        },
+        // 表数据访问（仅限当前用户）
+        tables: {
+            async list() {
+                try {
+                    // 只查询当前用户的表
+                    const result = await db
+                        .select()
+                        .from(tableDefinitions)
+                        .where(eq(tableDefinitions.userId, config.userId));
+                    return result.map((row) => {
+                        // 解析列定义，确保包含 description 字段
+                        const columns = JSON.parse(row.columns);
+                        const tableDef = {
+                            id: row.id,
+                            name: row.name,
+                            description: row.description || undefined,
+                            columns: columns, // 确保返回包含 description 的列定义
+                            createdAt: row.createdAt,
+                            updatedAt: row.updatedAt,
+                        };
+                        return tableDef;
+                    });
+                }
+                catch (error) {
+                    console.error('[Tables.list] Error:', error);
+                    throw new Error(`Failed to list tables: ${error.message}`);
+                }
+            },
+            async getDefinition(tableName) {
+                try {
+                    // 查找当前用户的表定义
+                    const tableDefs = await db
+                        .select()
+                        .from(tableDefinitions)
+                        .where(and(eq(tableDefinitions.name, tableName), eq(tableDefinitions.userId, config.userId)))
+                        .limit(1);
+                    if (tableDefs.length === 0) {
+                        throw new Error(`Table "${tableName}" not found`);
+                    }
+                    const tableDef = tableDefs[0];
+                    // 解析列定义，确保包含 description 字段
+                    const columns = JSON.parse(tableDef.columns);
+                    const result = {
+                        id: tableDef.id,
+                        name: tableDef.name,
+                        description: tableDef.description || undefined,
+                        columns: columns, // 确保返回包含 description 的列定义
+                        createdAt: tableDef.createdAt,
+                        updatedAt: tableDef.updatedAt,
+                    };
+                    return result;
+                }
+                catch (error) {
+                    console.error(`[Tables.getDefinition] Error for table "${tableName}":`, error);
+                    throw new Error(`Failed to get table definition "${tableName}": ${error.message}`);
+                }
+            },
+            async get(tableName) {
+                try {
+                    // 查找当前用户的表定义
+                    const tableDefs = await db
+                        .select()
+                        .from(tableDefinitions)
+                        .where(and(eq(tableDefinitions.name, tableName), eq(tableDefinitions.userId, config.userId)))
+                        .limit(1);
+                    if (tableDefs.length === 0) {
+                        throw new Error(`Table "${tableName}" not found`);
+                    }
+                    const tableDef = tableDefs[0];
+                    // 获取表的所有数据
+                    const rows = await db
+                        .select()
+                        .from(tableData)
+                        .where(eq(tableData.tableId, tableDef.id));
+                    // 返回行数据（不包含元数据）
+                    return rows.map((row) => JSON.parse(row.rowData));
+                }
+                catch (error) {
+                    console.error(`[Tables.get] Error for table "${tableName}":`, error);
+                    throw new Error(`Failed to get table "${tableName}": ${error.message}`);
+                }
+            },
+            async query(tableName, filter) {
+                try {
+                    const allRows = await this.get(tableName);
+                    if (!filter) {
+                        return allRows;
+                    }
+                    return allRows.filter(filter);
+                }
+                catch (error) {
+                    console.error(`[Tables.query] Error for table "${tableName}":`, error);
+                    throw new Error(`Failed to query table "${tableName}": ${error.message}`);
+                }
+            },
+        },
+        // SQL 执行（仅限当前用户的表）
+        sql: {
+            /**
+             * 执行 SQL 语句
+             * 只能访问和操作当前用户的表
+             * 支持 SELECT, INSERT, UPDATE, DELETE
+             */
+            async execute(sql) {
+                try {
+                    // 获取当前用户的所有表定义
+                    const userTables = await db
+                        .select({ id: tableDefinitions.id, name: tableDefinitions.name, columns: tableDefinitions.columns })
+                        .from(tableDefinitions)
+                        .where(eq(tableDefinitions.userId, config.userId));
+                    const userTableMap = new Map(userTables.map(t => [t.name.toLowerCase(), t]));
+                    const sqlLower = sql.toLowerCase().trim();
+                    // 检查是否包含危险操作
+                    const dangerousKeywords = ['drop', 'truncate', 'alter', 'create', 'replace', 'attach', 'detach'];
+                    for (const keyword of dangerousKeywords) {
+                        if (sqlLower.includes(keyword)) {
+                            throw new Error(`SQL keyword "${keyword}" is not allowed`);
+                        }
+                    }
+                    // 提取 SQL 中涉及的表名
+                    const tableNamePattern = /\b(from|into|update|join)\s+(\w+)/gi;
+                    const matches = Array.from(sql.matchAll(tableNamePattern));
+                    const referencedTables = matches.map(m => m[2].toLowerCase());
+                    // 验证所有引用的表都属于当前用户
+                    for (const tableName of referencedTables) {
+                        if (!userTableMap.has(tableName)) {
+                            throw new Error(`Table "${tableName}" not found or access denied`);
+                        }
+                    }
+                    // 由于用户表的数据存储在 table_data 表的 JSON 字段中，
+                    // 我们需要创建临时视图来映射用户表到实际的 SQLite 表结构
+                    // 然后执行 SQL，最后清理视图
+                    const viewNames = [];
+                    try {
+                        // 为每个用户表创建临时视图
+                        for (const table of userTables) {
+                            const viewName = `_user_table_${table.id.replace(/-/g, '_')}`;
+                            viewNames.push(viewName);
+                            // 获取表的所有数据
+                            const rows = await db
+                                .select()
+                                .from(tableData)
+                                .where(eq(tableData.tableId, table.id));
+                            const columns = JSON.parse(table.columns);
+                            // 创建临时表来存储数据（因为视图不支持直接查询 JSON）
+                            // 使用 WITH 子句创建临时表
+                            const columnDefs = columns.map(col => {
+                                const sqliteType = col.type === 'number' ? 'REAL' :
+                                    col.type === 'boolean' ? 'INTEGER' :
+                                        col.type === 'date' ? 'TEXT' :
+                                            col.type === 'json' ? 'TEXT' : 'TEXT';
+                                return `"${col.name}" ${sqliteType}`;
+                            }).join(', ');
+                            // 创建临时表
+                            const createTempTableSql = `
+                CREATE TEMP TABLE IF NOT EXISTS ${viewName} (
+                  id TEXT PRIMARY KEY,
+                  ${columnDefs},
+                  created_at INTEGER,
+                  updated_at INTEGER
+                );
+              `;
+                            sqlite.exec(createTempTableSql);
+                            // 插入数据
+                            for (const row of rows) {
+                                const rowData = JSON.parse(row.rowData);
+                                const values = columns.map(col => {
+                                    const value = rowData[col.name];
+                                    if (value === null || value === undefined) {
+                                        return 'NULL';
+                                    }
+                                    if (col.type === 'string' || col.type === 'date' || col.type === 'json') {
+                                        return `'${String(value).replace(/'/g, "''")}'`;
+                                    }
+                                    return String(value);
+                                }).join(', ');
+                                const insertSql = `
+                  INSERT OR REPLACE INTO ${viewName} (id, ${columns.map(c => `"${c.name}"`).join(', ')}, created_at, updated_at)
+                  VALUES ('${row.id}', ${values}, ${row.createdAt.getTime()}, ${row.updatedAt.getTime()});
+                `;
+                                sqlite.exec(insertSql);
+                            }
+                            // 在 SQL 中替换表名
+                            const tableNameRegex = new RegExp(`\\b${table.name}\\b`, 'gi');
+                            sql = sql.replace(tableNameRegex, viewName);
+                        }
+                        // 执行 SQL
+                        if (sqlLower.startsWith('select')) {
+                            // SELECT 查询
+                            const stmt = sqlite.prepare(sql);
+                            const results = stmt.all();
+                            return results;
+                        }
+                        else if (sqlLower.startsWith('insert')) {
+                            // INSERT 操作
+                            const stmt = sqlite.prepare(sql);
+                            const result = stmt.run();
+                            // 同步回 table_data 表
+                            // 找到对应的表
+                            const insertMatch = sqlLower.match(/into\s+(\w+)/i);
+                            if (insertMatch) {
+                                const tableName = insertMatch[1];
+                                const userTable = userTables.find(t => {
+                                    const viewName = `_user_table_${t.id.replace(/-/g, '_')}`;
+                                    return viewName.toLowerCase() === tableName.toLowerCase();
+                                });
+                                if (userTable) {
+                                    // 获取新插入的行
+                                    const newRowStmt = sqlite.prepare(`SELECT * FROM ${tableName} WHERE rowid = ?`);
+                                    const newRow = newRowStmt.get(result.lastInsertRowid);
+                                    if (newRow) {
+                                        // 构建 rowData（排除 id, created_at, updated_at）
+                                        const rowData = {};
+                                        const columns = JSON.parse(userTable.columns);
+                                        for (const col of columns) {
+                                            if (newRow[col.name] !== undefined) {
+                                                rowData[col.name] = newRow[col.name];
+                                            }
+                                        }
+                                        // 插入到 table_data
+                                        const rowId = newRow.id || generateId();
+                                        const now = new Date();
+                                        await db.insert(tableData).values({
+                                            id: rowId,
+                                            tableId: userTable.id,
+                                            rowData: JSON.stringify(rowData),
+                                            createdAt: now,
+                                            updatedAt: now,
+                                        });
+                                    }
+                                }
+                            }
+                            return {
+                                changes: result.changes,
+                                lastInsertRowid: result.lastInsertRowid,
+                            };
+                        }
+                        else if (sqlLower.startsWith('update') || sqlLower.startsWith('delete')) {
+                            // UPDATE 或 DELETE 操作
+                            // 由于需要同步回 table_data，这里暂时不支持
+                            // 未来可以实现更完整的同步逻辑
+                            throw new Error('UPDATE and DELETE operations are not yet fully supported. Please use the tables API methods instead.');
+                        }
+                        else {
+                            throw new Error(`Unsupported SQL operation: ${sqlLower.split(' ')[0]}`);
+                        }
+                    }
+                    finally {
+                        // 清理临时表
+                        for (const viewName of viewNames) {
+                            try {
+                                sqlite.exec(`DROP TABLE IF EXISTS ${viewName};`);
+                            }
+                            catch (e) {
+                                // 忽略清理错误
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('[SQL.execute] Error:', error);
+                    throw new Error(`SQL execution failed: ${error.message}`);
+                }
+            },
+        },
+    };
+}
+//# sourceMappingURL=context.js.map