foliko 2.0.5 → 2.0.6

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');
     }
@@ -146,9 +155,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 +205,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';
@@ -250,10 +268,10 @@ class PluginManager {
       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 +360,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 +423,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;
 }