foliko 1.0.0

package/plugins/python-executor-plugin.js

@@ -0,0 +1,331 @@
+/**
+ * Python 执行器插件
+ * 使用 child_process 执行 Python 代码和脚本
+ */
+
+const { Plugin } = require('../src/core/plugin-base')
+const { spawn } = require('child_process')
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const { z } = require('zod')
+
+class PythonExecutorPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'python-executor'
+    this.version = '1.0.0'
+    this.description = 'Python 执行器，用于运行 Python 代码和脚本'
+    this.priority = 15
+
+    this.config = {
+      pythonPath: config.pythonPath || 'python',  // python 或 python3
+      timeout: config.timeout || 120000,         // 2分钟超时
+      baseDir: config.baseDir || '.agent/python-scripts',
+      pipPath: config.pipPath || null             // 可选，自定义 pip 路径
+    }
+
+    this._framework = null
+    this._tempDir = null
+  }
+
+  install(framework) {
+    this._framework = framework
+
+    // 确保临时目录存在
+    this._tempDir = path.join(os.tmpdir(), `vb-python-${process.pid}`)
+    if (!fs.existsSync(this._tempDir)) {
+      fs.mkdirSync(this._tempDir, { recursive: true })
+    }
+
+    return this
+  }
+
+  start(framework) {
+    // 注册 python 工具
+    framework.registerTool({
+      name: 'python',
+      description: '执行 Python 代码',
+      inputSchema: z.object({
+        code: z.string().describe('Python 代码'),
+        timeout: z.number().optional().describe('超时时间（毫秒），默认 120000')
+      }),
+      execute: async (args) => {
+        return this._executePython(args.code, args.timeout || this.config.timeout)
+      }
+    })
+
+    // 注册 python_script 工具
+    framework.registerTool({
+      name: 'python_script',
+      description: '执行 Python 脚本文件',
+      inputSchema: z.object({
+        scriptPath: z.string().describe('Python 脚本文件路径'),
+        args: z.string().optional().describe('传递给脚本的命令行参数'),
+        timeout: z.number().optional().describe('超时时间（毫秒）')
+      }),
+      execute: async (args) => {
+        return this._executeScript(args.scriptPath, args.args, args.timeout || this.config.timeout)
+      }
+    })
+
+    // 注册 pip_install 工具
+    framework.registerTool({
+      name: 'pip_install',
+      description: '安装 Python 包',
+      inputSchema: z.object({
+        package: z.string().describe('包名 (例如: numpy, pandas>=1.0)'),
+        upgrade: z.boolean().optional().describe('是否升级已存在的包'),
+        timeout: z.number().optional().describe('超时时间（毫秒）')
+      }),
+      execute: async (args) => {
+        return this._pipInstall(args.package, args.upgrade, args.timeout || this.config.timeout)
+      }
+    })
+
+    return this
+  }
+
+  /**
+   * 执行 Python 代码
+   * @private
+   */
+  _executePython(code, timeout) {
+    return new Promise((resolve) => {
+      const startTime = Date.now()
+      let output = ''
+      let errorOutput = ''
+
+      // 创建临时脚本文件
+      const tempFile = path.join(this._tempDir, `temp_${Date.now()}.py`)
+
+      // 包装代码，添加错误处理
+      const wrappedCode = `
+import sys
+import traceback
+try:
+${code.split('\n').map(line => '    ' + line).join('\n')}
+except SystemExit:
+    pass
+except Exception:
+    traceback.print_exc()
+    sys.exit(1)
+`
+
+      fs.writeFileSync(tempFile, wrappedCode, 'utf-8')
+
+      const proc = spawn(this.config.pythonPath, [tempFile], {
+        timeout,
+        env: { ...process.env }
+      })
+
+      proc.stdout.on('data', (data) => {
+        output += data.toString()
+      })
+
+      proc.stderr.on('data', (data) => {
+        errorOutput += data.toString()
+      })
+
+      proc.on('close', (code) => {
+        // 清理临时文件
+        try {
+          fs.unlinkSync(tempFile)
+        } catch (e) { }
+
+        const elapsed = Date.now() - startTime
+        resolve({
+          success: code === 0,
+          exitCode: code,
+          stdout: output,
+          stderr: errorOutput,
+          elapsed,
+          timedOut: code === null
+        })
+      })
+
+      proc.on('error', (err) => {
+        // 清理临时文件
+        try {
+          fs.unlinkSync(tempFile)
+        } catch (e) { }
+
+        resolve({
+          success: false,
+          error: err.message
+        })
+      })
+
+      setTimeout(() => {
+        if (!proc.killed) {
+          proc.kill('SIGTERM')
+          try {
+            fs.unlinkSync(tempFile)
+          } catch (e) { }
+          resolve({
+            success: false,
+            error: `Python execution timed out after ${timeout}ms`,
+            stdout: output,
+            stderr: errorOutput,
+            timedOut: true
+          })
+        }
+      }, timeout)
+    })
+  }
+
+  /**
+   * 执行 Python 脚本文件
+   * @private
+   */
+  _executeScript(scriptPath, args, timeout) {
+    return new Promise((resolve) => {
+      const startTime = Date.now()
+      let output = ''
+      let errorOutput = ''
+
+      // 检查文件是否存在
+      if (!fs.existsSync(scriptPath)) {
+        resolve({
+          success: false,
+          error: `Script file not found: ${scriptPath}`
+        })
+        return
+      }
+
+      const procArgs = [scriptPath]
+      if (args) {
+        procArgs.push(...args.split(' '))
+      }
+
+      const proc = spawn(this.config.pythonPath, procArgs, {
+        timeout,
+        env: { ...process.env }
+      })
+
+      proc.stdout.on('data', (data) => {
+        output += data.toString()
+      })
+
+      proc.stderr.on('data', (data) => {
+        errorOutput += data.toString()
+      })
+
+      proc.on('close', (code) => {
+        const elapsed = Date.now() - startTime
+        resolve({
+          success: code === 0,
+          exitCode: code,
+          stdout: output,
+          stderr: errorOutput,
+          elapsed,
+          timedOut: code === null
+        })
+      })
+
+      proc.on('error', (err) => {
+        resolve({
+          success: false,
+          error: err.message
+        })
+      })
+
+      setTimeout(() => {
+        if (!proc.killed) {
+          proc.kill('SIGTERM')
+          resolve({
+            success: false,
+            error: `Script execution timed out after ${timeout}ms`,
+            stdout: output,
+            stderr: errorOutput,
+            timedOut: true
+          })
+        }
+      }, timeout)
+    })
+  }
+
+  /**
+   * 安装 Python 包
+   * @private
+   */
+  _pipInstall(packageName, upgrade, timeout) {
+    return new Promise((resolve) => {
+      const startTime = Date.now()
+      let output = ''
+      let errorOutput = ''
+
+      const pipPath = this.config.pipPath || this.config.pythonPath.replace('python', 'pip')
+      const args = [packageName]
+      if (upgrade) args.unshift('-U')
+      if (upgrade === undefined && packageName.includes('>=')) args.unshift('-U')
+
+      const proc = spawn(pipPath, ['install', ...args], {
+        timeout,
+        env: { ...process.env }
+      })
+
+      proc.stdout.on('data', (data) => {
+        output += data.toString()
+      })
+
+      proc.stderr.on('data', (data) => {
+        errorOutput += data.toString()
+      })
+
+      proc.on('close', (code) => {
+        const elapsed = Date.now() - startTime
+        resolve({
+          success: code === 0,
+          exitCode: code,
+          stdout: output,
+          stderr: errorOutput,
+          elapsed,
+          package: packageName,
+          upgraded: upgrade || packageName.includes('>=')
+        })
+      })
+
+      proc.on('error', (err) => {
+        resolve({
+          success: false,
+          error: err.message,
+          package: packageName
+        })
+      })
+
+      setTimeout(() => {
+        if (!proc.killed) {
+          proc.kill('SIGTERM')
+          resolve({
+            success: false,
+            error: `pip install timed out after ${timeout}ms`,
+            stdout: output,
+            stderr: errorOutput,
+            timedOut: true,
+            package: packageName
+          })
+        }
+      }, timeout)
+    })
+  }
+
+  reload(framework) {
+    this._framework = framework
+  }
+
+  uninstall(framework) {
+    // 清理临时目录
+    if (this._tempDir && fs.existsSync(this._tempDir)) {
+      try {
+        fs.rmSync(this._tempDir, { recursive: true, force: true })
+      } catch (e) {
+        console.warn(`[PythonExecutor] Failed to cleanup temp dir: ${e.message}`)
+      }
+    }
+    this._framework = null
+    this._tempDir = null
+  }
+}
+
+module.exports = { PythonExecutorPlugin }

