plugin-agent-orchestrator 1.0.13 → 1.0.15

package/dist/server/skill-hub/actions/git-import.js

@@ -0,0 +1,413 @@
+/**
+ * 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 git_import_exports = {};
+__export(git_import_exports, {
+  gitListSkills: () => gitListSkills,
+  gitSyncSkills: () => gitSyncSkills
+});
+module.exports = __toCommonJS(git_import_exports);
+var import_fs = require("fs");
+var path = __toESM(require("path"));
+var import_json_fields = require("../utils/json-fields");
+const CODE_FILES = [
+  ["index.py", "python"],
+  ["index.js", "node"],
+  ["main.py", "python"]
+];
+async function gitListSkills(ctx, next) {
+  const { repositoryId, ref = "HEAD", prefix = "" } = ctx.action.params;
+  const rootFolder = normalizeRootFolder(ctx.action.params.rootFolder);
+  if (!repositoryId) {
+    ctx.throw(400, "repositoryId and rootFolder are required");
+  }
+  const gitPlugin = ctx.app.pm.get("plugin-git-manager");
+  if (!gitPlugin) {
+    ctx.throw(400, "plugin-git-manager is not installed");
+  }
+  try {
+    const repo = await ctx.db.getRepository("gitRepositories").findOne({ filterByTk: repositoryId });
+    if (!repo) ctx.throw(404, "Repository not found");
+    const simpleGit = require("simple-git").default;
+    const localPath = getLocalPath(repo.get("localPath"));
+    const git = simpleGit(localPath);
+    const configPath = joinGitPath(rootFolder, "skills.json");
+    const loaded = await loadSkillsManifest(git, ref, localPath, configPath);
+    let config = loaded.config;
+    let initialized = false;
+    if (!loaded.exists) {
+      const discovered = await discoverSkills(git, ref, rootFolder);
+      config = createSkillsManifest(rootFolder, discovered);
+      initialized = initSkillsManifestFile(localPath, configPath, config);
+    }
+    const manifestSkills = Array.isArray(config.skills) ? config.skills.filter((skill) => getSkillKey(skill)) : [];
+    const enriched = manifestSkills.map((skill) => enrichListedSkill(skill, prefix));
+    const existingSkills = enriched.length ? await ctx.db.getRepository("skillDefinitions").find({
+      filter: { name: { $in: enriched.map((s) => s.name) } },
+      fields: ["name"]
+    }) : [];
+    const existingNames = new Set(existingSkills.map((s) => s.get("name")));
+    ctx.body = {
+      data: enriched.map((s) => ({
+        ...s,
+        existsInDb: existingNames.has(s.name)
+      })),
+      config: {
+        name: config.name || rootFolder || "skills",
+        description: config.description || "",
+        rootFolder,
+        path: configPath,
+        initializedSkillsJson: initialized
+      }
+    };
+    await next();
+  } catch (err) {
+    ctx.throw(400, err.message);
+  }
+}
+async function gitSyncSkills(ctx, next) {
+  const { repositoryId, ref = "HEAD" } = ctx.action.params;
+  const rootFolder = normalizeRootFolder(ctx.action.params.rootFolder);
+  const { skills: selectedKeys, overwrite = false, prefix = "" } = ctx.action.params.values || ctx.action.params;
+  if (!repositoryId || !Array.isArray(selectedKeys) || selectedKeys.length === 0) {
+    ctx.throw(400, "repositoryId, rootFolder and skills[] are required");
+  }
+  const repo = await ctx.db.getRepository("gitRepositories").findOne({ filterByTk: repositoryId });
+  if (!repo) ctx.throw(404, "Repository not found");
+  const simpleGit = require("simple-git").default;
+  const localPath = getLocalPath(repo.get("localPath"));
+  const git = simpleGit(localPath);
+  const configPath = joinGitPath(rootFolder, "skills.json");
+  const loaded = await loadSkillsManifest(git, ref, localPath, configPath);
+  let config = loaded.config;
+  if (!loaded.exists) {
+    const discovered = await discoverSkills(git, ref, rootFolder);
+    config = createSkillsManifest(rootFolder, discovered);
+    initSkillsManifestFile(localPath, configPath, config);
+  }
+  const manifest = /* @__PURE__ */ new Map();
+  for (const entry of config.skills || []) {
+    const key = getSkillKey(entry);
+    if (key) {
+      manifest.set(key, entry);
+    }
+  }
+  const results = [];
+  const skillRepo = ctx.db.getRepository("skillDefinitions");
+  for (const key of selectedKeys) {
+    const meta = manifest.get(key) || { folder: key, name: key };
+    const isPluginSkill = isPluginStorage(meta);
+    const rawName = meta.name || meta.pluginSource || meta.folder || key;
+    const skillName = `${prefix}${rawName}`;
+    const skillsSubDir = meta.folder ? joinGitPath(rootFolder, "skills", meta.folder) : "";
+    const skillBaseDir = skillsSubDir || rootFolder;
+    try {
+      let frontmatter = {};
+      let instructions = "";
+      if (skillBaseDir || !meta.folder) {
+        try {
+          const skillMd = await git.show([`${ref}:${joinGitPath(skillBaseDir, "SKILL.md")}`]);
+          const parsed = (0, import_json_fields.parseSkillMarkdown)(skillMd);
+          frontmatter = parsed.metadata;
+          instructions = parsed.body;
+          const otherMds = await fetchAllMarkdownInFolder(git, ref, skillBaseDir);
+          if (otherMds) instructions += otherMds;
+        } catch {
+        }
+      }
+      const storageType = normalizeStorageType(
+        frontmatter.storageType || meta.storageType || (isPluginSkill ? "plugin" : "git")
+      );
+      const pluginSource = frontmatter.pluginSource || meta.pluginSource || (storageType === "plugin" ? rawName : void 0);
+      let detectedLanguage = frontmatter.language || meta.language || "python";
+      let codeTemplate = frontmatter.codeTemplate || meta.codeTemplate || "";
+      if (!codeTemplate && meta.codeFile) {
+        codeTemplate = await readOptionalGitFile(git, ref, joinGitPath(skillBaseDir, meta.codeFile));
+      }
+      if (!codeTemplate && storageType !== "plugin") {
+        const codeFile = await readConventionalCodeFile(git, ref, skillBaseDir);
+        if (codeFile) {
+          codeTemplate = codeFile.content;
+          detectedLanguage = codeFile.language;
+        }
+      }
+      const merged = {
+        name: skillName,
+        title: frontmatter.title || meta.title || rawName,
+        description: frontmatter.description || meta.description || "",
+        language: detectedLanguage,
+        storageType,
+        storageUrl: storageType === "plugin" ? `git://${repositoryId}/${rootFolder || ""}@${ref}#${pluginSource || rawName}` : `git://${repositoryId}/${skillsSubDir || rootFolder || ""}@${ref}`,
+        timeoutSeconds: parseInteger(frontmatter.timeoutSeconds ?? meta.timeoutSeconds, 60),
+        maxOutputSizeMb: parseInteger(frontmatter.maxOutputSizeMb ?? meta.maxOutputSizeMb, 50),
+        toolScope: frontmatter.toolScope || meta.toolScope || "CUSTOM",
+        enabled: parseBoolean(frontmatter.enabled ?? meta.enabled, true),
+        autoCall: parseBoolean(frontmatter.autoCall ?? meta.autoCall, false),
+        packages: (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(meta.packages ?? frontmatter.packages, []), [])
+      };
+      if (codeTemplate) {
+        merged.codeTemplate = codeTemplate;
+      }
+      if (pluginSource) {
+        merged.pluginSource = pluginSource;
+      }
+      if (instructions) {
+        merged.instructions = instructions.trim();
+      }
+      const inputSchema = (0, import_json_fields.parseJsonLike)(frontmatter.inputSchema ?? meta.inputSchema, null);
+      if (inputSchema) {
+        merged.inputSchema = (0, import_json_fields.stringifyJsonText)(inputSchema);
+      }
+      const interactionSchema = (0, import_json_fields.parseJsonLike)(frontmatter.interactionSchema ?? meta.interactionSchema, null);
+      if (interactionSchema) {
+        merged.interactionSchema = (0, import_json_fields.stringifyJsonText)(interactionSchema);
+      }
+      const existing = await skillRepo.findOne({ filter: { name: skillName } });
+      if (existing && !overwrite) {
+        results.push({ folder: key, name: skillName, status: "skipped", reason: "Already exists" });
+        continue;
+      }
+      if (existing) {
+        await skillRepo.update({ filterByTk: existing.get("id"), values: merged });
+        results.push({ folder: key, name: skillName, status: "updated" });
+      } else {
+        await skillRepo.create({ values: merged });
+        results.push({ folder: key, name: skillName, status: "created" });
+      }
+    } catch (err) {
+      results.push({ folder: key, name: skillName, status: "error", reason: err.message });
+    }
+  }
+  ctx.body = { data: results };
+  await next();
+}
+async function loadSkillsManifest(git, ref, localPath, configPath) {
+  let raw = null;
+  try {
+    raw = await git.show([`${ref}:${configPath}`]);
+  } catch {
+    const filePath = resolveRepoFile(localPath, configPath);
+    if ((0, import_fs.existsSync)(filePath)) {
+      raw = (0, import_fs.readFileSync)(filePath, "utf8");
+    }
+  }
+  if (!raw) {
+    return { exists: false, config: {} };
+  }
+  try {
+    return { exists: true, config: JSON.parse(raw) };
+  } catch (err) {
+    throw new Error(`Invalid ${configPath}: ${err.message}`);
+  }
+}
+async function discoverSkills(git, ref, rootFolder) {
+  const folderSkills = await discoverSkillFolders(git, ref, rootFolder);
+  if (folderSkills.length > 0) {
+    return folderSkills;
+  }
+  const pluginSkill = await discoverPluginSkill(git, ref, rootFolder);
+  return pluginSkill ? [pluginSkill] : [];
+}
+async function discoverSkillFolders(git, ref, rootFolder) {
+  const baseDir = joinGitPath(rootFolder, "skills");
+  try {
+    const dirs = await git.raw(["ls-tree", "-d", "--name-only", `${ref}:${baseDir}/`]);
+    return dirs.trim().split("\n").filter(Boolean).map((folder) => ({
+      folder,
+      name: folder,
+      title: folder,
+      storageType: "git"
+    }));
+  } catch {
+    return [];
+  }
+}
+async function discoverPluginSkill(git, ref, rootFolder) {
+  const packageJsonPath = joinGitPath(rootFolder, "package.json");
+  let packageJson;
+  try {
+    packageJson = JSON.parse(await git.show([`${ref}:${packageJsonPath}`]));
+  } catch {
+    return null;
+  }
+  const definition = await readOptionalGitFile(git, ref, joinGitPath(rootFolder, "src/server/skill-definition.ts")) || await readOptionalGitFile(git, ref, joinGitPath(rootFolder, "src/server/skill-definition.js"));
+  const templateName = definition ? extractStringProperty(definition, "name") : null;
+  const title = definition ? extractStringProperty(definition, "title") : null;
+  const language = definition ? extractStringProperty(definition, "language") : null;
+  const pluginSource = templateName || packageJson.name;
+  if (!pluginSource) {
+    return null;
+  }
+  return {
+    name: pluginSource,
+    title: title || packageJson.displayName || packageJson.name || pluginSource,
+    description: packageJson.description || "",
+    language: language || "python",
+    storageType: "plugin",
+    pluginSource
+  };
+}
+function createSkillsManifest(rootFolder, skills) {
+  return {
+    name: rootFolder || "skills",
+    description: "",
+    initializedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    skills
+  };
+}
+function initSkillsManifestFile(localPath, configPath, config) {
+  const filePath = resolveRepoFile(localPath, configPath);
+  if ((0, import_fs.existsSync)(filePath)) {
+    return false;
+  }
+  (0, import_fs.mkdirSync)(path.dirname(filePath), { recursive: true });
+  (0, import_fs.writeFileSync)(filePath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return true;
+}
+async function readConventionalCodeFile(git, ref, skillsSubDir) {
+  for (const [file, language] of CODE_FILES) {
+    const content = await readOptionalGitFile(git, ref, joinGitPath(skillsSubDir, file));
+    if (content) {
+      return { content, language };
+    }
+  }
+  return null;
+}
+async function readOptionalGitFile(git, ref, filePath) {
+  try {
+    return await git.show([`${ref}:${filePath}`]);
+  } catch {
+    return "";
+  }
+}
+function enrichListedSkill(skill, prefix) {
+  const rawName = skill.name || skill.pluginSource || skill.folder || "";
+  const finalName = `${prefix}${rawName}`;
+  return {
+    folder: getSkillKey(skill),
+    name: finalName,
+    title: skill.title || rawName,
+    description: skill.description || "",
+    language: skill.language || "python",
+    storageType: normalizeStorageType(skill.storageType || (skill.pluginSource ? "plugin" : "git")),
+    pluginSource: skill.pluginSource,
+    ...skill.timeoutSeconds ? { timeoutSeconds: skill.timeoutSeconds } : {},
+    ...skill.maxOutputSizeMb ? { maxOutputSizeMb: skill.maxOutputSizeMb } : {},
+    ...skill.packages ? { packages: skill.packages } : {},
+    ...skill.inputSchema ? { inputSchema: skill.inputSchema } : {},
+    ...skill.toolScope ? { toolScope: skill.toolScope } : {}
+  };
+}
+function getSkillKey(skill) {
+  return String(skill.folder || skill.name || skill.pluginSource || "").trim();
+}
+function isPluginStorage(skill) {
+  return normalizeStorageType(skill.storageType) === "plugin" || !!skill.pluginSource;
+}
+function normalizeStorageType(storageType) {
+  const value = typeof storageType === "string" ? storageType.toLowerCase() : "";
+  if (value === "plugin") return "plugin";
+  if (value === "local") return "local";
+  if (value === "database") return "database";
+  return "git";
+}
+function parseInteger(value, fallback) {
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function parseBoolean(value, fallback) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return !["false", "0", "no"].includes(value.toLowerCase());
+  return Boolean(value);
+}
+function extractStringProperty(source, property) {
+  const match = source.match(new RegExp(`${property}\\s*:\\s*(['"\`])([\\s\\S]*?)\\1`));
+  return match ? match[2] : null;
+}
+function normalizeRootFolder(rootFolder) {
+  if (rootFolder === void 0 || rootFolder === null) {
+    throw new Error("repositoryId and rootFolder are required");
+  }
+  const normalized = String(rootFolder).replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (normalized.includes("..") || normalized.includes("\0")) {
+    throw new Error("Invalid rootFolder");
+  }
+  return normalized;
+}
+function joinGitPath(...parts) {
+  return parts.filter((part) => part !== void 0 && part !== "").join("/").replace(/\/+/g, "/");
+}
+function resolveRepoFile(localPath, gitPath) {
+  const basePath = path.resolve(localPath);
+  const resolved = path.resolve(basePath, ...gitPath.split("/").filter(Boolean));
+  if (resolved !== basePath && !resolved.startsWith(basePath + path.sep)) {
+    throw new Error("Invalid file path");
+  }
+  return resolved;
+}
+function getLocalPath(localPath) {
+  const basePath = process.env.GIT_REPOS_BASE_PATH || path.join(process.cwd(), "storage", "git-repos");
+  if (path.isAbsolute(localPath)) return localPath;
+  return path.resolve(basePath, localPath);
+}
+async function fetchAllMarkdownInFolder(git, ref, folderPath) {
+  let combined = "";
+  try {
+    const filesOut = await git.raw(["ls-tree", "-r", "--name-only", `${ref}:${folderPath}/`]);
+    const files = filesOut.trim().split("\n").filter(Boolean);
+    for (const file of files) {
+      if (file.toLowerCase().endsWith(".md") && file.toUpperCase() !== "SKILL.md") {
+        const content = await readOptionalGitFile(git, ref, joinGitPath(folderPath, file));
+        if (content) {
+          combined += `
+
+--- Content from ${file} ---
+
+${content}`;
+        }
+      }
+    }
+  } catch (err) {
+  }
+  return combined;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gitListSkills,
+  gitSyncSkills
+});

