plugin-agent-orchestrator 1.0.13 → 1.0.14

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,14 @@
+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;
+}

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

@@ -0,0 +1,267 @@
+/**
+ * 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_path = require("path");
+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);
+        }
+      });
+      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;
+  }
+}
+// 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;