plugin-agent-orchestrator 1.0.17 → 1.0.19

package/dist/server/services/AgentPlannerService.js

@@ -0,0 +1,119 @@
+/**
+ * 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 AgentPlannerService_exports = {};
+__export(AgentPlannerService_exports, {
+  AgentPlannerService: () => AgentPlannerService
+});
+module.exports = __toCommonJS(AgentPlannerService_exports);
+function normalizeStepType(value) {
+  return ["reasoning", "skill", "tool", "sub_agent", "verification"].includes(value) ? value : "tool";
+}
+function normalizePlanKey(step, index) {
+  return String(step.planKey || step.key || step.id || `step_${index + 1}`);
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+class AgentPlannerService {
+  buildPlan(goal, plan, options) {
+    var _a;
+    if (Array.isArray(plan) && plan.length > 0) {
+      return plan.map((step, index) => {
+        var _a2;
+        return {
+          ...step,
+          planKey: normalizePlanKey(step, index),
+          type: normalizeStepType(step.type),
+          dependsOn: asArray(step.dependsOn).map(String),
+          metadata: {
+            ...asObject(step.metadata),
+            harnessTag: options.harnessTag || ((_a2 = options.metadata) == null ? void 0 : _a2.harnessTag) || "default"
+          }
+        };
+      });
+    }
+    const harnessTag = options.harnessTag || ((_a = options.metadata) == null ? void 0 : _a.harnessTag) || "default";
+    const steps = [
+      {
+        planKey: "prepare_context",
+        title: "Prepare execution context",
+        description: "Review the user goal, available context, and constraints before execution.",
+        type: "reasoning",
+        input: { goal },
+        metadata: { harnessTag }
+      }
+    ];
+    if (options.targetAgent) {
+      steps.push({
+        planKey: "delegate_execution",
+        title: `Delegate execution to ${options.targetAgent}`,
+        description: goal,
+        type: "sub_agent",
+        target: options.targetAgent,
+        input: { goal },
+        dependsOn: ["prepare_context"],
+        metadata: { harnessTag }
+      });
+    } else {
+      steps.push({
+        planKey: "execute_goal",
+        title: "Execute approved goal",
+        description: "Execute the user goal in the leader harness using the available approved tools.",
+        type: "reasoning",
+        input: { goal },
+        dependsOn: ["prepare_context"],
+        metadata: { harnessTag, controllerOnly: true }
+      });
+    }
+    steps.push({
+      planKey: "verify_result",
+      title: "Verify result",
+      description: "Check that the completed work matches the approved goal and report evidence.",
+      type: "verification",
+      input: { goal },
+      dependsOn: [steps[steps.length - 1].planKey || "execute_goal"],
+      metadata: { harnessTag }
+    });
+    return steps;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentPlannerService
+});

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

@@ -0,0 +1,13 @@
+export declare class AgentRegistryService {
+    private readonly plugin;
+    constructor(plugin: any);
+    get db(): any;
+    getHarnessProfile(tag: string): Promise<any>;
+    getOrchestratorConfig(leaderUsername: string, subAgentUsername: string): Promise<any>;
+    getAIEmployee(username: string): Promise<any>;
+    resolveModelSettings(subAgentUsername: string, leaderUsername?: string, dynamicValues?: any): Promise<{
+        llmService: string;
+        model: string;
+    }>;
+    isRegisteredDelegationTool(toolName: string): Promise<boolean>;
+}

package/dist/server/services/AgentRegistryService.js

@@ -0,0 +1,178 @@
+/**
+ * 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 AgentRegistryService_exports = {};
+__export(AgentRegistryService_exports, {
+  AgentRegistryService: () => AgentRegistryService
+});
+module.exports = __toCommonJS(AgentRegistryService_exports);
+function toPlain(record) {
+  var _a;
+  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function normalizeEmployeeUsername(raw) {
+  if (!raw) return null;
+  if (typeof raw === "string") return raw;
+  return raw.username || raw.aiEmployeeUsername || raw.name || null;
+}
+class AgentRegistryService {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  get db() {
+    return this.plugin.db;
+  }
+  async getHarnessProfile(tag) {
+    try {
+      const repo = this.db.getRepository("agentHarnessProfiles");
+      if (!repo) return null;
+      const profile = await repo.findOne({
+        filter: {
+          tag: tag || "default",
+          enabled: true
+        }
+      });
+      return profile ? toPlain(profile) : null;
+    } catch {
+      return null;
+    }
+  }
+  async getOrchestratorConfig(leaderUsername, subAgentUsername) {
+    try {
+      const repo = this.db.getRepository("orchestratorConfig");
+      if (!repo) return null;
+      const config = await repo.findOne({
+        filter: {
+          leaderUsername,
+          subAgentUsername,
+          enabled: true
+        }
+      });
+      return config ? toPlain(config) : null;
+    } catch {
+      return null;
+    }
+  }
+  async getAIEmployee(username) {
+    try {
+      const repo = this.db.getRepository("aiEmployees");
+      if (!repo) return null;
+      const employee = await repo.findOne({
+        filter: { username }
+      });
+      return employee ? toPlain(employee) : null;
+    } catch {
+      return null;
+    }
+  }
+  async resolveModelSettings(subAgentUsername, leaderUsername, dynamicValues) {
+    const subAgent = await this.getAIEmployee(subAgentUsername);
+    if (!subAgent) {
+      throw new Error(`Sub-agent "${subAgentUsername}" was not found.`);
+    }
+    const hasModelSettings = (val) => {
+      return Boolean((val == null ? void 0 : val.llmService) && (val == null ? void 0 : val.model));
+    };
+    let modelSettings = hasModelSettings(dynamicValues) ? dynamicValues : void 0;
+    if (!modelSettings) {
+      if (hasModelSettings(subAgent.modelSettings)) {
+        modelSettings = subAgent.modelSettings;
+      }
+    }
+    if (!modelSettings && leaderUsername) {
+      const leader = await this.getAIEmployee(leaderUsername);
+      if (leader && hasModelSettings(leader.modelSettings)) {
+        modelSettings = leader.modelSettings;
+      }
+    }
+    return modelSettings;
+  }
+  async isRegisteredDelegationTool(toolName) {
+    if (!toolName || typeof toolName !== "string") return false;
+    if (!toolName.startsWith("delegate_") && !toolName.startsWith("dispatch_subagents_")) {
+      return false;
+    }
+    try {
+      const configRepo = this.db.getRepository("orchestratorConfig");
+      if (!configRepo) return false;
+      if (toolName.startsWith("dispatch_subagents_")) {
+        const leader = toolName.substring("dispatch_subagents_".length);
+        const count = await configRepo.count({
+          filter: {
+            leaderUsername: leader,
+            enabled: true
+          }
+        });
+        return count > 0;
+      }
+      if (toolName.startsWith("delegate_") && toolName.includes("_to_")) {
+        const parts = toolName.substring("delegate_".length).split("_to_");
+        if (parts.length === 2) {
+          const [leader, subAgent] = parts;
+          const count = await configRepo.count({
+            filter: {
+              leaderUsername: leader,
+              subAgentUsername: subAgent,
+              enabled: true
+            }
+          });
+          if (count > 0) return true;
+        }
+      }
+      if (toolName.startsWith("delegate_to_")) {
+        const subAgent = toolName.substring("delegate_to_".length);
+        const configs = await configRepo.find({
+          filter: {
+            subAgentUsername: subAgent,
+            enabled: true
+          }
+        });
+        if ((configs == null ? void 0 : configs.length) === 1) {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRegistryService
+});

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

@@ -0,0 +1,32 @@
+export declare class CodeValidator {
+    /**
+     * Check code against forbidden patterns (dangerous modules/functions).
+     * @throws CodeValidationError if a forbidden pattern is found.
+     */
+    validate(code: string, language: 'node' | 'python'): void;
+    /**
+     * 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: string, language: 'node' | 'python', whitelist: string[]): void;
+    /**
+     * Check Node.js require() calls against the whitelist.
+     * Built-in modules (fs, path, etc.) are always allowed.
+     */
+    private validateNodeImports;
+    /**
+     * 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).
+     */
+    private validatePythonImports;
+}
+export declare class CodeValidationError extends Error {
+    matchedPattern: string;
+    constructor(message: string, matchedPattern: string);
+}

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

