plugin-agent-orchestrator 1.0.6 → 1.0.14

package/dist/server/services/CodeValidator.js

@@ -0,0 +1,205 @@
+/**
+ * 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 CodeValidator_exports = {};
+__export(CodeValidator_exports, {
+  CodeValidationError: () => CodeValidationError,
+  CodeValidator: () => CodeValidator
+});
+module.exports = __toCommonJS(CodeValidator_exports);
+const DANGEROUS_NODE_PATTERNS = [
+  { pattern: /require\s*\(\s*['"]child_process['"]\s*\)/, reason: "child_process module not allowed" },
+  { pattern: /require\s*\(\s*['"]cluster['"]\s*\)/, reason: "cluster module not allowed" },
+  { pattern: /require\s*\(\s*['"]dgram['"]\s*\)/, reason: "dgram module not allowed" },
+  { pattern: /require\s*\(\s*['"]net['"]\s*\)/, reason: "net module not allowed" },
+  { pattern: /require\s*\(\s*['"]http['"]\s*\)/, reason: "http module not allowed" },
+  { pattern: /require\s*\(\s*['"]https['"]\s*\)/, reason: "https module not allowed" },
+  { pattern: /require\s*\(\s*['"]vm['"]\s*\)/, reason: "vm module not allowed" },
+  { pattern: /process\.exit/, reason: "process.exit not allowed" },
+  { pattern: /process\.env(?!\s*\.OUTPUT_DIR)/, reason: "process.env access not allowed (use OUTPUT_DIR only)" },
+  { pattern: /process\.kill/, reason: "process.kill not allowed" }
+];
+const DANGEROUS_PYTHON_PATTERNS = [
+  { pattern: /import\s+subprocess/, reason: "subprocess module not allowed" },
+  { pattern: /from\s+subprocess\s+import/, reason: "subprocess module not allowed" },
+  { pattern: /import\s+shutil/, reason: "shutil module not allowed" },
+  { pattern: /__import__\s*\(/, reason: "__import__ not allowed" },
+  { pattern: /os\.system\s*\(/, reason: "os.system not allowed" },
+  { pattern: /os\.popen\s*\(/, reason: "os.popen not allowed" },
+  { pattern: /os\.exec\w*\s*\(/, reason: "os.exec* not allowed" },
+  { pattern: /os\.spawn\w*\s*\(/, reason: "os.spawn* not allowed" },
+  { pattern: /\beval\s*\(/, reason: "eval not allowed" },
+  { pattern: /\bexec\s*\(/, reason: "exec not allowed" },
+  { pattern: /\bcompile\s*\(/, reason: "compile not allowed" }
+];
+const NODE_BUILTINS = [
+  "fs",
+  "path",
+  "os",
+  "crypto",
+  "util",
+  "stream",
+  "buffer",
+  "querystring",
+  "url",
+  "assert",
+  "events",
+  "string_decoder",
+  "zlib"
+];
+const PYTHON_BUILTINS = [
+  "os",
+  "sys",
+  "json",
+  "math",
+  "datetime",
+  "collections",
+  "itertools",
+  "functools",
+  "pathlib",
+  "typing",
+  "io",
+  "csv",
+  "re",
+  "string",
+  "textwrap",
+  "decimal",
+  "fractions",
+  "random",
+  "statistics",
+  "copy",
+  "enum",
+  "dataclasses",
+  "abc",
+  "contextlib",
+  "operator",
+  "time",
+  "calendar",
+  "locale",
+  "struct",
+  "hashlib",
+  "base64",
+  "binascii",
+  "codecs",
+  "unicodedata",
+  "pprint",
+  "warnings",
+  "traceback",
+  "logging",
+  "unittest",
+  "argparse",
+  "tempfile",
+  "xml",
+  "zipfile",
+  // Pre-installed local packages (trusted, bundled with plugin)
+  "svg_to_pptx"
+];
+const PYTHON_IMPORT_NAME_MAP = {
+  "python-docx": "docx",
+  "python-pptx": "pptx",
+  "Pillow": "PIL",
+  "pyyaml": "yaml"
+};
+class CodeValidator {
+  /**
+   * Check code against forbidden patterns (dangerous modules/functions).
+   * @throws CodeValidationError if a forbidden pattern is found.
+   */
+  validate(code, language) {
+    const patterns = language === "node" ? DANGEROUS_NODE_PATTERNS : DANGEROUS_PYTHON_PATTERNS;
+    for (const { pattern, reason } of patterns) {
+      if (pattern.test(code)) {
+        throw new CodeValidationError(reason, pattern.source);
+      }
+    }
+  }
+  /**
+   * Validate that code only imports packages in the whitelist.
+   * Called after the basic forbidden pattern check.
+   * Skips validation if whitelist is empty (env not initialized yet).
+   *
+   * @param code - The code to validate
+   * @param language - 'node' or 'python'
+   * @param whitelist - Array of allowed package names (from skillWorkerConfigs.packageWhitelist)
+   */
+  validateImports(code, language, whitelist) {
+    if (!(whitelist == null ? void 0 : whitelist.length)) return;
+    if (language === "node") {
+      this.validateNodeImports(code, whitelist);
+    } else if (language === "python") {
+      this.validatePythonImports(code, whitelist);
+    }
+  }
+  /**
+   * Check Node.js require() calls against the whitelist.
+   * Built-in modules (fs, path, etc.) are always allowed.
+   */
+  validateNodeImports(code, whitelist) {
+    const requires = [...code.matchAll(/require\s*\(\s*['"]([^'"./][^'"]*)['"]\s*\)/g)];
+    for (const match of requires) {
+      const raw = match[1];
+      const pkgName = raw.startsWith("@") ? raw.split("/").slice(0, 2).join("/") : raw.split("/")[0];
+      if (NODE_BUILTINS.includes(pkgName)) continue;
+      if (whitelist.includes(pkgName)) continue;
+      throw new CodeValidationError(
+        `Package "${pkgName}" is not in the allowed whitelist. Allowed: ${whitelist.join(", ")}`,
+        `require('${pkgName}')`
+      );
+    }
+  }
+  /**
+   * Check Python import/from statements against the whitelist.
+   * Built-in modules (os, sys, json, etc.) are always allowed.
+   * Handles PyPI→import name mapping (e.g., python-docx → docx, Pillow → PIL).
+   */
+  validatePythonImports(code, whitelist) {
+    const imports = [...code.matchAll(/(?:^|\n)\s*(?:import|from)\s+([a-zA-Z_][a-zA-Z0-9_]*)/g)];
+    const allowedImports = /* @__PURE__ */ new Set([
+      ...PYTHON_BUILTINS,
+      ...whitelist.map((p) => PYTHON_IMPORT_NAME_MAP[p] || p)
+    ]);
+    for (const match of imports) {
+      const pkg = match[1];
+      if (allowedImports.has(pkg)) continue;
+      throw new CodeValidationError(
+        `Module "${pkg}" is not in the allowed whitelist. Allowed: ${[...allowedImports].join(", ")}`,
+        `import ${pkg}`
+      );
+    }
+  }
+}
+class CodeValidationError extends Error {
+  constructor(message, matchedPattern) {
+    super(`Code validation failed: ${message}`);
+    this.matchedPattern = matchedPattern;
+    this.name = "CodeValidationError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodeValidationError,
+  CodeValidator
+});

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

@@ -0,0 +1,44 @@
+export declare const ORCHESTRATOR_TRACE_CONTEXT_KEY = "__orchestratorTraceContext";
+export type OrchestratorTraceContext = {
+    rootRunId: string;
+    spanId?: string;
+    parentSpanId?: string;
+    toolCallId?: string;
+    leaderUsername?: string;
+    employeeUsername?: string;
+    toolName?: string;
+};
+type SpanValues = {
+    rootRunId: string;
+    parentSpanId?: string;
+    type: string;
+    status: string;
+    leaderUsername?: string;
+    employeeUsername?: string;
+    toolName?: string;
+    title?: string;
+    input?: any;
+    output?: string;
+    error?: string;
+    durationMs?: number;
+    startedAt?: Date;
+    endedAt?: Date;
+    orchestratorLogId?: string | number;
+    skillExecutionId?: string | number;
+    metadata?: any;
+    userId?: string | number;
+};
+export declare class ExecutionSpanService {
+    private readonly plugin;
+    constructor(plugin: any);
+    create(values: SpanValues): Promise<any>;
+    update(spanId: string | number | undefined, values: Record<string, any>): Promise<{
+        id: string | number;
+    }>;
+    finish(spanId: string | number | undefined, status: 'success' | 'error' | 'canceled' | 'timeout', startedAt: number, values?: Record<string, any>): Promise<{
+        id: string | number;
+    }>;
+}
+export declare function getOrchestratorTraceContext(ctx: any): OrchestratorTraceContext | null;
+export declare function setOrchestratorTraceContext(ctx: any, traceContext: OrchestratorTraceContext): any;
+export {};

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>;
+}