package/dist/server/skill-hub/mcp/McpController.d.ts

@@ -0,0 +1,15 @@
+import type PluginSkillHubServer from '../plugin';
+export declare class McpController {
+    private plugin;
+    constructor(plugin: PluginSkillHubServer);
+    /**
+     * List all enabled skills in standard MCP format.
+     * Route: GET /api/skillHub:mcpListTools
+     */
+    listTools(ctx: any, next: any): Promise<void>;
+    /**
+     * Execute a skill in standard MCP format.
+     * Route: POST /api/skillHub:mcpCallTool
+     */
+    callTool(ctx: any, next: any): Promise<void>;
+}

package/dist/server/skill-hub/mcp/McpController.js

@@ -0,0 +1,111 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var McpController_exports = {};
+__export(McpController_exports, {
+  McpController: () => McpController
+});
+module.exports = __toCommonJS(McpController_exports);
+var import_json_fields = require("../utils/json-fields");
+class McpController {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  /**
+   * List all enabled skills in standard MCP format.
+   * Route: GET /api/skillHub:mcpListTools
+   */
+  async listTools(ctx, next) {
+    const skills = await this.plugin.db.getRepository("skillDefinitions").find({
+      filter: { enabled: true }
+    });
+    const tools = await Promise.all(skills.map(async (skill) => ({
+      name: skill.get("name").toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_"),
+      description: typeof this.plugin.getSkillDescriptionForAI === "function" ? await this.plugin.getSkillDescriptionForAI(skill) : skill.get("description"),
+      inputSchema: (0, import_json_fields.parseJsonText)(skill.get("inputSchema"), null)
+    })));
+    ctx.body = {
+      tools
+    };
+    await next();
+  }
+  /**
+   * Execute a skill in standard MCP format.
+   * Route: POST /api/skillHub:mcpCallTool
+   */
+  async callTool(ctx, next) {
+    var _a;
+    const { name, arguments: args } = ctx.request.body || {};
+    if (!name) {
+      ctx.throw(400, "Missing tool name");
+    }
+    const skills = await this.plugin.db.getRepository("skillDefinitions").find({
+      filter: { enabled: true }
+    });
+    const skill = skills.find(
+      (s) => s.get("name").toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_") === name
+    );
+    if (!skill) {
+      ctx.throw(404, `Tool ${name} not found`);
+    }
+    try {
+      const result = await this.plugin.executeSkill(skill, args || {}, ctx);
+      let textContent = `Executed successfully.`;
+      if (result.stdout) textContent += `
+Output:
+${result.stdout}`;
+      if (result.stderr) textContent += `
+Errors:
+${result.stderr}`;
+      if ((_a = result.files) == null ? void 0 : _a.length) {
+        textContent += `
+Files generated:
+` + result.files.map((f) => {
+          return `- [${f.name}](${f.downloadUrl})`;
+        }).join("\n");
+      }
+      ctx.body = {
+        content: [
+          {
+            type: "text",
+            text: textContent
+          }
+        ],
+        isError: result.status !== "succeeded"
+      };
+    } catch (err) {
+      ctx.body = {
+        content: [{ type: "text", text: `Skill Execution Error: ${err.message}` }],
+        isError: true
+      };
+    }
+    await next();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  McpController
+});

