foliko 1.0.0

package/plugins/session-plugin.js

@@ -0,0 +1,343 @@
+/**
+ * Session 会话管理插件
+ * 管理多个用户会话，支持会话隔离和历史记录
+ */
+
+const { Plugin } = require('../src/core/plugin-base')
+const { z } = require('zod')
+
+/**
+ * 生成 UUID
+ */
+function generateId() {
+  if (require('crypto').randomUUID) {
+    return require('crypto').randomUUID()
+  }
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    const r = Math.random() * 16 | 0
+    const v = c === 'x' ? r : (r & 0x3 | 0x8)
+    return v.toString(16)
+  })
+}
+
+class SessionPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'session'
+    this.version = '1.0.0'
+    this.description = '会话管理插件，支持多会话隔离、历史记录、会话超时清理'
+    this.priority = 5
+
+    this.config = {
+      sessionTTL: config.sessionTTL || 30 * 60 * 1000,  // 30分钟
+      maxSessions: config.maxSessions || 100,
+      maxHistoryLength: config.maxHistoryLength || 50,
+      autoCleanup: config.autoCleanup !== false,
+      cleanupInterval: config.cleanupInterval || 5 * 60 * 1000  // 5分钟
+    }
+
+    this._framework = null
+    this._sessions = new Map()
+    this._cleanupTimer = null
+  }
+
+  install(framework) {
+    this._framework = framework
+    return this
+  }
+
+  start(framework) {
+    // 注册会话管理工具
+    framework.registerTool({
+      name: 'session_create',
+      description: '创建新会话',
+      inputSchema: z.object({
+        sessionId: z.string().optional().describe('可选：指定会话 ID'),
+        metadata: z.object({}).optional().describe('会话元数据')
+      }),
+      execute: async (args) => {
+        const sessionId = args.sessionId || `session_${generateId()}`
+        const session = this.createSession(sessionId, { metadata: args.metadata })
+        return {
+          success: true,
+          sessionId: session.id,
+          createdAt: session.createdAt
+        }
+      }
+    })
+
+    framework.registerTool({
+      name: 'session_get',
+      description: '获取会话信息',
+      inputSchema: z.object({
+        sessionId: z.string().describe('会话 ID')
+      }),
+      execute: async (args) => {
+        const session = this.getSession(args.sessionId)
+        if (!session) {
+          return { success: false, error: 'Session not found' }
+        }
+        return {
+          success: true,
+          sessionId: session.id,
+          messageCount: session.messages.length,
+          variables: Object.keys(session.variables),
+          createdAt: session.createdAt,
+          lastActive: session.lastActive
+        }
+      }
+    })
+
+    framework.registerTool({
+      name: 'session_list',
+      description: '列出所有会话',
+      inputSchema: z.object({}),
+      execute: async () => {
+        const sessions = this.listSessions()
+        return {
+          success: true,
+          sessions,
+          total: sessions.length
+        }
+      }
+    })
+
+    framework.registerTool({
+      name: 'session_delete',
+      description: '删除会话',
+      inputSchema: z.object({
+        sessionId: z.string().describe('会话 ID')
+      }),
+      execute: async (args) => {
+        const deleted = this.deleteSession(args.sessionId)
+        return { success: deleted, deleted: args.sessionId }
+      }
+    })
+
+    framework.registerTool({
+      name: 'session_history',
+      description: '获取会话历史消息',
+      inputSchema: z.object({
+        sessionId: z.string().describe('会话 ID'),
+        limit: z.number().optional().describe('返回消息数量限制')
+      }),
+      execute: async (args) => {
+        const history = this.getHistory(args.sessionId, args.limit)
+        return {
+          success: true,
+          sessionId: args.sessionId,
+          messages: history,
+          count: history.length
+        }
+      }
+    })
+
+    framework.registerTool({
+      name: 'session_stats',
+      description: '获取会话统计信息',
+      inputSchema: z.object({}),
+      execute: async () => {
+        return {
+          success: true,
+          stats: this.getMemoryStats()
+        }
+      }
+    })
+
+    // 启动自动清理
+    if (this.config.autoCleanup) {
+      this._startAutoCleanup()
+    }
+
+    return this
+  }
+
+  /**
+   * 创建新会话
+   */
+  createSession(sessionId, options = {}) {
+    const id = sessionId || `session_${generateId()}`
+
+    if (this._sessions.has(id)) {
+      return this._sessions.get(id)
+    }
+
+    // 如果会话数超过限制，清理最老的
+    if (this._sessions.size >= this.config.maxSessions) {
+      this._cleanupLRU()
+    }
+
+    const session = {
+      id,
+      messages: options.initialMessages || [],
+      variables: options.variables || {},
+      metadata: options.metadata || {},
+      createdAt: new Date(),
+      lastActive: new Date()
+    }
+
+    this._sessions.set(id, session)
+    return session
+  }
+
+  /**
+   * 获取会话
+   */
+  getSession(sessionId) {
+    const session = this._sessions.get(sessionId)
+    if (session) {
+      session.lastActive = new Date()
+    }
+    return session
+  }
+
+  /**
+   * 获取或创建会话
+   */
+  getOrCreateSession(sessionId, options = {}) {
+    let session = this.getSession(sessionId)
+    if (!session) {
+      session = this.createSession(sessionId, options)
+    }
+    return session
+  }
+
+  /**
+   * 添加消息到会话
+   */
+  addMessage(sessionId, message) {
+    const session = this.getSession(sessionId)
+    if (session) {
+      session.messages.push(message)
+      session.lastActive = new Date()
+
+      // 限制历史长度
+      if (session.messages.length > this.config.maxHistoryLength) {
+        session.messages = session.messages.slice(-this.config.maxHistoryLength)
+      }
+    }
+    return session
+  }
+
+  /**
+   * 获取会话历史
+   */
+  getHistory(sessionId, limit = null) {
+    const session = this.getSession(sessionId)
+    if (!session) return []
+
+    const messages = session.messages
+    if (limit) {
+      return messages.slice(-limit)
+    }
+    return messages
+  }
+
+  /**
+   * 删除会话
+   */
+  deleteSession(sessionId) {
+    return this._sessions.delete(sessionId)
+  }
+
+  /**
+   * 列出所有会话
+   */
+  listSessions() {
+    return Array.from(this._sessions.values()).map(s => ({
+      id: s.id,
+      messageCount: s.messages.length,
+      createdAt: s.createdAt,
+      lastActive: s.lastActive,
+      metadata: s.metadata
+    }))
+  }
+
+  /**
+   * 清理过期会话
+   */
+  cleanup() {
+    const now = Date.now()
+    let cleanedCount = 0
+
+    for (const [sessionId, session] of this._sessions) {
+      if (now - session.lastActive.getTime() > this.config.sessionTTL) {
+        this._sessions.delete(sessionId)
+        cleanedCount++
+      }
+    }
+
+    return cleanedCount
+  }
+
+  /**
+   * LRU 清理 - 删除最老的 20% 会话
+   */
+  _cleanupLRU() {
+    const sessions = Array.from(this._sessions.values())
+    if (sessions.length === 0) return
+
+    // 按最后活跃时间排序
+    sessions.sort((a, b) => a.lastActive.getTime() - b.lastActive.getTime())
+
+    // 删除最老的会话
+    const toDelete = sessions.slice(0, Math.ceil(sessions.length * 0.2))
+    for (const session of toDelete) {
+      this._sessions.delete(session.id)
+    }
+  }
+
+  /**
+   * 获取内存统计
+   */
+  getMemoryStats() {
+    const sessionCount = this._sessions.size
+    const totalMessages = Array.from(this._sessions.values()).reduce(
+      (sum, s) => sum + s.messages.length, 0
+    )
+
+    return {
+      sessionCount,
+      maxSessions: this.config.maxSessions,
+      totalMessages,
+      ttl: this.config.sessionTTL
+    }
+  }
+
+  /**
+   * 清理所有会话
+   */
+  clear() {
+    this._sessions.clear()
+  }
+
+  /**
+   * 启动自动清理定时器
+   */
+  _startAutoCleanup() {
+    if (this._cleanupTimer) {
+      clearInterval(this._cleanupTimer)
+    }
+    this._cleanupTimer = setInterval(() => {
+      const cleaned = this.cleanup()
+      if (cleaned > 0) {
+        console.log(`[SessionPlugin] Cleaned up ${cleaned} expired sessions`)
+      }
+    }, this.config.cleanupInterval)
+  }
+
+  reload(framework) {
+    this._framework = framework
+  }
+
+  uninstall(framework) {
+    if (this._cleanupTimer) {
+      clearInterval(this._cleanupTimer)
+      this._cleanupTimer = null
+    }
+    this._sessions.clear()
+    this._framework = null
+  }
+}
+
+module.exports = { SessionPlugin }

