foliko 1.1.6 → 1.1.7

package/plugins/web-plugin.js

@@ -13,6 +13,46 @@ const { Hono } = require('hono')
 const fs = require('fs')
 const path = require('path')
 
+// ============================================================================
+// WebStore - 持久化 Web 配置到 .agent/data/web/
+// ============================================================================
+class WebStore {
+  constructor(persistencePath) {
+    this._persistencePath = persistencePath
+    this._ensureDir()
+  }
+
+  _ensureDir() {
+    if (!fs.existsSync(this._persistencePath)) {
+      fs.mkdirSync(this._persistencePath, { recursive: true })
+    }
+  }
+
+  _getConfigPath() {
+    return path.join(this._persistencePath, 'web-config.json')
+  }
+
+  saveConfig(data) {
+    try {
+      fs.writeFileSync(this._getConfigPath(), JSON.stringify(data, null, 2))
+    } catch (err) {
+      log.error(' 保存 Web 配置失败:', err.message)
+    }
+  }
+
+  loadConfig() {
+    try {
+      const filePath = this._getConfigPath()
+      if (fs.existsSync(filePath)) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+      }
+    } catch (err) {
+      log.error(' 加载 Web 配置失败:', err.message)
+    }
+    return null
+  }
+}
+
 class WebPlugin extends Plugin {
   constructor(config = {}) {
     super()
@@ -39,6 +79,10 @@ class WebPlugin extends Plugin {
     this._routes = []           // 路由列表
     this._webhooks = new Map()  // webhook Map: id -> {id, path, prompt, sessionId}
     this._statics = []          // 静态文件夹列表
+
+    // 持久化存储
+    this._webStore = null
+    this._persistencePath = config.persistencePath || '.agent/data/web'
   }
 
   // ==================== 生命周期 ====================
@@ -47,6 +91,12 @@ class WebPlugin extends Plugin {
     this._framework = framework
     this._registerTools()
 
+    // 初始化持久化存储
+    this._webStore = new WebStore(this._persistencePath)
+
+    // 加载已保存的配置
+    this._loadPersistedConfig()
+
     // 将 WEB_BASE_URL 注入到 framework 的元数据，供所有 agent 使用
     if (this._baseUrl && framework._mainAgent) {
       framework._mainAgent.setMetadata('WEB_BASE_URL', this._baseUrl)
@@ -61,12 +111,117 @@ class WebPlugin extends Plugin {
 
   reload(framework) {
     this._framework = framework
+
+    // 重新初始化存储并加载配置
+    this._webStore = new WebStore(this._persistencePath)
+    this._loadPersistedConfig()
+
     // 重新注入 WEB_BASE_URL
     if (this._baseUrl && framework._mainAgent) {
       framework._mainAgent.setMetadata('WEB_BASE_URL', this._baseUrl)
     }
   }
 
+  /**
+   * 加载持久化的配置并恢复路由/webhook/静态资源
+   */
+  _loadPersistedConfig() {
+    if (!this._webStore) return
+
+    const config = this._webStore.loadConfig()
+    if (!config) return
+
+    log.info(` 加载 Web 配置...`)
+
+    let hasRoutes = false
+    let hasWebhooks = false
+    let hasStatics = false
+
+    // 恢复路由
+    if (config.routes && Array.isArray(config.routes)) {
+      for (const route of config.routes) {
+        if (route.method && route.path && route.handler) {
+          this._routes.push({
+            method: route.method,
+            path: route.path,
+            handler: route.handler,
+            description: route.description || ''
+          })
+          hasRoutes = true
+          log.info(` 恢复路由: ${route.method} ${route.path}`)
+        }
+      }
+    }
+
+    // 恢复 Webhooks
+    if (config.webhooks && Array.isArray(config.webhooks)) {
+      for (const webhook of config.webhooks) {
+        if (webhook.id && webhook.path) {
+          this._webhooks.set(webhook.path, {
+            id: webhook.id,
+            path: webhook.path,
+            prompt: webhook.prompt || '处理以下 webhook 数据，返回适当的响应：',
+            awaitResponse: webhook.awaitResponse || false
+          })
+          hasWebhooks = true
+          log.info(` 恢复 Webhook: ${webhook.path}`)
+        }
+      }
+    }
+
+    // 恢复静态资源
+    if (config.statics && Array.isArray(config.statics)) {
+      for (const staticItem of config.statics) {
+        if (staticItem.urlPath && staticItem.folder) {
+          this._statics.push({
+            urlPath: staticItem.urlPath,
+            folder: staticItem.folder,
+            options: staticItem.options || { dotfiles: 'ignore', index: 'index.html' }
+          })
+          hasStatics = true
+          log.info(` 恢复静态资源: ${staticItem.urlPath} -> ${staticItem.folder}`)
+        }
+      }
+    }
+
+    // 如果有恢复的路由/webhook/静态资源，自动启动服务器
+    if ((hasRoutes || hasWebhooks || hasStatics) && !this._server) {
+      log.info(` 恢复的 Web 配置需要启动服务器...`)
+      this._startServer().catch(err => {
+        log.error(` 自动启动服务器失败:`, err.message)
+      })
+    }
+  }
+
+  /**
+   * 保存当前配置到持久化存储
+   */
+  _saveConfig() {
+    if (!this._webStore) return
+
+    const config = {
+      routes: this._routes.map(r => ({
+        method: r.method,
+        path: r.path,
+        handler: r.handler,
+        description: r.description
+      })),
+      webhooks: Array.from(this._webhooks.values()).map(w => ({
+        id: w.id,
+        path: w.path,
+        prompt: w.prompt,
+        awaitResponse: w.awaitResponse
+      })),
+      statics: this._statics.map(s => ({
+        urlPath: s.urlPath,
+        folder: s.folder,
+        options: s.options
+      }))
+    }
+
+    this._webStore.saveConfig(config)
+  }
+
   uninstall() {
     this._stopServer()
     this._framework = null
@@ -146,6 +301,37 @@ class WebPlugin extends Plugin {
       execute: async () => this._listRoutes()
     }
 
+    // 删除路由
+    this.tools.web_delete_route = {
+      name: 'web_delete_route',
+      description: '删除已注册的 HTTP 路由',
+      inputSchema: z.object({
+        method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).describe('HTTP 方法'),
+        path: z.string().describe('路由路径，如 /api/user')
+      }),
+      execute: async (args) => this._deleteRoute(args.method, args.path)
+    }
+
+    // 删除 Webhook
+    this.tools.web_delete_webhook = {
+      name: 'web_delete_webhook',
+      description: '删除已注册的 Webhook',
+      inputSchema: z.object({
+        id: z.string().describe('Webhook ID')
+      }),
+      execute: async (args) => this._deleteWebhook(args.id)
+    }
+
+    // 删除静态资源
+    this.tools.web_delete_static = {
+      name: 'web_delete_static',
+      description: '删除已注册的静态资源文件夹',
+      inputSchema: z.object({
+        urlPath: z.string().describe('URL 路径前缀，如 /public')
+      }),
+      execute: async (args) => this._deleteStatic(args.urlPath)
+    }
+
     // 发送 HTTP 请求
     this.tools.web_request = {
       name: 'web_request',
@@ -317,8 +503,14 @@ class WebPlugin extends Plugin {
     const prompt = webhook.prompt || '处理以下 webhook 数据，返回适当的响应：'
     const finalSessionId = sessionId || `web_${Date.now()}`
 
-    // 触发 webhook 接收事件
-    this._framework.emit('webhook:received', { webhook, data: webhookData, sessionId: finalSessionId })
+    // 触发 webhook 接收事件（扁平化结构）
+    this._framework.emit('webhook:received', {
+      path: webhook.path,
+      method: c.req.method,
+      query,
+      body,
+      timestamp: webhookData.timestamp
+    })
 
     // 使用子Agent处理 webhook
     const webhookAgent = this._framework.createSubAgent({
@@ -342,7 +534,14 @@ class WebPlugin extends Plugin {
         }
 
         // 触发 webhook 处理完成事件
-        this._framework.emit('webhook:processed', { webhook, data: webhookData, response: responseText, sessionId: finalSessionId })
+        this._framework.emit('webhook:processed', {
+          path: webhook.path,
+          method: c.req.method,
+          query,
+          body,
+          response: responseText,
+          timestamp: webhookData.timestamp
+        })
       }).catch(err => {
         log.error(' Webhook error:', err.message)
       })
@@ -366,7 +565,14 @@ class WebPlugin extends Plugin {
       }
 
       // 触发 webhook 处理完成事件
-      this._framework.emit('webhook:received', { webhook, data: webhookData, response: responseText, sessionId: finalSessionId })
+      this._framework.emit('webhook:processed', {
+        path: webhook.path,
+        method: c.req.method,
+        query,
+        body,
+        response: responseText,
+        timestamp: webhookData.timestamp
+      })
 
       return { success: true, message: 'Webhook processed', response: responseText }
     } catch (err) {
@@ -394,6 +600,9 @@ class WebPlugin extends Plugin {
       this._routes.push(route)
     }
 
+    // 持久化保存
+    this._saveConfig()
+
     log.info(` Route registered: ${method} ${path}`)
     return { success: true, message: `Route ${method} ${path} registered`, url: this._getUrl(path), route: { method, path, description } }
   }
@@ -414,6 +623,9 @@ class WebPlugin extends Plugin {
       awaitResponse
     })
 
+    // 持久化保存
+    this._saveConfig()
+
     log.info(` Webhook registered: ${webhookPath}`)
     return {
       success: true,
@@ -441,6 +653,9 @@ class WebPlugin extends Plugin {
       }
     })
 
+    // 持久化保存
+    this._saveConfig()
+
     log.info(` Static registered: ${normalizedPath} -> ${folder}`)
     return {
       success: true,
@@ -461,6 +676,50 @@ class WebPlugin extends Plugin {
     }
   }
 
+  async _deleteRoute(method, path) {
+    const index = this._routes.findIndex(r => r.method === method.toUpperCase() && r.path === path)
+    if (index < 0) {
+      return { success: false, error: `Route not found: ${method} ${path}` }
+    }
+
+    this._routes.splice(index, 1)
+    this._saveConfig()
+    log.info(` Route deleted: ${method} ${path}`)
+    return { success: true, message: `Route deleted: ${method} ${path}` }
+  }
+
+  async _deleteWebhook(id) {
+    let found = null
+    for (const [path, webhook] of this._webhooks.entries()) {
+      if (webhook.id === id) {
+        found = path
+        break
+      }
+    }
+
+    if (!found) {
+      return { success: false, error: `Webhook not found: ${id}` }
+    }
+
+    this._webhooks.delete(found)
+    this._saveConfig()
+    log.info(` Webhook deleted: ${found}`)
+    return { success: true, message: `Webhook deleted: ${found}` }
+  }
+
+  async _deleteStatic(urlPath) {
+    const normalizedPath = urlPath.endsWith('/') ? urlPath : urlPath + '/'
+    const index = this._statics.findIndex(s => s.urlPath === normalizedPath)
+    if (index < 0) {
+      return { success: false, error: `Static folder not found: ${urlPath}` }
+    }
+
+    this._statics.splice(index, 1)
+    this._saveConfig()
+    log.info(` Static deleted: ${normalizedPath}`)
+    return { success: true, message: `Static folder deleted: ${normalizedPath}` }
+  }
+
   // ==================== HTTP 客户端 ====================
 
   async _sendRequest(method, urlPath, body, headers) {