plugin-agent-orchestrator 1.0.6 → 1.0.14

package/dist/server/skill-hub/plugin.js

@@ -0,0 +1,694 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  SkillHubSubFeature: () => SkillHubSubFeature,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_path = require("path");
+var import_fs = require("fs");
+var os = __toESM(require("os"));
+var import_SandboxRunner = require("../services/SandboxRunner");
+var import_FileManager = require("../services/FileManager");
+var import_SkillManager = require("../services/SkillManager");
+var import_WorkerEnvManager = require("../services/WorkerEnvManager");
+var import_SkillExecutionTask = require("./tasks/SkillExecutionTask");
+var import_skill_execute = require("../tools/skill-execute");
+var import_McpController = require("./mcp/McpController");
+var import_SkillRepositoryService = require("../services/SkillRepositoryService");
+var import_git_import = require("./actions/git-import");
+var import_json_fields = require("./utils/json-fields");
+class RateLimiter {
+  constructor(maxExecutions = 10, windowMs = 60 * 1e3) {
+    this.maxExecutions = maxExecutions;
+    this.windowMs = windowMs;
+  }
+  userExecutions = /* @__PURE__ */ new Map();
+  /**
+   * Check if the user is allowed to execute.
+   * @returns true if allowed, false if rate limited.
+   */
+  check(userId) {
+    const now = Date.now();
+    const executions = this.userExecutions.get(userId) || [];
+    const valid = executions.filter((t) => now - t < this.windowMs);
+    this.userExecutions.set(userId, valid);
+    if (valid.length >= this.maxExecutions) {
+      return false;
+    }
+    valid.push(now);
+    return true;
+  }
+  /** Get remaining executions for a user */
+  remaining(userId) {
+    const now = Date.now();
+    const executions = (this.userExecutions.get(userId) || []).filter(
+      (t) => now - t < this.windowMs
+    );
+    return Math.max(0, this.maxExecutions - executions.length);
+  }
+  /** Periodically clean up expired entries (call from interval) */
+  cleanup() {
+    const now = Date.now();
+    for (const [userId, executions] of this.userExecutions) {
+      const valid = executions.filter((t) => now - t < this.windowMs);
+      if (valid.length === 0) {
+        this.userExecutions.delete(userId);
+      } else {
+        this.userExecutions.set(userId, valid);
+      }
+    }
+  }
+}
+class SkillHubSubFeature {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  sandboxRunner;
+  fileManager;
+  skillManager;
+  workerEnvManager;
+  cleanupInterval = null;
+  initEnvDoneCallback = null;
+  initEnvProgressCallback = null;
+  mcpController;
+  skillRepoService;
+  rateLimiter = new RateLimiter(
+    parseInt(process.env.SKILL_HUB_RATE_LIMIT_MAX || "10", 10),
+    parseInt(process.env.SKILL_HUB_RATE_LIMIT_WINDOW_MS || "60000", 10)
+  );
+  skillTemplates = /* @__PURE__ */ new Map();
+  get app() {
+    return this.plugin.app;
+  }
+  get db() {
+    return this.plugin.db;
+  }
+  get name() {
+    return this.plugin.name;
+  }
+  async load() {
+    const storagePath = (0, import_path.resolve)(process.cwd(), "storage", "plugin-skill-hub");
+    this.fileManager = new import_FileManager.FileManager(storagePath);
+    this.sandboxRunner = new import_SandboxRunner.SandboxRunner(this.fileManager, this.app.logger, storagePath);
+    this.skillManager = new import_SkillManager.SkillManager(this.db);
+    this.workerEnvManager = new import_WorkerEnvManager.WorkerEnvManager(this.app, this.db, storagePath);
+    this.skillRepoService = new import_SkillRepositoryService.SkillRepositoryService(storagePath);
+    this.mcpController = new import_McpController.McpController(this);
+    this.app.resourceManager.define({
+      name: "skillHub",
+      actions: {
+        download: this.handleDownload.bind(this),
+        test: this.handleTest.bind(this),
+        initEnv: this.handleInitEnv.bind(this),
+        clearStorage: this.handleClearStorage.bind(this),
+        mcpListTools: this.mcpController.listTools.bind(this.mcpController),
+        mcpCallTool: this.mcpController.callTool.bind(this.mcpController),
+        listTemplates: this.handleListTemplates.bind(this),
+        gitListSkills: import_git_import.gitListSkills,
+        gitSyncSkills: import_git_import.gitSyncSkills
+      }
+    });
+    this.db.on("skillExecutions.afterDestroy", async (model, options) => {
+      const execId = model.get("id");
+      try {
+        const dir = this.fileManager.getExecDir(String(execId));
+        if (require("fs").existsSync(dir)) {
+          require("fs").rmSync(dir, { recursive: true, force: true });
+        }
+      } catch (err) {
+        this.app.logger.error(`[skill-hub] Failed to cleanup physical storage for execId ${execId}`, { error: err });
+      }
+    });
+    this.db.on("skillDefinitions.afterSave", async (model, options) => {
+      if (model.changed("fileId") && model.get("fileId")) {
+        try {
+          const attachment = await this.db.getRepository("attachments").findOne({
+            filter: { id: model.get("fileId") },
+            transaction: options.transaction
+          });
+          if (attachment) {
+            const fileManager = this.app.pm.get("@nocobase/plugin-file-manager");
+            if (!fileManager) {
+              this.app.logger.warn("[skill-hub] plugin-file-manager not found, cannot extract skill package");
+              return;
+            }
+            const streamData = await fileManager.getFileStream(attachment);
+            if (!streamData || !streamData.stream) {
+              this.app.logger.warn(`[skill-hub] Could not get file stream for attachment ${attachment.get("id")}`);
+              return;
+            }
+            const tempZipPath = (0, import_path.resolve)(os.tmpdir(), `skill_${Date.now()}_${model.get("id")}.zip`);
+            await new Promise((resolvePipe, rejectPipe) => {
+              const writeStream = (0, import_fs.createWriteStream)(tempZipPath);
+              streamData.stream.pipe(writeStream);
+              writeStream.on("finish", resolvePipe);
+              writeStream.on("error", rejectPipe);
+              streamData.stream.on("error", rejectPipe);
+            });
+            if (require("fs").existsSync(tempZipPath)) {
+              const skillName = model.get("name");
+              const { metadata, instructions } = await this.skillRepoService.extractSkillPackage(skillName, tempZipPath);
+              const code = this.skillRepoService.getSkillCode(skillName);
+              const updateValues = { storageType: attachment.get("storageId") ? `storage-${attachment.get("storageId")}` : "local" };
+              if (code) updateValues.codeTemplate = code;
+              if (metadata.description) updateValues.description = metadata.description;
+              if (metadata.title) updateValues.title = metadata.title;
+              if (metadata.language) updateValues.language = metadata.language;
+              if (metadata.inputSchema) updateValues.inputSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.inputSchema, null));
+              if (metadata.interactionSchema) updateValues.interactionSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.interactionSchema, null));
+              if (metadata.packages) updateValues.packages = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.packages, []), []);
+              if (metadata.timeoutSeconds) updateValues.timeoutSeconds = metadata.timeoutSeconds;
+              if (instructions) updateValues.instructions = instructions;
+              await this.db.getRepository("skillDefinitions").update({
+                filter: { id: model.get("id") },
+                values: updateValues,
+                transaction: options.transaction
+              });
+              (0, import_fs.unlinkSync)(tempZipPath);
+              this.app.logger.info(`[skill-hub] Successfully extracted zip and updated skill: ${skillName}`);
+            }
+          }
+        } catch (err) {
+          this.app.logger.error(`[skill-hub] Failed to unpack skill zip`, { error: err });
+        }
+      }
+    });
+    this.app.pubSubManager.subscribe("skill-hub.task", async (payload) => {
+      if (process.env.SKILL_HUB_SANDBOX === "false") return;
+      await this.onQueueTask(payload);
+    });
+    this.app.pubSubManager.subscribe("skill-hub.init-env", async (payload) => {
+      if (process.env.SKILL_HUB_SANDBOX === "false") return;
+      await this.workerEnvManager.executeInit(payload);
+    });
+    this.app.on("afterStart", async () => {
+      this.registerAITools();
+      this.startCleanupInterval();
+      await this.subscribeInitEnvDone();
+      await this.skillManager.seedDefaults().catch((e) => {
+        this.app.logger.error(`[skill-hub] Failed to seed default skills: ${e.message}`);
+      });
+    });
+  }
+  async onQueueTask(message) {
+    this.app.logger.info(`[skill-hub] Worker received queue task: ${message.id}`);
+    const execution = await this.db.getRepository("skillExecutions").findOne({
+      filter: { id: message.id },
+      appends: ["skill"]
+    });
+    if (!execution) {
+      this.app.logger.warn(`[skill-hub] Task ${message.id} ignored: execution record not found.`);
+      return;
+    }
+    const task = new import_SkillExecutionTask.SkillExecutionTask(
+      execution,
+      this.sandboxRunner,
+      this.fileManager,
+      this.skillRepoService,
+      this.app
+    );
+    await task.run();
+  }
+  /**
+   * Execute skill — called by both AI tool and REST test endpoint.
+   * Dispatches to worker via EventQueue, waits for result via PubSub.
+   * Pushes progress to SSE via runtime.writer (if within AI tool context).
+   * Includes rate limiting and graceful abort propagation.
+   */
+  async executeSkill(skill, inputArgs, ctx) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const userId = (_b = (_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentUser) == null ? void 0 : _b.id;
+    if (userId) {
+      if (!this.rateLimiter.check(String(userId))) {
+        const remaining = this.rateLimiter.remaining(String(userId));
+        throw new Error(
+          `Rate limit exceeded. You can execute up to ${this.rateLimiter["maxExecutions"]} skills per minute. Remaining: ${remaining}. Please wait and try again.`
+        );
+      }
+    }
+    const execution = await this.db.getRepository("skillExecutions").create({
+      values: {
+        skillId: skill.id,
+        status: "pending",
+        inputArgs: (0, import_json_fields.stringifyJsonText)(inputArgs, {}),
+        sessionId: (_c = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c.sessionId,
+        triggeredById: (_e = (_d = ctx == null ? void 0 : ctx.state) == null ? void 0 : _d.currentUser) == null ? void 0 : _e.id
+      }
+    });
+    const execId = String(execution.id);
+    this.app.logger.info(
+      `[skill-hub] Queued execution ${execId}: skill=${skill.get ? skill.get("name") : skill.name}, user=${userId || "system"}`
+    );
+    const cleanups = [];
+    const progressChannel = `skill-hub.progress.${execId}`;
+    const doneChannel = `skill-hub.done.${execId}`;
+    const abortChannel = `skill-hub.abort.${execId}`;
+    const progressCallback = async (progress) => {
+      var _a2, _b2, _c2;
+      try {
+        (_c2 = (_a2 = ctx == null ? void 0 : ctx.runtime) == null ? void 0 : _a2.writer) == null ? void 0 : _c2.call(_a2, {
+          action: "skillProgress",
+          body: { execId, skillName: skill.name || ((_b2 = skill.get) == null ? void 0 : _b2.call(skill, "name")), ...progress }
+        });
+      } catch {
+      }
+    };
+    let result;
+    try {
+      let resolvePromise;
+      let rejectPromise;
+      const resultPromise = new Promise((resolve2, reject) => {
+        resolvePromise = resolve2;
+        rejectPromise = reject;
+      });
+      const timeoutMs = ((skill.timeoutSeconds || ((_f = skill.get) == null ? void 0 : _f.call(skill, "timeoutSeconds")) || 60) + 15) * 1e3;
+      const timeout = setTimeout(() => {
+        rejectPromise(new Error(`Skill execution timeout after ${skill.timeoutSeconds || 60}s`));
+      }, timeoutMs);
+      const doneCallback = async (data) => {
+        clearTimeout(timeout);
+        resolvePromise(data);
+      };
+      await this.app.pubSubManager.subscribe(progressChannel, progressCallback);
+      cleanups.push({ channel: progressChannel, callback: progressCallback });
+      await this.app.pubSubManager.subscribe(doneChannel, doneCallback);
+      cleanups.push({ channel: doneChannel, callback: doneCallback });
+      if (((_g = ctx == null ? void 0 : ctx.req) == null ? void 0 : _g.signal) || (ctx == null ? void 0 : ctx.signal)) {
+        const signal = ((_h = ctx.req) == null ? void 0 : _h.signal) || ctx.signal;
+        (_i = signal.addEventListener) == null ? void 0 : _i.call(signal, "abort", () => {
+          clearTimeout(timeout);
+          this.app.pubSubManager.publish(abortChannel, { reason: "user_cancel" }).catch(() => {
+          });
+          this.db.getRepository("skillExecutions").update({
+            filter: { id: execId },
+            values: { status: "canceled" }
+          }).catch(() => {
+          });
+          rejectPromise(new Error("Canceled by user"));
+        });
+      }
+      await this.app.pubSubManager.publish("skill-hub.task", { id: execId });
+      result = await resultPromise;
+    } finally {
+      for (const { channel, callback } of cleanups) {
+        try {
+          await this.app.pubSubManager.unsubscribe(channel, callback);
+        } catch {
+        }
+      }
+    }
+    const filesWithUrls = (result.files || []).map((f) => {
+      const b64name = Buffer.from(f.name).toString("base64url");
+      return {
+        ...f,
+        downloadUrl: `/api/skillHub:download?execId=${execId}&f=${b64name}`
+      };
+    });
+    return { ...result, files: filesWithUrls, execId };
+  }
+  async handleDownload(ctx, next) {
+    var _a, _b;
+    const { execId, filename, f } = ctx.action.params;
+    let targetFile = filename;
+    if (f) {
+      targetFile = Buffer.from(f, "base64url").toString("utf8");
+    }
+    if (!execId || !targetFile) {
+      ctx.throw(400, "Missing execId or filename");
+    }
+    const currentUser = (_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentUser;
+    if (!currentUser) {
+      ctx.throw(401, "Unauthorized");
+    }
+    const execution = await this.db.getRepository("skillExecutions").findOne({
+      filter: { id: execId }
+    });
+    if (!execution) {
+      ctx.throw(404, "Execution not found");
+    }
+    const isOwner = execution.triggeredById === currentUser.id;
+    const isAdmin = (_b = currentUser.roles) == null ? void 0 : _b.some((r) => r.name === "root" || r === "root" || r.name === "admin");
+    if (!isOwner && !isAdmin) {
+      ctx.throw(403, "Permission denied: you cannot view files from this execution");
+    }
+    const filePath = this.fileManager.getOutputFilePath(execId, targetFile);
+    if (!filePath) {
+      ctx.throw(404, "File not found");
+    }
+    ctx.attachment(targetFile);
+    ctx.body = (0, import_fs.createReadStream)(filePath);
+    await next();
+  }
+  async handleTest(ctx, next) {
+    const { skillId, input } = ctx.action.params.values || {};
+    if (!skillId) {
+      ctx.throw(400, "Missing skillId");
+    }
+    const skill = await this.db.getRepository("skillDefinitions").findOne({
+      filter: { id: skillId }
+    });
+    if (!skill) {
+      ctx.throw(404, "Skill not found");
+    }
+    const result = await this.executeSkill(skill, input || {}, ctx);
+    ctx.body = result;
+    await next();
+  }
+  /**
+   * Handle Init Environment request from admin UI.
+   * Dispatches init task to all workers via EventQueue.
+   */
+  async handleInitEnv(ctx, next) {
+    var _a;
+    const config = await this.workerEnvManager.getOrCreateConfig();
+    const customPackages = (0, import_json_fields.parseJsonText)(((_a = config.get) == null ? void 0 : _a.call(config, "customPackages")) ?? config.customPackages, {
+      python: [],
+      node: []
+    });
+    const message = await this.workerEnvManager.initEnvironment(
+      config.get ? {
+        npmRegistryUrl: config.get("npmRegistryUrl"),
+        npmAuthToken: config.get("npmAuthToken"),
+        pypiIndexUrl: config.get("pypiIndexUrl"),
+        pypiTrustedHost: config.get("pypiTrustedHost"),
+        aptMirrorUrl: config.get("aptMirrorUrl"),
+        aptGpgKeyUrl: config.get("aptGpgKeyUrl"),
+        customPackages
+      } : config
+    );
+    ctx.body = { message };
+    await next();
+  }
+  /**
+   * Subscribe to init-env done AND progress PubSub channels.
+   * When a worker finishes init, auto-update the DB with status.
+   */
+  async subscribeInitEnvDone() {
+    this.initEnvDoneCallback = async (data) => {
+      try {
+        const values = {
+          initStatus: data.status,
+          lastInitLog: data.log
+        };
+        if (data.status === "succeeded" && data.whitelist) {
+          values.packageWhitelist = (0, import_json_fields.stringifyJsonText)(data.whitelist, { python: [], node: [], apt: [] });
+        }
+        await this.db.getRepository("skillWorkerConfigs").update({
+          filter: {},
+          values,
+          forceUpdate: true
+        });
+        this.app.logger.info(`[skill-hub] Init env ${data.status}`);
+      } catch (err) {
+        this.app.logger.warn("[skill-hub] Failed to update init env status:", err);
+      }
+    };
+    this.initEnvProgressCallback = async (data) => {
+      try {
+        await this.db.getRepository("skillWorkerConfigs").update({
+          filter: {},
+          values: {
+            initProgressPercent: data.percent,
+            initProgressLog: data.log
+          },
+          forceUpdate: true
+        });
+      } catch (err) {
+      }
+    };
+    await this.app.pubSubManager.subscribe("skill-hub.init-env.done", this.initEnvDoneCallback);
+    await this.app.pubSubManager.subscribe("skill-hub.init-env.progress", this.initEnvProgressCallback);
+  }
+  registerAITools() {
+    var _a;
+    try {
+      const aiPlugin = this.app.pm.get("@nocobase/plugin-ai");
+      if (!((_a = aiPlugin == null ? void 0 : aiPlugin.ai) == null ? void 0 : _a.toolsManager)) {
+        this.app.logger.warn("[skill-hub] plugin-ai not available, skip AI tool registration.");
+        return;
+      }
+      aiPlugin.ai.toolsManager.registerTools((0, import_skill_execute.createSkillExecuteTool)(this));
+      aiPlugin.ai.toolsManager.registerDynamicTools(async (register) => {
+        try {
+          const skills = await this.db.getRepository("skillDefinitions").find({
+            filter: { enabled: true }
+          });
+          if (!skills || skills.length === 0) return;
+          const tools = await Promise.all(skills.map(async (skill) => {
+            const sanitizedToolName = skill.get("name").toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+            const autoCall = !!skill.get("autoCall");
+            const interactionSchema = (0, import_json_fields.parseJsonText)(skill.get("interactionSchema"), null);
+            const fullDescription = await this.getSkillDescriptionForAI(skill);
+            const baseDescription = `${fullDescription || skill.get("description")}
+Language: ${skill.get("language")}`;
+            const description = !autoCall && interactionSchema ? `${baseDescription}
+
+IMPORTANT: This skill requires human confirmation. Pass best-effort args; the user will adjust them in UI before execution.` : baseDescription;
+            return {
+              scope: "CUSTOM",
+              execution: "backend",
+              defaultPermission: autoCall ? "ALLOW" : "ASK",
+              introduction: {
+                title: `Skill Hub: ${skill.get("title")}`,
+                about: skill.get("description") || `Th\u1EF1c thi k\u1EF9 n\u0103ng ${skill.get("title")}`
+              },
+              definition: {
+                name: `skill_hub_${sanitizedToolName}`,
+                description,
+                schema: (0, import_json_fields.parseJsonText)(skill.get("inputSchema"), { type: "object", properties: {} })
+              },
+              invoke: async (toolCtx, args) => {
+                const latestSkill = await this.db.getRepository("skillDefinitions").findOne({
+                  filter: { id: skill.get("id"), enabled: true }
+                });
+                if (!latestSkill) {
+                  return { error: `Skill "${skill.get("name")}" is no longer available` };
+                }
+                const result = await this.executeSkill(latestSkill, args, toolCtx);
+                return {
+                  status: result.status === "succeeded" ? "success" : "error",
+                  result
+                  // Attach raw result
+                };
+              }
+            };
+          }));
+          register.registerTools(tools);
+        } catch (err) {
+          this.app.logger.warn("[skill-hub] Failed to provide dynamic tools", err);
+        }
+      });
+      this.app.logger.info("[skill-hub] AI tools registered (dynamic provider + general tool).");
+    } catch (error) {
+      this.app.logger.warn("[skill-hub] Failed to register AI tools:", error);
+    }
+  }
+  startCleanupInterval() {
+    const CLEANUP_INTERVAL = 60 * 60 * 1e3;
+    this.cleanupInterval = setInterval(async () => {
+      try {
+        const config = await this.db.getRepository("skillWorkerConfigs").findOne();
+        const hours = config ? config.get("retentionHours") : 24;
+        if (hours && hours > 0) {
+          const MAX_AGE_MS = hours * 60 * 60 * 1e3;
+          const cutoff = new Date(Date.now() - MAX_AGE_MS);
+          const repo = this.db.getRepository("skillExecutions");
+          const outdated = await repo.find({
+            where: { createdAt: { $lt: cutoff } }
+          });
+          if (outdated.length > 0) {
+            for (const record of outdated) {
+              await record.destroy();
+            }
+            this.app.logger.info(`[skill-hub] Auto-cleaned up ${outdated.length} expired execution records`);
+          }
+        }
+      } catch (err) {
+        this.app.logger.warn("[skill-hub] Auto Cleanup error:", err);
+      }
+      this.rateLimiter.cleanup();
+    }, CLEANUP_INTERVAL);
+  }
+  async beforeStop() {
+    if (this.initEnvDoneCallback) {
+      try {
+        await this.app.pubSubManager.unsubscribe("skill-hub.init-env.done", this.initEnvDoneCallback);
+      } catch {
+      }
+    }
+    if (this.initEnvProgressCallback) {
+      try {
+        await this.app.pubSubManager.unsubscribe("skill-hub.init-env.progress", this.initEnvProgressCallback);
+      } catch {
+      }
+    }
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  // --- Handlers ---
+  async handleClearStorage(ctx, next) {
+    const { type } = ctx.request.body || ctx.action.params.values;
+    const repo = this.db.getRepository("skillExecutions");
+    let count = 0;
+    if (type === "all") {
+      const results = await repo.find({ fields: ["id"] });
+      for (const rec of results) {
+        await rec.destroy();
+      }
+      count = results.length;
+    } else if (type === "expired") {
+      const config = await this.db.getRepository("skillWorkerConfigs").findOne();
+      const hours = config ? config.get("retentionHours") : 24;
+      if (hours > 0) {
+        const cutoff = new Date(Date.now() - hours * 60 * 60 * 1e3);
+        const results = await repo.find({ where: { createdAt: { $lt: cutoff } }, fields: ["id"] });
+        for (const rec of results) {
+          await rec.destroy();
+        }
+        count = results.length;
+      }
+    }
+    ctx.body = { count };
+    await next();
+  }
+  async handleListTemplates(ctx, next) {
+    try {
+      const allPlugins = this.app.pm.getPlugins();
+      for (const [, pluginInstance] of allPlugins) {
+        if (typeof pluginInstance.getSkillTemplates === "function") {
+          const pluginSkills = pluginInstance.getSkillTemplates();
+          if (Array.isArray(pluginSkills)) {
+            for (const s of pluginSkills) {
+              if (!this.skillTemplates.has(s.name)) {
+                this.skillTemplates.set(s.name, this.hydrateSkillTemplate(pluginInstance.name, s));
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      this.app.logger.warn(`[skill-hub] Failed to discover some plugin skills: ${e.message}`);
+    }
+    ctx.body = { data: Array.from(this.skillTemplates.values()) };
+    await next();
+  }
+  // ─── Extension API: other plugins register/unregister skills ───
+  /**
+   * Register a skill template into memory for UI importing.
+   */
+  registerSkillTemplate(pluginName, skillDef) {
+    this.skillTemplates.set(skillDef.name, this.hydrateSkillTemplate(pluginName, skillDef));
+    this.app.logger.info(`[skill-hub] Registered skill template "${skillDef.name}" from plugin "${pluginName}"`);
+  }
+  resolveSkillTemplate(templateName) {
+    if (!templateName) return null;
+    const cached = this.skillTemplates.get(templateName);
+    if (cached) return cached;
+    try {
+      const allPlugins = this.app.pm.getPlugins();
+      for (const [, pluginInstance] of allPlugins) {
+        if (typeof pluginInstance.getSkillTemplates !== "function") continue;
+        const pluginSkills = pluginInstance.getSkillTemplates();
+        if (!Array.isArray(pluginSkills)) continue;
+        const found = pluginSkills.find((s) => (s == null ? void 0 : s.name) === templateName);
+        if (found) {
+          const hydrated = this.hydrateSkillTemplate(pluginInstance.name, found);
+          this.skillTemplates.set(templateName, hydrated);
+          return hydrated;
+        }
+      }
+    } catch (e) {
+      this.app.logger.warn(`[skill-hub] Failed to resolve plugin skill "${templateName}": ${e.message}`);
+    }
+    return null;
+  }
+  async getSkillDescriptionForAI(skill) {
+    const description = skill.get ? skill.get("description") : skill.description;
+    const instructions = await this.getSkillInstructions(skill);
+    const maxInlineInstructionChars = 24e3;
+    const inlineInstructions = instructions && instructions.length > maxInlineInstructionChars ? `${instructions.slice(0, maxInlineInstructionChars)}
+
+[Instructions truncated in tool description. Call skill_hub_execute with action="describe" and this skillName to load the complete workflow.]` : instructions;
+    return [description, inlineInstructions ? `Instructions:
+${inlineInstructions}` : ""].filter(Boolean).join("\n\n");
+  }
+  async getSkillInstructions(skill) {
+    const storedInstructions = skill.get ? skill.get("instructions") : skill.instructions;
+    if (storedInstructions) return storedInstructions;
+    const storageType = skill.get ? skill.get("storageType") : skill.storageType;
+    if (storageType !== "plugin") return "";
+    const templateName = (skill.get ? skill.get("pluginSource") : skill.pluginSource) || (skill.get ? skill.get("name") : skill.name);
+    const template = this.resolveSkillTemplate(templateName);
+    return (template == null ? void 0 : template.instructions) || "";
+  }
+  hydrateSkillTemplate(pluginName, skillDef) {
+    var _a;
+    const skillName = skillDef.name;
+    const packageRoot = (_a = skillDef.skillPackage) == null ? void 0 : _a.rootDir;
+    let packageInfo = null;
+    if (packageRoot && this.skillRepoService) {
+      packageInfo = this.skillRepoService.readSkillPackage(packageRoot);
+    }
+    const metadata = (packageInfo == null ? void 0 : packageInfo.metadata) || {};
+    const packageInstructions = packageInfo == null ? void 0 : packageInfo.instructions;
+    return {
+      ...skillDef,
+      title: skillDef.title || metadata.title || skillName,
+      description: skillDef.description || metadata.description || "",
+      instructions: [skillDef.instructions, packageInstructions].filter(Boolean).join("\n\n").trim(),
+      language: skillDef.language || metadata.language || "python",
+      codeTemplate: skillDef.codeTemplate || (packageInfo == null ? void 0 : packageInfo.code) || "",
+      storageType: "plugin",
+      storageUrl: skillDef.storageUrl || `plugin://${pluginName}/${skillName}`,
+      // Keep pluginSource as the skill template name because existing DB records use it for lookup.
+      pluginSource: skillName,
+      pluginName
+    };
+  }
+  async install() {
+    await this.skillManager.seedDefaults();
+  }
+}
+var plugin_default = SkillHubSubFeature;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SkillHubSubFeature
+});