foliko 1.1.93 → 2.0.1

package/src/plugin/manager.js

@@ -0,0 +1,484 @@
+'use strict';
+
+/**
+ * PluginManager 插件管理器
+ * 负责插件的加载、卸载、重载、启用/禁用
+ */
+
+const { Plugin } = require('./base');
+const { logger } = require('../common/logger');
+const { PluginError, PluginNotFoundError } = require('../common/errors');
+const { safeJsonParse } = require('../utils');
+const { resolvePluginPath, scanPluginNames } = require('../utils/plugin-helpers');
+const fs = require('fs');
+const path = require('path');
+
+class PluginManager {
+  constructor(framework) {
+    this.framework = framework;
+    this._plugins = new Map();
+    this._loading = false;
+    this._bootstrapping = false;
+    this._stateFile = path.join(
+      framework?.getCwd?.() ?? process.cwd(),
+      '.foliko',
+      'data',
+      'plugins-state.json'
+    );
+    this._knownPlugins = new Set();
+
+    this._log = logger.child('plugin-manager');
+    this._eventDescriptions = new Map();
+    this._stateCache = null;
+
+    this._registerDefaultEventDescriptions();
+  }
+
+  _registerDefaultEventDescriptions() {
+    // placeholder - plugins can register event descriptions
+  }
+
+  /**
+   * 注册插件（不加载，只记录状态）
+   */
+  register(plugin, options = {}) {
+    if (!(plugin instanceof Plugin)) {
+      throw new PluginError('Plugin must be an instance of Plugin');
+    }
+
+    const savedState = this._loadState();
+    const savedEnabled = savedState[plugin.name]?.enabled;
+    const savedConfig = savedState[plugin.name]?.config;
+
+    // 恢复保存的配置
+    if (savedConfig && plugin.config && plugin.name !== 'ai') {
+      plugin.config = { ...plugin.config, ...savedConfig };
+    }
+
+    // 确定启用状态：系统插件强制启用 → state 文件记录 → 插件默认
+    let enabled;
+    if (plugin.system) {
+      enabled = true;
+    } else if (savedEnabled !== undefined) {
+      enabled = savedEnabled;
+    } else {
+      enabled = plugin.enabled !== false;
+    }
+
+    this._plugins.set(plugin.name, {
+      instance: plugin,
+      status: 'registered',
+      enabled,
+      sourcePath: plugin.sourcePath || null,
+    });
+    this._knownPlugins.add(plugin.name);
+    this._log.debug(`Plugin registered: ${plugin.name} (enabled: ${enabled})`);
+    return this;
+  }
+
+  has(name) {
+    return this._plugins.has(name);
+  }
+
+  get(name) {
+    const entry = this._plugins.get(name);
+    return entry ? entry.instance : null;
+  }
+
+  isEnabled(name) {
+    const entry = this._plugins.get(name);
+    return entry ? entry.enabled !== false : false;
+  }
+
+  getAll() {
+    return Array.from(this._plugins.values());
+  }
+
+  getNames() {
+    return Array.from(this._plugins.keys());
+  }
+
+  /**
+   * 获取所有已知插件信息（包括已加载和未加载的）
+   */
+  getAllKnown() {
+    const result = [];
+    for (const name of this._knownPlugins) {
+      const entry = this._plugins.get(name);
+      if (entry) {
+        const inst = entry.instance;
+        result.push({
+          name,
+          status: entry.status || 'registered',
+          enabled: entry.enabled !== false,
+          version: inst.version,
+          system: inst.system,
+        });
+      } else {
+        result.push({ name, status: 'known', enabled: false });
+      }
+    }
+    // 加入已加载但不在 knownPlugins 中的
+    for (const [name, entry] of this._plugins) {
+      if (!result.find(p => p.name === name)) {
+        result.push({
+          name,
+          status: entry.status || 'registered',
+          enabled: entry.enabled !== false,
+          version: entry.instance?.version,
+          system: entry.instance?.system || false,
+        });
+      }
+    }
+    return result;
+  }
+
+  count() {
+    return this._plugins.size;
+  }
+
+  /**
+   * 加载插件
+   * @param {Plugin|Object} plugin - 插件实例或类
+   * @param {Object} [options] - 加载选项
+   * @param {boolean} [options.forceEnabled] - 强制启用，忽略 state 文件的 disabled
+   */
+  async load(plugin, options = {}) {
+    let pluginInstance = plugin;
+
+    // 如果是类（Plugin 子类），实例化
+    if (typeof plugin === 'function' && plugin.prototype instanceof Plugin) {
+      pluginInstance = new plugin();
+    }
+
+    const name = pluginInstance.name;
+
+    // 已存在且已加载 → 跳过
+    const existing = this._plugins.get(name);
+    if (existing && existing.status === 'loaded' && pluginInstance._started) {
+      this._log.debug(`Plugin '${name}' already loaded, skipping`);
+      return;
+    }
+
+    // 已注册但未加载 → 检查 enabled 状态
+    if (existing) {
+      if (!existing.enabled && !options.forceEnabled) {
+        this._log.info(`Plugin '${name}' is disabled, skipping load`);
+        return;
+      }
+      pluginInstance = existing.instance;
+    } else {
+      // 未注册 → 先注册
+      this.register(pluginInstance, options);
+    }
+
+    const entry = this._plugins.get(name);
+    if (!entry.enabled && !options.forceEnabled) {
+      this._log.info(`Plugin '${name}' is disabled, skipping load`);
+      return;
+    }
+
+    // 如果 forceEnabled，覆盖 enabled 状态
+    if (options.forceEnabled) {
+      entry.enabled = true;
+      pluginInstance.enabled = true;
+    }
+
+    this._log.info(`Loading plugin: ${name}`);
+
+    if (typeof pluginInstance.install === 'function') {
+      pluginInstance.install(this.framework);
+    }
+
+    entry.status = 'loaded';
+
+    // bootstrapping 模式下不 start，由 startAll() 统一启动
+    if (!this._bootstrapping) {
+      if (typeof pluginInstance.start === 'function') {
+        await pluginInstance.start(this.framework);
+        pluginInstance._started = true;
+      }
+    }
+
+    this.framework?.emit('plugin:loaded', pluginInstance);
+    this._saveState();
+    this._log.info(`Plugin loaded: ${name}`);
+  }
+
+  async unload(name) {
+    const entry = this._plugins.get(name);
+    if (!entry) {
+      throw new PluginNotFoundError(`Plugin '${name}' not found`);
+    }
+
+    const plugin = entry.instance;
+    this._log.info(`Unloading plugin: ${name}`);
+
+    if (typeof plugin.uninstall === 'function') {
+      plugin.uninstall(this.framework);
+    }
+
+    this._plugins.delete(name);
+    return true;
+  }
+
+  async unloadExcept(keepSet) {
+    const unloaded = [];
+    for (const [name, entry] of this._plugins) {
+      if (keepSet.has(name) || (entry.instance && entry.instance.system)) continue;
+      try {
+        await this.unload(name);
+        this._plugins.delete(name);
+        unloaded.push(name);
+      } catch (err) {
+        this._log.warn(`unloadExcept: ${name} failed: ${err.message}`);
+      }
+    }
+    return unloaded;
+  }
+
+  async reload(name) {
+    const entry = this._plugins.get(name);
+    if (!entry) {
+      throw new PluginNotFoundError(`Plugin '${name}' not found`);
+    }
+
+    this._log.info(`Reloading plugin: ${name}`);
+    const plugin = entry.instance;
+
+    if (typeof plugin.reload === 'function') {
+      await plugin.reload(this.framework);
+    } else {
+      if (typeof plugin.uninstall === 'function') {
+        plugin.uninstall(this.framework);
+      }
+      if (typeof plugin.install === 'function') {
+        plugin.install(this.framework);
+      }
+      if (typeof plugin.start === 'function') {
+        await plugin.start(this.framework);
+      }
+    }
+
+    this.framework?.emit('plugin:reloaded', plugin);
+    this._log.info(`Plugin reloaded: ${name}`);
+  }
+
+  /**
+   * 启动所有已加载、已启用、未启动的插件（按优先级排序）
+   */
+  async startAll() {
+    const entries = Array.from(this._plugins.values())
+      .filter(e => e.status === 'loaded' && e.enabled)
+      .sort((a, b) => (a.instance.priority || 100) - (b.instance.priority || 100));
+
+    for (const entry of entries) {
+      const plugin = entry.instance;
+      if (plugin._started) continue;
+      if (typeof plugin.start === 'function') {
+        try {
+          await plugin.start(this.framework);
+          plugin._started = true;
+        } catch (err) {
+          this._log.warn(`startAll: ${plugin.name} failed: ${err.message}`);
+        }
+      }
+    }
+  }
+
+  /**
+   * 启用插件
+   */
+  async enable(name) {
+    const entry = this._plugins.get(name);
+    if (!entry) {
+      throw new PluginNotFoundError(name);
+    }
+    if (entry.instance?.system) {
+      throw new PluginError(`Plugin '${name}' is a system plugin, cannot be disabled/enabled`);
+    }
+    if (entry.enabled) {
+      this._log.info(`Plugin '${name}' already enabled`);
+      return;
+    }
+
+    entry.enabled = true;
+    if (entry.instance) {
+      entry.instance.enabled = true;
+    }
+
+    // 如果已加载，重新启动
+    if (entry.status === 'loaded') {
+      try {
+        // 停止旧实例
+        if (entry.instance._started) {
+          if (typeof entry.instance.stopBot === 'function') {
+            await entry.instance.stopBot();
+          } else if (typeof entry.instance.stop === 'function') {
+            await entry.instance.stop();
+          }
+        }
+
+        // 如果记录过 sourcePath，重新 require 最新代码
+        if (entry.sourcePath) {
+          delete require.cache[require.resolve(entry.sourcePath)];
+          const mod = require(entry.sourcePath);
+          let NewClass = mod.default || mod;
+          if (typeof NewClass === 'function' && NewClass.prototype instanceof Plugin) {
+            const newInstance = new NewClass();
+            newInstance._sourcePath = entry.sourcePath;
+            if (entry.instance.config) newInstance.config = { ...entry.instance.config };
+            entry.instance = newInstance;
+            await newInstance.install(this.framework);
+            await newInstance.start(this.framework);
+            newInstance._started = true;
+            this.framework?.emit('plugin:reloaded', newInstance);
+          }
+        } else {
+          // 没有 sourcePath，调用 reload
+          if (typeof entry.instance.reload === 'function') {
+            await entry.instance.reload(this.framework);
+          }
+          if (typeof entry.instance.start === 'function') {
+            await entry.instance.start(this.framework);
+          }
+          entry.instance._started = true;
+        }
+      } catch (err) {
+        this._log.error(`Enable/start failed for '${name}':`, err.message);
+      }
+    } else if (entry.status === 'registered') {
+      // 只注册过但未加载，现在加载
+      try {
+        await this.load(entry.instance);
+      } catch (err) {
+        this._log.error(`Enable/load failed for '${name}':`, err.message);
+      }
+    }
+
+    this.framework?.emit('plugin:enabled', entry.instance);
+    this._saveState();
+    this._log.info(`Plugin '${name}' enabled`);
+  }
+
+  /**
+   * 禁用插件
+   */
+  async disable(name) {
+    const entry = this._plugins.get(name);
+    if (!entry) {
+      throw new PluginNotFoundError(name);
+    }
+    if (entry.instance?.system) {
+      throw new PluginError(`Plugin '${name}' is a system plugin, cannot be disabled`);
+    }
+    if (!entry.enabled) {
+      this._log.info(`Plugin '${name}' already disabled`);
+      return;
+    }
+
+    entry.enabled = false;
+    if (entry.instance) {
+      entry.instance.enabled = false;
+    }
+
+    // 如果正在运行，停止
+    if (entry.instance._started) {
+      try {
+        if (typeof entry.instance.stopBot === 'function') {
+          await entry.instance.stopBot();
+        } else if (typeof entry.instance.stop === 'function') {
+          await entry.instance.stop();
+        }
+        entry.instance._started = false;
+      } catch (err) {
+        this._log.error(`Stop failed for '${name}':`, err.message);
+      }
+    }
+
+    this.framework?.emit('plugin:disabled', entry.instance);
+    this._saveState();
+    this._log.info(`Plugin '${name}' disabled`);
+  }
+
+  updatePluginConfig(name, config) {
+    const entry = this._plugins.get(name);
+    if (!entry) {
+      throw new PluginNotFoundError(`Plugin '${name}' not found`);
+    }
+    if (entry.instance.config) {
+      Object.assign(entry.instance.config, config);
+    }
+    this._saveState();
+  }
+
+  setBootstrapping(val) {
+    this._bootstrapping = val !== false;
+  }
+
+  // ========== 状态持久化 ==========
+
+  _getStateFile() {
+    const dir = path.dirname(this._stateFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    return this._stateFile;
+  }
+
+  _saveState() {
+    try {
+      const stateFile = this._getStateFile();
+      let state = safeJsonParse(
+        fs.existsSync(stateFile) ? fs.readFileSync(stateFile, 'utf-8') : '{}',
+        {}
+      );
+      for (const [name, entry] of this._plugins) {
+        state[name] = {
+          enabled: entry.enabled,
+          config: entry.instance?.config || {},
+        };
+      }
+      fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+      this._stateCache = state;
+    } catch (err) {
+      this._log.error('Failed to save state:', err.message);
+    }
+  }
+
+  _loadState() {
+    if (this._stateCache !== null) return this._stateCache;
+    try {
+      const stateFile = this._getStateFile();
+      if (fs.existsSync(stateFile)) {
+        this._stateCache = safeJsonParse(fs.readFileSync(stateFile, 'utf-8'), {});
+        return this._stateCache;
+      }
+    } catch (err) {
+      this._log.error('Failed to load state:', err.message);
+    }
+    this._stateCache = {};
+    return this._stateCache;
+  }
+
+  _setStateFile(cwd) {
+    this._stateFile = path.join(cwd, '.foliko', 'data', 'plugins-state.json');
+    this._stateCache = null;
+  }
+
+  // ========== 事件描述 ==========
+
+  registerEventDescription(eventType, description, schema = null) {
+    this._eventDescriptions.set(eventType, { description, schema });
+  }
+
+  getEventDescriptions() {
+    return new Map(this._eventDescriptions);
+  }
+
+  getEventDescription(eventType) {
+    return this._eventDescriptions.get(eventType) || null;
+  }
+}
+
+module.exports = { PluginManager };

package/src/{core → session}/branch-summary-auto.js

@@ -9,9 +9,9 @@ const {
   BRANCH_SUMMARY_PREAMBLE,
   BRANCH_SUMMARY_PROMPT,
   serializeConversation
-} = require('./context-compressor');
+} = require('../context/compressor');
 
