plugin-agent-orchestrator 1.0.13 → 1.0.15

package/dist/server/skill-hub/sandbox-config.json

@@ -0,0 +1,6 @@
+{
+  "verifyPackages": [
+    "xlsx",
+    "dayjs"
+  ]
+}

package/dist/server/skill-hub/tasks/SkillExecutionTask.d.ts

@@ -0,0 +1,16 @@
+import Application from '@nocobase/server';
+import { SandboxRunner } from '../../services/SandboxRunner';
+import { FileManager } from '../../services/FileManager';
+import { SkillRepositoryService } from '../../services/SkillRepositoryService';
+export declare class SkillExecutionTask {
+    private execution;
+    private sandboxRunner;
+    private fileManager;
+    private skillRepoService;
+    private app;
+    constructor(execution: any, sandboxRunner: SandboxRunner, fileManager: FileManager, skillRepoService: SkillRepositoryService, app: Application);
+    run(): Promise<void>;
+    private renderTemplate;
+    private installGeneratedSkillIfRequested;
+    private validateGeneratedSkillPackages;
+}

package/dist/server/skill-hub/tasks/SkillExecutionTask.js

@@ -0,0 +1,389 @@
+/**
+ * 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 SkillExecutionTask_exports = {};
+__export(SkillExecutionTask_exports, {
+  SkillExecutionTask: () => SkillExecutionTask
+});
+module.exports = __toCommonJS(SkillExecutionTask_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_CodeValidator = require("../../services/CodeValidator");
+var import_json_fields = require("../utils/json-fields");
+class TaskAbortController {
+  listeners = [];
+  _aborted = false;
+  get aborted() {
+    return this._aborted;
+  }
+  get signal() {
+    return {
+      addEventListener: (_event, listener) => {
+        if (this._aborted) {
+          listener();
+        } else {
+          this.listeners.push(listener);
+        }
+      }
+    };
+  }
+  abort() {
+    if (this._aborted) return;
+    this._aborted = true;
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+    this.listeners = [];
+  }
+}
+class SkillExecutionTask {
+  constructor(execution, sandboxRunner, fileManager, skillRepoService, app) {
+    this.execution = execution;
+    this.sandboxRunner = sandboxRunner;
+    this.fileManager = fileManager;
+    this.skillRepoService = skillRepoService;
+    this.app = app;
+  }
+  async run() {
+    var _a, _b, _c, _d, _e;
+    const skill = this.execution.get("skill") || this.execution.skill;
+    const execId = String(this.execution.get("id"));
+    await this.execution.update({ status: "running" });
+    const abortController = new TaskAbortController();
+    const abortChannel = `skill-hub.abort.${execId}`;
+    const abortCallback = async () => {
+      this.app.logger.info(`[skill-hub] Task ${execId}: received abort signal`);
+      abortController.abort();
+    };
+    try {
+      await this.app.pubSubManager.subscribe(abortChannel, abortCallback);
+      const inputArgs = (0, import_json_fields.parseJsonText)(this.execution.get("inputArgs"), {});
+      const storageType = skill.get ? skill.get("storageType") : skill.storageType;
+      let rawCodeTemplate = skill.get ? skill.get("codeTemplate") : skill.codeTemplate;
+      let language = skill.get ? skill.get("language") : skill.language;
+      let timeoutSeconds = skill.get ? skill.get("timeoutSeconds") : skill.timeoutSeconds;
+      let maxOutputSizeMb = skill.get ? skill.get("maxOutputSizeMb") : skill.maxOutputSizeMb;
+      const skillName = skill.get ? skill.get("name") : skill.name;
+      const workDir = this.fileManager.createExecDir(execId);
+      let skillDir;
+      if (storageType === "plugin") {
+        const pluginSkillName = (skill.get ? skill.get("pluginSource") : skill.pluginSource) || skillName;
+        const orchestratorPlugin = this.app.pm.get("plugin-agent-orchestrator");
+        const skillHub = orchestratorPlugin == null ? void 0 : orchestratorPlugin.skillHub;
+        let pluginTemplate = typeof (skillHub == null ? void 0 : skillHub.resolveSkillTemplate) === "function" ? skillHub.resolveSkillTemplate(pluginSkillName) : (_a = skillHub == null ? void 0 : skillHub.skillTemplates) == null ? void 0 : _a.get(pluginSkillName);
+        if (!pluginTemplate && skillHub) {
+          const allPlugins = this.app.pm.getPlugins();
+          for (const [, pInstance] of allPlugins) {
+            if (typeof pInstance.getSkillTemplates === "function") {
+              const pluginSkills = pInstance.getSkillTemplates();
+              if (Array.isArray(pluginSkills)) {
+                for (const s of pluginSkills) {
+                  if (s.name === pluginSkillName) {
+                    pluginTemplate = typeof (skillHub == null ? void 0 : skillHub.hydrateSkillTemplate) === "function" ? skillHub.hydrateSkillTemplate(pInstance.name, s) : { ...s, pluginSource: s.name, pluginName: pInstance.name };
+                    skillHub.skillTemplates.set(s.name, pluginTemplate);
+                    break;
+                  }
+                }
+              }
+            }
+            if (pluginTemplate) break;
+          }
+        }
+        if (pluginTemplate) {
+          rawCodeTemplate = pluginTemplate.codeTemplate;
+          language = pluginTemplate.language;
+          if (pluginTemplate.timeoutSeconds) timeoutSeconds = pluginTemplate.timeoutSeconds;
+          if (pluginTemplate.maxOutputSizeMb) maxOutputSizeMb = pluginTemplate.maxOutputSizeMb;
+          const packageRoot = (_b = pluginTemplate.skillPackage) == null ? void 0 : _b.rootDir;
+          if (packageRoot) {
+            const mountMode = ((_c = pluginTemplate.skillPackage) == null ? void 0 : _c.mountMode) || "reference";
+            if (mountMode === "copy") {
+              skillDir = (0, import_path.resolve)(workDir, "skill");
+              this.skillRepoService.copyDirectoryTo(packageRoot, skillDir);
+            } else {
+              skillDir = packageRoot;
+            }
+          }
+        } else {
+          throw new Error(`Plugin skill "${pluginSkillName}" not found. Is the parent plugin enabled?`);
+        }
+      }
+      if (!rawCodeTemplate) {
+        throw new Error(
+          `Skill "${skillName}" has no codeTemplate. Add a code file, inline codeTemplate, or bind it to an installed plugin skill.`
+        );
+      }
+      if (storageType !== "plugin") {
+        skillDir = workDir;
+      }
+      const code = this.renderTemplate(rawCodeTemplate, inputArgs, execId, skillDir);
+      await this.execution.update({ executedCode: code });
+      let packageWhitelist = [];
+      try {
+        const workerConfig = await this.app.db.getRepository("skillWorkerConfigs").findOne();
+        if (workerConfig) {
+          const wl = (0, import_json_fields.parseJsonText)(
+            workerConfig.get ? workerConfig.get("packageWhitelist") : workerConfig.packageWhitelist,
+            { python: [], node: [], apt: [] }
+          );
+          if (wl) {
+            packageWhitelist = (language === "node" ? wl.node : wl.python) || [];
+          }
+        }
+      } catch {
+      }
+      const fileId = skill.get ? skill.get("fileId") : skill.fileId;
+      if (!require("fs").existsSync(this.skillRepoService.getSkillPath(skillName)) && fileId) {
+        const fmPlugin = this.app.pm.get("@nocobase/plugin-file-manager");
+        const attachment = await this.app.db.getRepository("attachments").findOne({ filter: { id: fileId } });
+        if (fmPlugin && attachment) {
+          try {
+            const streamData = await fmPlugin.getFileStream(attachment);
+            if (streamData == null ? void 0 : streamData.stream) {
+              const tempZipPath = require("path").resolve(require("os").tmpdir(), `skill_${Date.now()}_exec.zip`);
+              await new Promise((resolve2, reject) => {
+                const writeStream = require("fs").createWriteStream(tempZipPath);
+                streamData.stream.pipe(writeStream);
+                writeStream.on("finish", resolve2);
+                writeStream.on("error", reject);
+                streamData.stream.on("error", reject);
+              });
+              await this.skillRepoService.extractSkillPackage(skillName, tempZipPath);
+              require("fs").unlinkSync(tempZipPath);
+              this.app.logger.info(
+                `[skill-hub] Task ${execId}: Auto-restored skill package ${skillName} from S3/Storage`
+              );
+            }
+          } catch (fetchErr) {
+            this.app.logger.warn(
+              `[skill-hub] Task ${execId}: Failed to fetch skill package ${skillName} from storage`,
+              { error: fetchErr }
+            );
+          }
+        }
+      }
+      if (storageType !== "plugin") {
+        this.skillRepoService.copySkillPackageTo(skillName, workDir);
+        skillDir = workDir;
+      }
+      const result = await this.sandboxRunner.execute({
+        language,
+        code,
+        execId,
+        timeoutSeconds: timeoutSeconds || 60,
+        maxOutputSizeMb: maxOutputSizeMb || 50,
+        skillDir,
+        signal: abortController.signal,
+        packageWhitelist,
+        onProgress: (progress) => {
+          this.app.pubSubManager.publish(`skill-hub.progress.${execId}`, progress);
+        }
+      });
+      if (result.success) {
+        const installMessage = await this.installGeneratedSkillIfRequested(execId);
+        if (installMessage) {
+          result.stdout = [result.stdout, installMessage].filter(Boolean).join("\n");
+        }
+      }
+      let status;
+      if (result.canceled) {
+        status = "canceled";
+      } else if (result.timedOut) {
+        status = "timeout";
+      } else {
+        status = result.success ? "succeeded" : "failed";
+      }
+      await this.execution.update({
+        status,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        outputFiles: (0, import_json_fields.stringifyJsonText)(result.files, []),
+        durationMs: result.durationMs
+      });
+      await this.app.pubSubManager.publish(`skill-hub.done.${execId}`, {
+        status,
+        stdout: (_d = result.stdout) == null ? void 0 : _d.slice(0, 3e3),
+        stderr: (_e = result.stderr) == null ? void 0 : _e.slice(0, 1e3),
+        files: result.files,
+        durationMs: result.durationMs
+      });
+      this.app.logger.info(
+        `[skill-hub] Execution ${execId} ${status}: skill=${skill.get ? skill.get("name") : skill.name}, language=${language}, duration=${result.durationMs}ms, files=${result.files.length}, outputSize=${this.fileManager.getTotalOutputSize(execId)}bytes`
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      await this.execution.update({
+        status: "failed",
+        stderr: errorMessage
+      });
+      await this.app.pubSubManager.publish(`skill-hub.done.${execId}`, {
+        status: "failed",
+        stderr: errorMessage,
+        files: [],
+        durationMs: 0
+      });
+      this.app.logger.error(`[skill-hub] Execution ${execId} error: ${errorMessage}`);
+    } finally {
+      try {
+        await this.app.pubSubManager.unsubscribe(abortChannel, abortCallback);
+      } catch {
+      }
+    }
+  }
+  renderTemplate(template, args, execId, skillDir) {
+    let code = template;
+    for (const [key, value] of Object.entries(args)) {
+      const serialized = typeof value === "string" ? value : JSON.stringify(value);
+      code = code.replaceAll(`{{${key}}}`, serialized);
+      const b64 = Buffer.from(serialized, "utf-8").toString("base64");
+      code = code.replaceAll(`{{${key}_b64}}`, b64);
+    }
+    code = code.replaceAll("{{outputDir}}", this.fileManager.getOutputDir(execId).replace(/\\/g, "/"));
+    code = code.replaceAll("{{skillDir}}", (skillDir || "").replace(/\\/g, "/"));
+    return code;
+  }
+  async installGeneratedSkillIfRequested(execId) {
+    const manifestPath = this.fileManager.getOutputFilePath(execId, "skill-hub-install.json");
+    if (!manifestPath) return null;
+    let manifest;
+    try {
+      manifest = JSON.parse((0, import_fs.readFileSync)(manifestPath, "utf8"));
+    } catch (error) {
+      throw new Error(`Generated skill install manifest is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!(manifest == null ? void 0 : manifest.autoInstall)) return null;
+    const skill = manifest.skill || {};
+    const name = String(skill.name || "").trim();
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
+      throw new Error(`Generated skill name "${name}" is invalid. Use lowercase letters, numbers, and hyphens.`);
+    }
+    const language = skill.language;
+    if (language !== "python" && language !== "node") {
+      throw new Error(`Generated skill "${name}" has unsupported language "${language}".`);
+    }
+    if (!skill.codeTemplate) {
+      throw new Error(`Generated skill "${name}" is missing codeTemplate.`);
+    }
+    const validator = new import_CodeValidator.CodeValidator();
+    validator.validate(skill.codeTemplate, language);
+    await this.validateGeneratedSkillPackages(name, language, skill.packages);
+    const outputDir = this.fileManager.getOutputDir(execId);
+    const outputRoot = (0, import_path.resolve)(outputDir);
+    const packageDirName = String(manifest.packageDir || name);
+    const packageDir = (0, import_path.resolve)(outputRoot, packageDirName);
+    if (packageDir !== outputRoot && !packageDir.startsWith(outputRoot + import_path.sep) || !(0, import_fs.existsSync)(packageDir)) {
+      throw new Error(`Generated skill package directory "${packageDirName}" was not found in output.`);
+    }
+    if (manifest.testInput && Object.keys(manifest.testInput).length > 0) {
+      const verifyExecId = `${execId}-verify-${name}`;
+      const verifyCode = this.renderTemplate(skill.codeTemplate, manifest.testInput, verifyExecId, packageDir);
+      const verifyResult = await this.sandboxRunner.execute({
+        language,
+        code: verifyCode,
+        execId: verifyExecId,
+        timeoutSeconds: Math.min(Number(skill.timeoutSeconds || 60), 30),
+        maxOutputSizeMb: Math.min(Number(skill.maxOutputSizeMb || 50), 10),
+        skillDir: packageDir
+      });
+      if (!verifyResult.success) {
+        throw new Error(
+          `Generated skill "${name}" failed smoke verification: ${verifyResult.stderr || verifyResult.stdout || "unknown error"}`
+        );
+      }
+    }
+    const skillRepoDir = this.skillRepoService.getSkillPath(name);
+    if ((0, import_fs.existsSync)(skillRepoDir)) {
+      (0, import_fs.rmSync)(skillRepoDir, { recursive: true, force: true });
+    }
+    (0, import_fs.cpSync)(packageDir, skillRepoDir, {
+      recursive: true,
+      force: true,
+      filter: (src) => {
+        const leaf = src.split(/[\\/]/).pop();
+        return !["node_modules", ".git", "__pycache__"].includes(leaf || "") && !src.endsWith(".pyc");
+      }
+    });
+    const values = {
+      name,
+      title: skill.title || name,
+      description: skill.description || "",
+      instructions: skill.instructions || "",
+      language,
+      codeTemplate: skill.codeTemplate,
+      inputSchema: (0, import_json_fields.stringifyJsonText)(skill.inputSchema || { type: "object", properties: {} }),
+      packages: (0, import_json_fields.stringifyJsonText)(skill.packages || [], []),
+      timeoutSeconds: skill.timeoutSeconds || 60,
+      maxOutputSizeMb: skill.maxOutputSizeMb || 50,
+      enabled: skill.enabled !== false,
+      toolScope: skill.toolScope || "CUSTOM",
+      autoCall: !!skill.autoCall,
+      storageType: "local",
+      storageUrl: `local://generated/${name}`
+    };
+    if (skill.interactionSchema) {
+      values.interactionSchema = (0, import_json_fields.stringifyJsonText)(skill.interactionSchema);
+    }
+    const repo = this.app.db.getRepository("skillDefinitions");
+    const existing = await repo.findOne({ filter: { name } });
+    if (existing) {
+      if (manifest.overwrite === false) {
+        throw new Error(`Skill "${name}" already exists and overwrite=false.`);
+      }
+      await repo.update({ filter: { name }, values });
+      return `[skill-hub] Updated generated skill "${name}" in Skill Hub.`;
+    }
+    await repo.create({ values });
+    return `[skill-hub] Installed generated skill "${name}" in Skill Hub.`;
+  }
+  async validateGeneratedSkillPackages(name, language, packages) {
+    if (!Array.isArray(packages) || packages.length === 0) return;
+    if (!packages.every((pkg) => typeof pkg === "string" && pkg.trim())) {
+      throw new Error(`Generated skill "${name}" has invalid packages. Use an array of package names.`);
+    }
+    const workerConfig = await this.app.db.getRepository("skillWorkerConfigs").findOne();
+    if (!workerConfig) return;
+    const whitelist = (0, import_json_fields.parseJsonText)(
+      workerConfig.get ? workerConfig.get("packageWhitelist") : workerConfig.packageWhitelist,
+      null
+    );
+    const allowed = whitelist == null ? void 0 : whitelist[language];
+    if (!Array.isArray(allowed) || allowed.length === 0) return;
+    const allowedSet = new Set(allowed.map((pkg) => pkg.toLowerCase()));
+    const missing = packages.map((pkg) => pkg.trim()).filter((pkg) => !allowedSet.has(pkg.toLowerCase()));
+    if (missing.length > 0) {
+      throw new Error(
+        `Generated skill "${name}" requires ${language} package(s) not available in the Skill Hub worker environment: ${missing.join(", ")}. Add them to the worker environment and refresh/init Skill Hub before installing this skill.`
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SkillExecutionTask
+});

package/dist/server/skill-hub/utils/json-fields.d.ts

@@ -0,0 +1,7 @@
+export declare function parseJsonText<T = any>(value: any, fallback: T): T;
+export declare function stringifyJsonText(value: any, fallback?: any): string;
+export declare function parseJsonLike(value: any, fallback: any): any;
+export declare function parseSkillMarkdown(markdown: string): {
+    metadata: Record<string, any>;
+    body: string;
+};

package/dist/server/skill-hub/utils/json-fields.js

@@ -0,0 +1,88 @@
+/**
+ * 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 json_fields_exports = {};
+__export(json_fields_exports, {
+  parseJsonLike: () => parseJsonLike,
+  parseJsonText: () => parseJsonText,
+  parseSkillMarkdown: () => parseSkillMarkdown,
+  stringifyJsonText: () => stringifyJsonText
+});
+module.exports = __toCommonJS(json_fields_exports);
+function parseJsonText(value, fallback) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  const json = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return JSON.parse(json);
+  } catch {
+    return fallback;
+  }
+}
+function stringifyJsonText(value, fallback = null) {
+  const normalized = value === void 0 || value === null || value === "" ? fallback : value;
+  if (typeof normalized === "string") {
+    const parsed = parseJsonText(normalized, void 0);
+    if (parsed === void 0) return normalized;
+    return `\`\`\`json
+${JSON.stringify(parsed, null, 2)}
+\`\`\``;
+  }
+  return `\`\`\`json
+${JSON.stringify(normalized, null, 2)}
+\`\`\``;
+}
+function parseJsonLike(value, fallback) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value !== "string") return value;
+  const parsed = parseJsonText(value, void 0);
+  if (parsed !== void 0) return parsed;
+  return value.includes(",") ? value.split(",").map((item) => item.trim()).filter(Boolean) : fallback;
+}
+function parseSkillMarkdown(markdown) {
+  const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return { metadata: {}, body: markdown.trim() };
+  const result = {};
+  match[1].split(/\r?\n/).forEach((line) => {
+    const idx = line.indexOf(":");
+    if (idx > 0) {
+      const key = line.substring(0, idx).trim();
+      const value = line.substring(idx + 1).trim();
+      if (key) result[key] = value;
+    }
+  });
+  const body = markdown.substring(match[0].length).trim();
+  return { metadata: result, body };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseJsonLike,
+  parseJsonText,
+  parseSkillMarkdown,
+  stringifyJsonText
+});

package/dist/server/tools/delegate-task.d.ts

@@ -13,3 +13,7 @@
  *   leaderUsername field, so scoping is enforced in the invoke callback)
  */
 export declare function createDelegateToolsProvider(plugin: any): (register: any) => Promise<void>;
+/**
+ * Test/internal helper to drop the in-memory tool cache (e.g., from a CLI op).
+ */
+export declare function invalidateDelegateToolsCache(): void;