foliko 2.0.5 → 2.0.7

package/src/plugin/manager.js

@@ -42,6 +42,15 @@ class PluginManager {
    * 注册插件（不加载，只记录状态）
    */
   register(plugin, options = {}) {
+    // 处理 function(Plugin) { return class... } 格式
+    if (typeof plugin === 'function' && !(plugin instanceof Plugin)) {
+      try {
+        plugin = plugin(Plugin);
+      } catch (err) {
+        throw new PluginError(`Plugin factory function failed: ${err.message}`);
+      }
+    }
+
     if (!(plugin instanceof Plugin)) {
       throw new PluginError('Plugin must be an instance of Plugin');
     }
@@ -69,7 +78,7 @@ class PluginManager {
       instance: plugin,
       status: 'registered',
       enabled,
-      sourcePath: plugin.sourcePath || null,
+      sourcePath: this._detectPluginSourcePath(plugin, plugin.sourcePath),
     });
     this._knownPlugins.add(plugin.name);
     this._log.debug(`Plugin registered: ${plugin.name} (enabled: ${enabled})`);
@@ -80,6 +89,71 @@ class PluginManager {
     return this._plugins.has(name);
   }
 
+  /**
+   * Find the source file path for a plugin instance by scanning plugin
+   * class names in candidate directories (used as a fallback when the
+   * plugin was created directly via `new SomePlugin(...)` instead of going
+   * through `loadPluginFromPath`).
+   */
+  _detectPluginSourcePath(plugin, declared) {
+    if (declared) return declared;
+
+    // For system plugins registered in plugins/core/*, the class name often
+    // matches the on-disk filename (e.g. `WorkflowPlugin` => `index.js` of
+    // `plugins/core/workflow`, `SubAgentManagerPlugin` => `.../sub-agent/index.js`).
+    const candidates = [];
+    const fs = require('fs');
+    const path = require('path');
+    try {
+      const projectRoot = path.resolve(__dirname, '..', '..');
+      candidates.push(path.resolve(projectRoot, 'plugins'));
+    } catch (_) {}
+
+    const className =
+      (plugin.constructor && plugin.constructor.name) || plugin.name;
+    if (!className) return null;
+
+    for (const base of candidates) {
+      // exact-match: <base>/<dir>/index.js with class declared inside
+      // heuristic: walk top-level plugin dirs and look for index.js exports
+      // a class named `className`.
+      let dirs = [];
+      try {
+        dirs = fs.readdirSync(base);
+      } catch (_) {
+        continue;
+      }
+      for (const sub of dirs) {
+        const subDir = path.join(base, sub);
+        let files = [];
+        try {
+          files = fs.statSync(subDir).isDirectory()
+            ? fs.readdirSync(subDir)
+            : [path.basename(subDir)];
+          subDir = fs.statSync(subDir).isDirectory()
+            ? subDir
+            : path.dirname(subDir);
+        } catch (_) {
+          continue;
+        }
+        for (const file of files) {
+          if (!file.endsWith('.js')) continue;
+          const full = path.join(subDir, file);
+          try {
+            const src = fs.readFileSync(full, 'utf-8');
+            // Heuristic class declaration
+            if (
+              new RegExp(`class\\s+${className}\\s+extends\\s+Plugin`).test(src)
+            ) {
+              return full;
+            }
+          } catch (_) {}
+        }
+      }
+    }
+    return null;
+  }
+
   get(name) {
     const entry = this._plugins.get(name);
     return entry ? entry.instance : null;
@@ -146,9 +220,18 @@ class PluginManager {
   async load(plugin, options = {}) {
     let pluginInstance = plugin;
 
-    // 如果是类（Plugin 子类），实例化
-    if (typeof plugin === 'function' && plugin.prototype instanceof Plugin) {
-      pluginInstance = new plugin();
+    // 处理 function(Plugin) { return class... } 格式
+    if (typeof plugin === 'function') {
+      if (plugin.prototype instanceof Plugin) {
+        // Plugin 子类
+        pluginInstance = new plugin();
+      } else {
+        // Factory function
+        pluginInstance = plugin(Plugin);
+        if (pluginInstance.prototype instanceof Plugin) {
+          pluginInstance = new pluginInstance();
+        }
+      }
     }
 
     const name = pluginInstance.name;
@@ -187,7 +270,7 @@ class PluginManager {
     this._log.info(`Loading plugin: ${name}`);
 
     if (typeof pluginInstance.install === 'function') {
-      pluginInstance.install(this.framework);
+      await pluginInstance.install(this.framework);
     }
 
     entry.status = 'loaded';
@@ -246,14 +329,43 @@ class PluginManager {
     this._log.info(`Reloading plugin: ${name}`);
     const plugin = entry.instance;
 
+    // Refresh the plugin's prototype with the latest source code BEFORE invoking
+    // its reload hook. Without this, plugin.reload() still runs against the
+    // prototype cached at construction time (and Node.js' require cache means
+    // the same source file is returned on disk), so changes to plugin code
+    // (e.g., workflow/_loadWorkflows) won't take effect until the process
+    // restarts.
+    if (entry.sourcePath) {
+      try {
+        delete require.cache[require.resolve(entry.sourcePath)];
+        const mod = require(entry.sourcePath);
+        // The module may export a single class or an object map.
+        const PluginClass =
+          (mod && (mod.default || mod.WorkflowPlugin || mod)) ||
+          null;
+        if (
+          PluginClass &&
+          PluginClass.prototype &&
+          Object.getPrototypeOf(plugin) !== PluginClass.prototype
+        ) {
+          Object.setPrototypeOf(plugin, PluginClass.prototype);
+        }
+      } catch (err) {
+        this._log.warn(
+          `Failed to refresh prototype for plugin '${name}' from ${entry.sourcePath}:`,
+          err.message
+        );
+      }
+    }
+
     if (typeof plugin.reload === 'function') {
       await plugin.reload(this.framework);
     } else {
       if (typeof plugin.uninstall === 'function') {
-        plugin.uninstall(this.framework);
+        await plugin.uninstall(this.framework);
       }
       if (typeof plugin.install === 'function') {
-        plugin.install(this.framework);
+        await plugin.install(this.framework);
       }
       if (typeof plugin.start === 'function') {
         await plugin.start(this.framework);
@@ -342,10 +454,10 @@ class PluginManager {
           } else {
             // 没有 reload，走完整 uninstall + install + start
             if (typeof entry.instance.uninstall === 'function') {
-              entry.instance.uninstall(this.framework);
+              await entry.instance.uninstall(this.framework);
             }
             if (typeof entry.instance.install === 'function') {
-              entry.instance.install(this.framework);
+              await entry.instance.install(this.framework);
             }
             if (typeof entry.instance.start === 'function') {
               await entry.instance.start(this.framework);
@@ -405,6 +517,9 @@ class PluginManager {
       }
     }
 
+    // 清理该插件注册的提示词
+    entry.instance._cleanupPrompts?.();
+
     this.framework?.emit('plugin:disabled', entry.instance);
     this._saveState();
     this._log.info(`Plugin '${name}' disabled`);

package/src/tool/schema.js

@@ -13,15 +13,36 @@ const { z } = require('zod');
  * @param {boolean} [required] - Whether this schema is required (optional when false)
  * @returns {z.ZodType}
  */
+/**
+ * Convert JSON Schema to Zod schema
+ * @param {Object} jsonSchema
+ * @param {boolean} [required] - Whether the root schema is required (default true)
+ * @returns {z.ZodType}
+ */
 function jsonSchemaToZod(jsonSchema, required) {
   if (!jsonSchema || typeof jsonSchema !== 'object') {
     return z.any();
   }
 
-  return _convertSchema(jsonSchema, required);
+  // 根级默认 required=true，optional() 在对象字段级别应用
+  const isRequired = required !== false;
+  return _applyOptional(_convertSchema(jsonSchema, true), isRequired, jsonSchema);
+}
+
+/**
+ * 在对象字段构建时调用：根据 required 包装
+ */
+function _applyOptional(zodType, isRequired, schema) {
+  if (isRequired) return zodType;
+  if (schema && schema.default !== undefined) return zodType;
+  return zodType.optional();
 }
 
-function _convertSchema(schema, required = false) {
+/**
+ * 内部转换：只负责类型转换，不做 optional 包装
+ * optional 包装由调用方根据 required 参数决定
+ */
+function _convertSchema(schema, _required = true) {
   if (!schema) return z.any();
 
   let type = schema.type;
@@ -55,8 +76,10 @@ function _convertSchema(schema, required = false) {
       zodType = z.boolean();
       break;
     case 'array': {
+      // 数组项的 required 由 _required 决定（通常为 true，因为数组存在即代表"有数组"）
+      const itemRequired = _required && schema.items?.required !== false;
       if (schema.items) {
-        zodType = z.array(_convertSchema(schema.items, true));
+        zodType = z.array(_convertSchema(schema.items, itemRequired));
       } else {
         zodType = z.array(z.any());
       }
@@ -68,12 +91,14 @@ function _convertSchema(schema, required = false) {
         break;
       }
       const shape = {};
-      const req = schema.required || [];
+      const req = new Set(schema.required || []);
       for (const [key, prop] of Object.entries(schema.properties)) {
-        shape[key] = _convertSchema(prop, req.includes(key));
+        const isRequired = req.has(key);
+        // 子字段的 optional() 在这里统一包装
+        const fieldSchema = _convertSchema(prop, isRequired);
+        shape[key] = _applyOptional(fieldSchema, isRequired, prop);
       }
-      const obj = z.object(shape);
-      zodType = req.length === Object.keys(shape).length ? obj : obj.partial();
+      zodType = z.object(shape);
       break;
     }
     case 'null':
@@ -84,8 +109,6 @@ function _convertSchema(schema, required = false) {
   }
 
   if (schema.nullable) zodType = zodType.nullable();
-  if (!required && schema.default === undefined) zodType = zodType.optional();
-
   return zodType;
 }
 

package/src/utils/sandbox.js

@@ -29,7 +29,7 @@ function createSandboxContext(customContext = {}, options = {}) {
     Number: { isNaN: Number.isNaN, isFinite: Number.isFinite, parseInt: Number.parseInt, parseFloat: Number.parseFloat },
     Boolean,
     Object: { keys: Object.keys, values: Object.values, entries: Object.entries, assign: Object.assign, create: Object.create, freeze: Object.freeze },
-    Date: { now: Date.now },
+    Date,
     RegExp,
     Error,
     Promise,