plugin-agent-orchestrator 1.0.13 → 1.0.14

package/dist/server/services/ExecutionSpanService.js

@@ -0,0 +1,104 @@
+/**
+ * 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 ExecutionSpanService_exports = {};
+__export(ExecutionSpanService_exports, {
+  ExecutionSpanService: () => ExecutionSpanService,
+  ORCHESTRATOR_TRACE_CONTEXT_KEY: () => ORCHESTRATOR_TRACE_CONTEXT_KEY,
+  getOrchestratorTraceContext: () => getOrchestratorTraceContext,
+  setOrchestratorTraceContext: () => setOrchestratorTraceContext
+});
+module.exports = __toCommonJS(ExecutionSpanService_exports);
+const ORCHESTRATOR_TRACE_CONTEXT_KEY = "__orchestratorTraceContext";
+function toPlain(record) {
+  var _a;
+  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
+}
+class ExecutionSpanService {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  async create(values) {
+    var _a, _b;
+    try {
+      const repo = this.plugin.db.getRepository("agentExecutionSpans");
+      if (!repo) return null;
+      const record = await repo.create({
+        values: {
+          ...values,
+          startedAt: values.startedAt || /* @__PURE__ */ new Date(),
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      });
+      return toPlain(record);
+    } catch (error) {
+      (_b = (_a = this.plugin.app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[AgentOrchestrator] Failed to create execution span", error);
+      return null;
+    }
+  }
+  async update(spanId, values) {
+    var _a, _b;
+    if (!spanId) return null;
+    try {
+      const repo = this.plugin.db.getRepository("agentExecutionSpans");
+      if (!repo) return null;
+      await repo.update({
+        filterByTk: spanId,
+        values: {
+          ...values,
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+      return { id: spanId };
+    } catch (error) {
+      (_b = (_a = this.plugin.app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, `[AgentOrchestrator] Failed to update execution span ${spanId}`, error);
+      return null;
+    }
+  }
+  async finish(spanId, status, startedAt, values = {}) {
+    return this.update(spanId, {
+      ...values,
+      status,
+      endedAt: /* @__PURE__ */ new Date(),
+      durationMs: Date.now() - startedAt
+    });
+  }
+}
+function getOrchestratorTraceContext(ctx) {
+  var _a, _b, _c;
+  return (ctx == null ? void 0 : ctx[ORCHESTRATOR_TRACE_CONTEXT_KEY]) || ((_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.orchestratorTraceContext) || ((_c = (_b = ctx == null ? void 0 : ctx.runtime) == null ? void 0 : _b.context) == null ? void 0 : _c.orchestratorTraceContext) || null;
+}
+function setOrchestratorTraceContext(ctx, traceContext) {
+  ctx[ORCHESTRATOR_TRACE_CONTEXT_KEY] = traceContext;
+  return ctx;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExecutionSpanService,
+  ORCHESTRATOR_TRACE_CONTEXT_KEY,
+  getOrchestratorTraceContext,
+  setOrchestratorTraceContext
+});

package/dist/server/services/FileManager.d.ts

@@ -0,0 +1,28 @@
+export interface OutputFileInfo {
+    name: string;
+    size: number;
+    mimeType: string;
+}
+export declare class FileManager {
+    private storagePath;
+    private executionsDir;
+    constructor(storagePath: string);
+    createExecDir(execId: string): string;
+    getExecDir(execId: string): string;
+    getOutputDir(execId: string): string;
+    /**
+     * Returns absolute path to an output file, or null if invalid/not found.
+     * Includes path traversal protection.
+     */
+    getOutputFilePath(execId: string, filename: string): string | null;
+    listOutputFiles(execId: string): OutputFileInfo[];
+    getTotalOutputSize(execId: string): number;
+    /**
+     * Remove a specific execution directory by execId.
+     */
+    removeExecDir(execId: string): void;
+    /**
+     * Remove execution directories older than maxAgeMs.
+     */
+    cleanupOlderThan(maxAgeMs: number): number;
+}

package/dist/server/services/FileManager.js

@@ -0,0 +1,151 @@
+/**
+ * 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 FileManager_exports = {};
+__export(FileManager_exports, {
+  FileManager: () => FileManager
+});
+module.exports = __toCommonJS(FileManager_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+const MIME_MAP = {
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pdf": "application/pdf",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".zip": "application/zip",
+  ".html": "text/html",
+  ".xml": "application/xml"
+};
+function getMimeType(filename) {
+  const ext = filename.substring(filename.lastIndexOf(".")).toLowerCase();
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+class FileManager {
+  constructor(storagePath) {
+    this.storagePath = storagePath;
+    this.executionsDir = (0, import_path.resolve)(storagePath, "executions");
+    (0, import_fs.mkdirSync)(this.executionsDir, { recursive: true });
+  }
+  executionsDir;
+  createExecDir(execId) {
+    const dir = (0, import_path.resolve)(this.executionsDir, execId);
+    (0, import_fs.mkdirSync)(dir, { recursive: true });
+    (0, import_fs.mkdirSync)((0, import_path.resolve)(dir, "output"), { recursive: true });
+    return dir;
+  }
+  getExecDir(execId) {
+    return (0, import_path.resolve)(this.executionsDir, execId);
+  }
+  getOutputDir(execId) {
+    return (0, import_path.resolve)(this.executionsDir, execId, "output");
+  }
+  /**
+   * Returns absolute path to an output file, or null if invalid/not found.
+   * Includes path traversal protection.
+   */
+  getOutputFilePath(execId, filename) {
+    const safeBase = (0, import_path.resolve)(this.executionsDir, execId, "output");
+    const filePath = (0, import_path.resolve)(safeBase, filename);
+    if (!filePath.startsWith(safeBase)) {
+      return null;
+    }
+    if (!(0, import_fs.existsSync)(filePath)) {
+      return null;
+    }
+    return filePath;
+  }
+  listOutputFiles(execId) {
+    const outputDir = this.getOutputDir(execId);
+    if (!(0, import_fs.existsSync)(outputDir)) return [];
+    try {
+      return (0, import_fs.readdirSync)(outputDir).filter((name) => {
+        const filePath = (0, import_path.join)(outputDir, name);
+        return (0, import_fs.statSync)(filePath).isFile();
+      }).map((name) => {
+        const filePath = (0, import_path.join)(outputDir, name);
+        const stat = (0, import_fs.statSync)(filePath);
+        return {
+          name,
+          size: stat.size,
+          mimeType: getMimeType(name)
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+  getTotalOutputSize(execId) {
+    const files = this.listOutputFiles(execId);
+    return files.reduce((sum, f) => sum + f.size, 0);
+  }
+  /**
+   * Remove a specific execution directory by execId.
+   */
+  removeExecDir(execId) {
+    const dirPath = (0, import_path.resolve)(this.executionsDir, execId);
+    if ((0, import_fs.existsSync)(dirPath)) {
+      try {
+        (0, import_fs.rmSync)(dirPath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Remove execution directories older than maxAgeMs.
+   */
+  cleanupOlderThan(maxAgeMs) {
+    if (!(0, import_fs.existsSync)(this.executionsDir)) return 0;
+    let cleaned = 0;
+    const now = Date.now();
+    try {
+      for (const dir of (0, import_fs.readdirSync)(this.executionsDir)) {
+        const dirPath = (0, import_path.resolve)(this.executionsDir, dir);
+        try {
+          const stat = (0, import_fs.statSync)(dirPath);
+          if (stat.isDirectory() && now - stat.mtimeMs > maxAgeMs) {
+            (0, import_fs.rmSync)(dirPath, { recursive: true, force: true });
+            cleaned++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return cleaned;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileManager
+});

package/dist/server/services/SandboxRunner.d.ts

@@ -0,0 +1,41 @@
+import { FileManager, OutputFileInfo } from './FileManager';
+export interface ExecuteOptions {
+    language: 'node' | 'python';
+    code: string;
+    execId: string;
+    timeoutSeconds?: number;
+    maxOutputSizeMb?: number;
+    onProgress?: (progress: ProgressUpdate) => void;
+    /** AbortSignal — when aborted, the child process is killed */
+    signal?: {
+        addEventListener(event: string, listener: () => void): void;
+    };
+    /** Package whitelist for import validation (from skillWorkerConfigs) */
+    packageWhitelist?: string[];
+    /** Optional installed/copied skill package root exposed to the runtime as SKILL_DIR. */
+    skillDir?: string;
+}
+export interface ProgressUpdate {
+    percent: number;
+    log: string;
+}
+export interface ExecutionResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    files: OutputFileInfo[];
+    durationMs: number;
+    /** true if execution was canceled by user */
+    canceled?: boolean;
+    /** true if execution timed out */
+    timedOut?: boolean;
+}
+export declare class SandboxRunner {
+    private fileManager;
+    private logger;
+    private storagePath;
+    private validator;
+    private sandboxWorkspace;
+    constructor(fileManager: FileManager, logger: any, storagePath: string);
+    execute(options: ExecuteOptions): Promise<ExecutionResult>;
+}

package/dist/server/services/SandboxRunner.js

@@ -0,0 +1,167 @@
+/**
+ * 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 SandboxRunner_exports = {};
+__export(SandboxRunner_exports, {
+  SandboxRunner: () => SandboxRunner
+});
+module.exports = __toCommonJS(SandboxRunner_exports);
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_CodeValidator = require("./CodeValidator");
+class SandboxRunner {
+  constructor(fileManager, logger, storagePath) {
+    this.fileManager = fileManager;
+    this.logger = logger;
+    this.storagePath = storagePath;
+    this.sandboxWorkspace = (0, import_path.resolve)(storagePath, "sandbox-workspace");
+  }
+  validator = new import_CodeValidator.CodeValidator();
+  sandboxWorkspace;
+  async execute(options) {
+    const {
+      language,
+      code,
+      execId,
+      timeoutSeconds = 60,
+      maxOutputSizeMb = 50,
+      onProgress,
+      signal,
+      packageWhitelist,
+      skillDir
+    } = options;
+    this.validator.validate(code, language);
+    if (packageWhitelist == null ? void 0 : packageWhitelist.length) {
+      this.validator.validateImports(code, language, packageWhitelist);
+    }
+    const workDir = this.fileManager.createExecDir(execId);
+    const outputDir = this.fileManager.getOutputDir(execId);
+    const filename = language === "node" ? "script.js" : "script.py";
+    const scriptPath = (0, import_path.resolve)(workDir, filename);
+    (0, import_fs.writeFileSync)(scriptPath, code, "utf-8");
+    onProgress == null ? void 0 : onProgress({ percent: 20, log: "Code validated, executing..." });
+    const cmd = language === "node" ? `node "${scriptPath}"` : `python3 "${scriptPath}"`;
+    const path = require("path");
+    const nodePath = path.resolve(this.sandboxWorkspace, "node_modules");
+    const finalNodePath = process.env.NODE_PATH ? `${nodePath}${path.delimiter}${process.env.NODE_PATH}` : nodePath;
+    const startTime = Date.now();
+    let childProc = null;
+    let wasCanceled = false;
+    const processResult = await new Promise((resolveResult) => {
+      childProc = (0, import_child_process.exec)(
+        cmd,
+        {
+          timeout: timeoutSeconds * 1e3,
+          maxBuffer: 10 * 1024 * 1024,
+          // 10MB stdout/stderr buffer
+          cwd: workDir,
+          env: {
+            // Sanitized environment — only expose what's necessary
+            PATH: process.env.PATH,
+            HOME: "/tmp",
+            TMPDIR: "/tmp",
+            OUTPUT_DIR: outputDir,
+            LANG: "en_US.UTF-8",
+            // Node.js
+            NODE_PATH: finalNodePath,
+            // Python — include bundled packages (svg_to_pptx etc.)
+            PYTHONPATH: [
+              skillDir ? path.resolve(skillDir, "scripts") : "",
+              path.resolve(this.sandboxWorkspace, "python_packages"),
+              process.env.PYTHONPATH || ""
+            ].filter(Boolean).join(path.delimiter),
+            PYTHONIOENCODING: "utf-8",
+            SKILL_DIR: skillDir || ""
+            // DO NOT pass: DB credentials, API keys, APP_KEY, etc.
+          }
+        },
+        (error, stdout, stderr) => {
+          let exitCode = 0;
+          if (error) {
+            if (error.killed) {
+              exitCode = -1;
+            } else {
+              exitCode = error.code || 1;
+            }
+          }
+          resolveResult({
+            exitCode,
+            stdout: (stdout || "").slice(0, 5e3),
+            stderr: (stderr || "").slice(0, 2e3)
+          });
+        }
+      );
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          wasCanceled = true;
+          if (childProc && !childProc.killed) {
+            this.logger.info(`[skill-hub] Killing child process for exec ${execId} (user abort)`);
+            childProc.kill("SIGTERM");
+            setTimeout(() => {
+              if (childProc && !childProc.killed) {
+                childProc.kill("SIGKILL");
+              }
+            }, 3e3);
+          }
+        });
+      }
+    });
+    const durationMs = Date.now() - startTime;
+    onProgress == null ? void 0 : onProgress({ percent: 80, log: wasCanceled ? "Canceled" : "Execution completed, collecting files..." });
+    const files = this.fileManager.listOutputFiles(execId);
+    const totalSizeBytes = this.fileManager.getTotalOutputSize(execId);
+    const maxBytes = maxOutputSizeMb * 1024 * 1024;
+    if (totalSizeBytes > maxBytes) {
+      this.logger.warn(
+        `[skill-hub] Execution ${execId}: output size ${totalSizeBytes} bytes exceeds limit ${maxBytes}`
+      );
+    }
+    onProgress == null ? void 0 : onProgress({ percent: 100, log: "Done" });
+    const timedOut = !wasCanceled && processResult.exitCode === -1;
+    if (timedOut) {
+      processResult.stderr = `Execution timed out after ${timeoutSeconds}s
+${processResult.stderr}`;
+    }
+    if (wasCanceled) {
+      processResult.stderr = `Execution canceled by user
+${processResult.stderr}`;
+    }
+    return {
+      success: !wasCanceled && !timedOut && processResult.exitCode === 0,
+      stdout: processResult.stdout,
+      stderr: processResult.stderr,
+      files,
+      durationMs,
+      canceled: wasCanceled,
+      timedOut
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SandboxRunner
+});

package/dist/server/services/SkillManager.d.ts

@@ -0,0 +1,6 @@
+import { Database } from '@nocobase/database';
+export declare class SkillManager {
+    private db;
+    constructor(db: Database);
+    seedDefaults(): Promise<void>;
+}