-const { logger } = require('../utils/logger');
+const { logger } = require('../common/logger');
 
 class BranchSummaryAuto {
   /**

package/src/{core/chat-session.js → session/chat.js}

@@ -8,8 +8,8 @@
  * 4. SessionScope 事件作用域
  */
 
-const { EventEmitter } = require('../utils/event-emitter');
-const { logger } = require('../utils/logger');
+const { EventEmitter } = require('../common/events');
+const { logger } = require('../common/logger');
 
 /**
  * Session 作用域的事件监听器

package/src/session/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  SessionManager: require('./session').SessionManager,
+  SessionEntry: require('./entry'),
+  ChatSession: require('./chat').ChatSession,
+};

package/src/{core/session-manager.js → session/session.js}

@@ -6,7 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { JsonlSessionStorage } = require('./jsonl-storage');
+const { JsonlSessionStorage } = require('../storage/jsonl');
 const {
   EntryTypes,
   generateEntryId,
@@ -15,7 +15,7 @@ const {
   createBranchSummaryMessage,
   createCompactionSummaryMessage,
   createCustomMessage
-} = require('./session-entry');
+} = require('./entry');
 
 const CURRENT_SESSION_VERSION = 3;
 

package/src/session/ttl.js

@@ -0,0 +1,92 @@
+'use strict';
+
+/**
+ * SessionTTL - Session 过期清理管理
+ * 从 framework.js 中提取的 TTL 清理逻辑
+ */
+
+const { DEFAULT_SESSION_CLEANUP_INTERVAL_MS } = require('../common/constants');
+
+class SessionTTL {
+  /**
+   * @param {Object} options
+   * @param {Function} options.getSessionContexts - 返回 session 上下文 Map
+   * @param {Function} options.destroySession - 销毁 session 的函数
+   * @param {number} [options.ttlMs=1800000] - TTL 毫秒数，默认 30 分钟
+   * @param {number} [options.checkIntervalMs=60000] - 检查间隔，默认 60 秒
+   */
+  constructor(options = {}) {
+    this._getSessionContexts = options.getSessionContexts;
+    this._destroySession = options.destroySession;
+    this._ttlMs = options.ttlMs || 30 * 60 * 1000;
+    this._checkIntervalMs = options.checkIntervalMs || DEFAULT_SESSION_CLEANUP_INTERVAL_MS;
+    this._intervalId = null;
+    this._lastAccessMap = new Map();
+  }
+
+  /**
+   * 设置 TTL
+   */
+  setTTL(ttlMs) {
+    this._ttlMs = ttlMs;
+    return this;
+  }
+
+  /**
+   * 启动定期清理
+   */
+  start() {
+    if (this._intervalId) return;
+    this._intervalId = setInterval(() => this._cleanup(), this._checkIntervalMs);
+    this._intervalId.unref();
+    return this;
+  }
+
+  /**
+   * 停止定期清理
+   */
+  stop() {
+    if (this._intervalId) {
+      clearInterval(this._intervalId);
+      this._intervalId = null;
+    }
+    return this;
+  }
+
+  /**
+   * 标记 session 活跃（更新最后访问时间）
+   */
+  touch(sessionId) {
+    this._lastAccessMap.set(sessionId, Date.now());
+  }
+
+  /**
+   * 清理过期 session
+   */
+  _cleanup() {
+    if (!this._getSessionContexts) return;
+    const contexts = this._getSessionContexts();
+    if (!contexts || contexts.size === 0) return;
+
+    const now = Date.now();
+    for (const [sessionId] of contexts) {
+      const lastAccess = this._lastAccessMap.get(sessionId) || now;
+      if (now - lastAccess > this._ttlMs) {
+        this._lastAccessMap.delete(sessionId);
+        if (this._destroySession) {
+          this._destroySession(sessionId);
+        }
+      }
+    }
+  }
+
+  /**
+   * 销毁
+   */
+  destroy() {
+    this.stop();
+    this._lastAccessMap.clear();
+  }
+}
+
+module.exports = { SessionTTL };

package/src/{core/jsonl-storage.js → storage/jsonl.js}

@@ -6,7 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { generateEntryId, EntryTypes } = require('./session-entry');
+const { generateEntryId, EntryTypes } = require('../session/entry');
 
 const CURRENT_SESSION_VERSION = 3;