package/dist/server/skill-hub/plugin.d.ts

@@ -0,0 +1,58 @@
+import { SandboxRunner } from '../services/SandboxRunner';
+import { FileManager } from '../services/FileManager';
+import { SkillManager } from '../services/SkillManager';
+import { WorkerEnvManager } from '../services/WorkerEnvManager';
+export declare class SkillHubSubFeature {
+    private plugin;
+    sandboxRunner: SandboxRunner;
+    fileManager: FileManager;
+    skillManager: SkillManager;
+    workerEnvManager: WorkerEnvManager;
+    private cleanupInterval;
+    private initEnvDoneCallback;
+    private initEnvProgressCallback;
+    private mcpController;
+    private skillRepoService;
+    private rateLimiter;
+    private skillTemplates;
+    constructor(plugin: any);
+    get app(): any;
+    get db(): any;
+    get name(): any;
+    load(): Promise<void>;
+    private onQueueTask;
+    /**
+     * 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.
+     */
+    executeSkill(skill: any, inputArgs: Record<string, any>, ctx?: any): Promise<any>;
+    private handleDownload;
+    private handleTest;
+    /**
+     * Handle Init Environment request from admin UI.
+     * Dispatches init task to all workers via EventQueue.
+     */
+    private handleInitEnv;
+    /**
+     * Subscribe to init-env done AND progress PubSub channels.
+     * When a worker finishes init, auto-update the DB with status.
+     */
+    private subscribeInitEnvDone;
+    private registerAITools;
+    private startCleanupInterval;
+    beforeStop(): Promise<void>;
+    private handleClearStorage;
+    private handleListTemplates;
+    /**
+     * Register a skill template into memory for UI importing.
+     */
+    registerSkillTemplate(pluginName: string, skillDef: any): void;
+    resolveSkillTemplate(templateName: string): any;
+    getSkillDescriptionForAI(skill: any): Promise<string>;
+    getSkillInstructions(skill: any): Promise<any>;
+    private hydrateSkillTemplate;
+    install(): Promise<void>;
+}
+export default SkillHubSubFeature;