package/plugins/shell-executor-plugin.js

@@ -0,0 +1,196 @@
+/**
+ * Shell 执行器插件
+ * 使用 child_process 执行终端命令
+ */
+
+const { Plugin } = require('../src/core/plugin-base')
+const { spawn } = require('child_process')
+const { z } = require('zod')
+
+class ShellExecutorPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'shell-executor'
+    this.version = '1.0.0'
+    this.description = 'Shell 执行器，用于运行终端命令和脚本'
+    this.priority = 15
+
+    this.config = {
+      timeout: config.timeout || 60000,
+      workingDir: config.workingDir || process.cwd()
+    }
+
+    this._framework = null
+  }
+
+  install(framework) {
+    this._framework = framework
+    return this
+  }
+
+  start(framework) {
+    // 注册 shell 工具
+    framework.registerTool({
+      name: 'shell',
+      description: '执行 Shell 命令',
+      inputSchema: z.object({
+        command: z.string().describe('要执行的命令'),
+        cwd: z.string().optional().describe('工作目录，默认为当前目录'),
+        timeout: z.number().optional().describe('超时时间（毫秒），默认 60000')
+      }),
+      execute: async (args) => {
+        const cwd = args.cwd || this.config.workingDir
+        const timeout = args.timeout || this.config.timeout
+
+        return new Promise((resolve) => {
+          const startTime = Date.now()
+          let output = ''
+          let errorOutput = ''
+
+          // 检测命令类型
+          const isWindows = process.platform === 'win32'
+          const shell = isWindows ? 'cmd.exe' : '/bin/sh'
+          const shellArg = isWindows ? '/c' : '-c'
+
+          const proc = spawn(shell, [shellArg, args.command], {
+            cwd,
+            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,
+              command: args.command,
+              cwd
+            })
+          })
+
+          proc.on('error', (err) => {
+            resolve({
+              success: false,
+              error: err.message,
+              command: args.command,
+              cwd
+            })
+          })
+
+          // 超时处理
+          setTimeout(() => {
+            if (!proc.killed) {
+              proc.kill('SIGTERM')
+              resolve({
+                success: false,
+                error: `Command timed out after ${timeout}ms`,
+                stdout: output,
+                stderr: errorOutput,
+                command: args.command,
+                cwd,
+                timedOut: true
+              })
+            }
+          }, timeout)
+        })
+      }
+    })
+
+    // 注册 PowerShell 工具 (Windows)
+    if (process.platform === 'win32') {
+      framework.registerTool({
+        name: 'powershell',
+        description: '执行 PowerShell 命令 (仅 Windows)',
+        inputSchema: z.object({
+          command: z.string().describe('要执行的 PowerShell 命令'),
+          cwd: z.string().optional().describe('工作目录'),
+          timeout: z.number().optional().describe('超时时间（毫秒）')
+        }),
+        execute: async (args) => {
+          const cwd = args.cwd || this.config.workingDir
+          const timeout = args.timeout || this.config.timeout
+
+          return new Promise((resolve) => {
+            const startTime = Date.now()
+            let output = ''
+            let errorOutput = ''
+
+            const proc = spawn('powershell.exe', ['-NoProfile', '-Command', args.command], {
+              cwd,
+              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,
+                command: args.command,
+                cwd
+              })
+            })
+
+            proc.on('error', (err) => {
+              resolve({
+                success: false,
+                error: err.message,
+                command: args.command,
+                cwd
+              })
+            })
+
+            setTimeout(() => {
+              if (!proc.killed) {
+                proc.kill('SIGTERM')
+                resolve({
+                  success: false,
+                  error: `Command timed out after ${timeout}ms`,
+                  stdout: output,
+                  stderr: errorOutput,
+                  command: args.command,
+                  cwd,
+                  timedOut: true
+                })
+              }
+            }, timeout)
+          })
+        }
+      })
+    }
+
+    return this
+  }
+
+  reload(framework) {
+    this._framework = framework
+  }
+
+  uninstall(framework) {
+    this._framework = null
+  }
+}
+
+module.exports = { ShellExecutorPlugin }