package/plugins/rules-plugin.js

@@ -0,0 +1,292 @@
+/**
+ * Rules 规则引擎插件
+ * 控制工具调用权限、内容过滤、触发动作
+ */
+
+const { Plugin } = require('../src/core/plugin-base')
+const { z } = require('zod')
+const fs = require('fs')
+const path = require('path')
+
+/**
+ * 内置规则类型
+ */
+const RuleType = {
+  ALLOW: 'allow',      // 允许
+  DENY: 'deny',        // 拒绝
+  TRANSFORM: 'transform',  // 转换
+  RATE_LIMIT: 'rate_limit' // 限流
+}
+
+/**
+ * 规则评估结果
+ */
+class RuleResult {
+  constructor(allowed, rule = null, transform = null) {
+    this.allowed = allowed
+    this.rule = rule
+    this.transform = transform
+  }
+}
+
+class RulesPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'rules'
+    this.version = '1.0.0'
+    this.description = '规则引擎插件，用于控制工具调用权限、内容过滤、触发动作'
+    this.priority = 25
+
+    this.config = {
+      rulesDir: config.rulesDir || '.agent/rules',
+      autoLoad: config.autoLoad !== false
+    }
+
+    this._framework = null
+    this._rules = []
+    this._ruleStats = {
+      total: 0,
+      allowed: 0,
+      denied: 0,
+      transformed: 0
+    }
+  }
+
+  install(framework) {
+    this._framework = framework
+    return this
+  }
+
+  start(framework) {
+    // 自动加载规则文件
+    if (this.config.autoLoad && this.config.rulesDir) {
+      this.loadFromDirectory(this.config.rulesDir)
+    }
+
+    // 注册规则管理工具
+    framework.registerTool({
+      name: 'rules_list',
+      description: '列出所有规则',
+      inputSchema: z.object({}),
+      execute: async () => {
+        return {
+          success: true,
+          rules: this._rules.map(r => ({
+            name: r.name,
+            type: r.type,
+            target: r.target,
+            description: r.description,
+            enabled: r.enabled
+          })),
+          total: this._rules.length
+        }
+      }
+    })
+
+    framework.registerTool({
+      name: 'rules_add',
+      description: '添加规则',
+      inputSchema: z.object({
+        name: z.string().describe('规则名称'),
+        type: z.enum(['allow', 'deny', 'transform']).describe('规则类型'),
+        target: z.string().describe('目标 (工具名, *, @event-type)'),
+        pattern: z.string().optional().describe('匹配模式 (正则表达式)'),
+        description: z.string().optional().describe('规则描述'),
+        action: z.object({}).optional().describe('规则动作 (transform 时使用)')
+      }),
+      execute: async (args) => {
+        const rule = {
+          name: args.name,
+          type: args.type,
+          target: args.target,
+          pattern: args.pattern ? new RegExp(args.pattern) : null,
+          description: args.description || '',
+          action: args.action || {},
+          enabled: true
+        }
+        this._rules.push(rule)
+        return { success: true, rule: rule.name }
+      }
+    })
+
+    framework.registerTool({
+      name: 'rules_remove',
+      description: '移除规则',
+      inputSchema: z.object({
+        name: z.string().describe('规则名称')
+      }),
+      execute: async (args) => {
+        const index = this._rules.findIndex(r => r.name === args.name)
+        if (index === -1) {
+          return { success: false, error: 'Rule not found' }
+        }
+        this._rules.splice(index, 1)
+        return { success: true, removed: args.name }
+      }
+    })
+
+    framework.registerTool({
+      name: 'rules_stats',
+      description: '获取规则统计',
+      inputSchema: z.object({}),
+      execute: async () => {
+        return {
+          success: true,
+          stats: { ...this._ruleStats }
+        }
+      }
+    })
+
+    framework.registerTool({
+      name: 'rules_test',
+      description: '测试规则匹配',
+      inputSchema: z.object({
+        target: z.string().describe('目标 (工具名或事件类型)'),
+        input: z.object({}).optional().describe('输入参数')
+      }),
+      execute: async (args) => {
+        const result = this.evaluate(args.target, args.input || {})
+        return {
+          success: true,
+          target: args.target,
+          result: {
+            allowed: result.allowed,
+            ruleName: result.rule?.name || null,
+            ruleType: result.rule?.type || null
+          }
+        }
+      }
+    })
+
+    return this
+  }
+
+  /**
+   * 从目录加载规则文件
+   */
+  loadFromDirectory(rulesDir) {
+    const resolvedDir = path.resolve(process.cwd(), rulesDir)
+
+    if (!fs.existsSync(resolvedDir)) {
+      console.log(`[RulesPlugin] Rules directory not found: ${resolvedDir}`)
+      return
+    }
+
+    try {
+      const files = fs.readdirSync(resolvedDir).filter(f => f.endsWith('.json'))
+
+      for (const file of files) {
+        const filePath = path.join(resolvedDir, file)
+        const content = fs.readFileSync(filePath, 'utf-8')
+        const rules = JSON.parse(content)
+
+        for (const rule of rules) {
+          if (rule.pattern) {
+            rule.pattern = new RegExp(rule.pattern)
+          }
+          rule.enabled = rule.enabled !== false
+          this._rules.push(rule)
+        }
+
+        console.log(`[RulesPlugin] Loaded ${rules.length} rules from ${file}`)
+      }
+    } catch (err) {
+      console.error(`[RulesPlugin] Failed to load rules: ${err.message}`)
+    }
+  }
+
+  /**
+   * 评估目标是否符合规则
+   * @param {string} target - 目标 (工具名, *, @event-type)
+   * @param {Object} input - 输入参数
+   * @returns {RuleResult}
+   */
+  evaluate(target, input = {}) {
+    this._ruleStats.total++
+
+    // 按优先级排序规则 (先加载的在前)
+    for (const rule of this._rules) {
+      if (!rule.enabled) continue
+
+      // 匹配目标
+      if (rule.target !== '*' && rule.target !== target) continue
+
+      // 匹配模式 (如果有)
+      if (rule.pattern) {
+        const targetStr = typeof input === 'string' ? input : JSON.stringify(input)
+        if (!rule.pattern.test(targetStr)) continue
+      }
+
+      // 评估规则
+      if (rule.type === RuleType.DENY) {
+        this._ruleStats.denied++
+        return new RuleResult(false, rule)
+      }
+
+      if (rule.type === RuleType.ALLOW) {
+        this._ruleStats.allowed++
+        return new RuleResult(true, rule)
+      }
+
+      if (rule.type === RuleType.TRANSFORM) {
+        this._ruleStats.transformed++
+        return new RuleResult(true, rule, rule.action)
+      }
+    }
+
+    // 没有匹配规则，默认允许
+    this._ruleStats.allowed++
+    return new RuleResult(true)
+  }
+
+  /**
+   * 检查工具调用是否允许
+   */
+  checkToolCall(toolName, args) {
+    return this.evaluate(toolName, args)
+  }
+
+  /**
+   * 检查消息是否允许
+   */
+  checkMessage(message, context) {
+    return this.evaluate('@message', { message, context })
+  }
+
+  /**
+   * 添加规则
+   */
+  addRule(rule) {
+    this._rules.push(rule)
+  }
+
+  /**
+   * 移除规则
+   */
+  removeRule(name) {
+    const index = this._rules.findIndex(r => r.name === name)
+    if (index !== -1) {
+      this._rules.splice(index, 1)
+      return true
+    }
+    return false
+  }
+
+  reload(framework) {
+    this._framework = framework
+    this._rules = []
+    this._ruleStats = { total: 0, allowed: 0, denied: 0, transformed: 0 }
+
+    if (this.config.autoLoad && this.config.rulesDir) {
+      this.loadFromDirectory(this.config.rulesDir)
+    }
+  }
+
+  uninstall(framework) {
+    this._rules = []
+    this._ruleStats = { total: 0, allowed: 0, denied: 0, transformed: 0 }
+    this._framework = null
+  }
+}
+
+module.exports = { RulesPlugin }