@@ -0,0 +1,46 @@
+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;
+    agentLoopRunId?: string;
+    agentLoopStepId?: 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/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/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/SkillManager.d.ts

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

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

@@ -0,0 +1,22 @@
+export interface SkillPackageMetadata {
+    path: string;
+    metadata: Record<string, any>;
+    instructions: string;
+    code: string | null;
+}
+export declare class SkillRepositoryService {
+    private baseDir;
+    constructor(storagePath: string);
+    /**
+     * Extract a zip file to the repository.
+     * Returns parsed metadata from SKILL.md / skill.yaml
+     */
+    extractSkillPackage(skillName: string, zipFilePath: string): Promise<SkillPackageMetadata>;
+    getSkillPath(skillName: string): string;
+    getSkillCode(skillName: string): string | null;
+    copySkillPackageTo(skillName: string, destDir: string): void;
+    readSkillPackage(packageDir: string): SkillPackageMetadata;
+    copyDirectoryTo(srcDir: string, destDir: string): void;
+    private getSkillCodeFromDir;
+    private aggregateOtherMarkdownFiles;
+}

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

@@ -0,0 +1,26 @@
+import Application from '@nocobase/server';
+import { Database } from '@nocobase/database';
+type WorkerEnvConfig = {
+    npmRegistryUrl?: string;
+    npmAuthToken?: string;
+    pypiIndexUrl?: string;
+    pypiTrustedHost?: string;
+    aptMirrorUrl?: string;
+    aptGpgKeyUrl?: string;
+    customPackages?: {
+        python?: string[];
+        node?: string[];
+        apt?: string[];
+    };
+};
+export declare class WorkerEnvManager {
+    private readonly app;
+    private readonly db;
+    private readonly storagePath;
+    constructor(app: Application, db: Database, storagePath: string);
+    getOrCreateConfig(): Promise<any>;
+    initEnvironment(config: WorkerEnvConfig): Promise<string>;
+    executeInit(payload: WorkerEnvConfig): Promise<void>;
+    parsePackageWhitelist(config: any): Record<"node" | "python" | "apt", string[]>;
+}
+export {};

package/dist/server/skill-hub/actions/git-import.d.ts

@@ -0,0 +1,21 @@
+import { Context } from '@nocobase/actions';
+/**
+ * Git integration actions for skill-hub.
+ *
+ * Supported manifest shape:
+ * {
+ *   "skills": [
+ *     { "folder": "my-skill", "name": "my-skill", "language": "python" },
+ *     { "name": "pptx-advanced-export", "storageType": "plugin", "pluginSource": "pptx-advanced-export" }
+ *   ]
+ * }
+ */
+export declare function gitListSkills(ctx: Context, next: () => Promise<void>): Promise<void>;
+/**
+ * Sync selected skills from git into skillDefinitions.
+ *
+ * Code is optional. Regular git skills may provide code via codeTemplate,
+ * codeFile, or conventional files under skills/<folder>. Plugin skills only
+ * need storageType=plugin and pluginSource.
+ */
+export declare function gitSyncSkills(ctx: Context, next: () => Promise<void>): Promise<void>;

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/plugin.d.ts

@@ -0,0 +1,61 @@
+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 getSkillRecordId;
+    private resolveLoopInteractionSchema;
+    private getLoopConfigsBySkillId;
+    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;