plugin-agent-orchestrator 1.0.13 → 1.0.14

package/src/server/collections/skill-definitions.ts

@@ -0,0 +1,128 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'skillDefinitions',
+  title: 'Skill Definitions',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'name',
+      type: 'string',
+      length: 100,
+      unique: true,
+    },
+    {
+      name: 'title',
+      type: 'string',
+      length: 200,
+    },
+    {
+      name: 'description',
+      type: 'text',
+    },
+    {
+      name: 'instructions',
+      type: 'text',
+    },
+    {
+      // 'node' | 'python'
+      name: 'language',
+      type: 'string',
+      length: 20,
+    },
+    {
+      // Code template with {{placeholder}} support
+      name: 'codeTemplate',
+      type: 'text',
+    },
+    {
+      // JSON Schema for input parameters (used by AI tool)
+      name: 'inputSchema',
+      type: 'text',
+    },
+    {
+      // Optional UI schema for human-in-the-loop interaction.
+      // Shape: { type: 'form'|'select'|'confirm', prompt: string,
+      //          options?: {label,value}[], fields?: Record<string, {type,title,required,enum}> }
+      name: 'interactionSchema',
+      type: 'text',
+    },
+    {
+      // Pre-installed packages reference (informational)
+      name: 'packages',
+      type: 'text',
+      defaultValue: null,
+    },
+    {
+      name: 'timeoutSeconds',
+      type: 'integer',
+      defaultValue: 60,
+    },
+    {
+      name: 'maxOutputSizeMb',
+      type: 'integer',
+      defaultValue: 50,
+    },
+    {
+      name: 'enabled',
+      type: 'boolean',
+      defaultValue: true,
+    },
+    {
+      // 'CUSTOM' | 'GENERAL' | 'SPECIFIED'
+      name: 'toolScope',
+      type: 'string',
+      length: 20,
+      defaultValue: 'CUSTOM',
+    },
+    {
+      name: 'autoCall',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      // Which plugin registered this skill. null = built-in / user-created.
+      // Format: plugin package name, e.g. 'plugin-skill-pptx-advanced'
+      name: 'pluginSource',
+      type: 'string',
+      length: 200,
+      defaultValue: null,
+    },
+    {
+      name: 'storageType',
+      type: 'string',
+      length: 20,
+      defaultValue: 'database', // 'database', 'local', 's3', 'plugin'
+    },
+    {
+      name: 'storageUrl',
+      type: 'string',
+      length: 1000,
+    },
+    {
+      name: 'file',
+      type: 'belongsTo',
+      target: 'attachments',
+      foreignKey: 'fileId',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+    {
+      name: 'updatedAt',
+      type: 'date',
+    },
+    {
+      name: 'createdBy',
+      type: 'belongsTo',
+      target: 'users',
+      foreignKey: 'createdById',
+    },
+  ],
+} as CollectionOptions;

package/src/server/collections/skill-executions.ts

@@ -0,0 +1,94 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'skillExecutions',
+  title: 'Skill Executions',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'skill',
+      type: 'belongsTo',
+      target: 'skillDefinitions',
+      foreignKey: 'skillId',
+    },
+    {
+      // 'pending' | 'running' | 'succeeded' | 'failed' | 'canceled' | 'timeout'
+      name: 'status',
+      type: 'string',
+      length: 20,
+      defaultValue: 'pending',
+    },
+    {
+      name: 'inputArgs',
+      type: 'text',
+    },
+    {
+      // Final code after template rendering
+      name: 'executedCode',
+      type: 'text',
+    },
+    {
+      name: 'stdout',
+      type: 'text',
+    },
+    {
+      name: 'stderr',
+      type: 'text',
+    },
+    {
+      // [{ name, size, mimeType }]
+      name: 'outputFiles',
+      type: 'text',
+      defaultValue: null,
+    },
+    {
+      name: 'durationMs',
+      type: 'integer',
+    },
+    {
+      name: 'sessionId',
+      type: 'string',
+      length: 100,
+      allowNull: true,
+    },
+    {
+      name: 'orchestratorRootRunId',
+      type: 'string',
+      length: 100,
+      allowNull: true,
+    },
+    {
+      name: 'orchestratorSpanId',
+      type: 'string',
+      length: 100,
+      allowNull: true,
+    },
+    {
+      name: 'orchestratorParentSpanId',
+      type: 'string',
+      length: 100,
+      allowNull: true,
+    },
+    {
+      name: 'orchestratorToolCallId',
+      type: 'string',
+      length: 100,
+      allowNull: true,
+    },
+    {
+      name: 'triggeredBy',
+      type: 'belongsTo',
+      target: 'users',
+      foreignKey: 'triggeredById',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+  ],
+} as CollectionOptions;

package/src/server/collections/skill-worker-configs.ts

@@ -0,0 +1,86 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'skillWorkerConfigs',
+  title: 'Skill Worker Configs',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'retentionHours',
+      type: 'integer',
+      defaultValue: 24,
+    },
+    {
+      name: 'packageWhitelist',
+      type: 'text',
+      defaultValue: null,
+    },
+    {
+      name: 'customPackages',
+      type: 'text',
+      defaultValue: null,
+    },
+    {
+      name: 'npmRegistryUrl',
+      type: 'string',
+      length: 500,
+    },
+    {
+      name: 'npmAuthToken',
+      type: 'string',
+      length: 1000,
+    },
+    {
+      name: 'pypiIndexUrl',
+      type: 'string',
+      length: 500,
+    },
+    {
+      name: 'pypiTrustedHost',
+      type: 'string',
+      length: 255,
+    },
+    {
+      name: 'aptMirrorUrl',
+      type: 'string',
+      length: 500,
+    },
+    {
+      name: 'aptGpgKeyUrl',
+      type: 'string',
+      length: 500,
+    },
+    {
+      name: 'initStatus',
+      type: 'string',
+      length: 20,
+      defaultValue: 'idle',
+    },
+    {
+      name: 'lastInitLog',
+      type: 'text',
+    },
+    {
+      name: 'initProgressPercent',
+      type: 'integer',
+      defaultValue: 0,
+    },
+    {
+      name: 'initProgressLog',
+      type: 'text',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+    {
+      name: 'updatedAt',
+      type: 'date',
+    },
+  ],
+} as CollectionOptions;

package/src/server/migrations/20260423000000-add-progress-fields.ts

@@ -0,0 +1,50 @@
+import { Migration } from '@nocobase/server';
+
+export default class AddProgressFieldsMigration extends Migration {
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tablePrefix = this.db.options.tablePrefix || '';
+    const tableName = `${tablePrefix}skillWorkerConfigs`;
+
+    try {
+      const tableExists = await queryInterface.tableExists(tableName);
+      if (!tableExists) return;
+
+      const tableDesc = await queryInterface.describeTable(tableName);
+
+      // Force NocoBase fields metadata to recognize the physical columns exists
+      // so it won't crash trying to ADD COLUMN during db.sync()
+      const fieldRepo = this.db.getRepository('fields');
+      const collectionName = 'skillWorkerConfigs';
+
+      const fieldsToSync = [
+        { name: 'initProgressPercent', type: 'integer', defaultValue: 0 },
+        { name: 'initProgressLog', type: 'text' }
+      ];
+
+      for (const f of fieldsToSync) {
+        const fieldMeta = await fieldRepo.findOne({
+          filter: { name: f.name, collectionName },
+        });
+
+        if (!fieldMeta && tableDesc[f.name]) {
+           // The physical column exists, but NocoBase metadata is missing it!
+           // Let's create the metadata right now BEFORE NocoBase's collection.sync() 
+           // runs and crashes on addColumn.
+           await fieldRepo.create({
+              values: {
+                 name: f.name,
+                 type: f.type,
+                 collectionName,
+                 // Avoid trying to physically add it because it already exists
+                 interface: f.type,
+              }
+           });
+           this.app.logger.info(`[skill-hub] Restored NocoBase metadata for preexisting column ${f.name}`);
+        }
+      }
+    } catch (error) {
+      this.app.logger.error(`[skill-hub] Failed to check progress fields: ${error.message}`);
+    }
+  }
+}

package/src/server/migrations/20260425000000-add-interaction-schema.ts

@@ -0,0 +1,35 @@
+import { Migration } from '@nocobase/server';
+
+export default class AddInteractionSchemaMigration extends Migration {
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tableName = `${this.db.options.tablePrefix || ''}skillDefinitions`;
+
+    try {
+      const tableExists = await queryInterface.tableExists(tableName);
+      if (!tableExists) return;
+
+      const tableDesc = await queryInterface.describeTable(tableName);
+      const fieldRepo = this.db.getRepository('fields');
+      const collectionName = 'skillDefinitions';
+
+      const fieldMeta = await fieldRepo.findOne({
+        filter: { name: 'interactionSchema', collectionName },
+      });
+
+      if (!fieldMeta && tableDesc.interactionSchema) {
+        await fieldRepo.create({
+          values: {
+            name: 'interactionSchema',
+            type: 'text',
+            collectionName,
+            interface: 'textarea',
+          },
+        });
+        this.app.logger.info('[skill-hub] Restored NocoBase metadata for preexisting column interactionSchema');
+      }
+    } catch (error) {
+      this.app.logger.error(`[skill-hub] Failed to check interactionSchema field: ${error.message}`);
+    }
+  }
+}

package/src/server/migrations/20260427000000-change-packages-to-text.ts

@@ -0,0 +1,47 @@
+import { Migration } from '@nocobase/server';
+
+export default class ChangePackagesToTextMigration extends Migration {
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tableName = `${this.db.options.tablePrefix || ''}skillDefinitions`;
+
+    try {
+      const tableExists = await queryInterface.tableExists(tableName);
+      if (!tableExists) return;
+
+      const tableDesc = await queryInterface.describeTable(tableName);
+      const columnsToChange = ['packages', 'inputSchema', 'interactionSchema'];
+      const fieldRepo = this.db.getRepository('fields');
+      const collectionName = 'skillDefinitions';
+
+      for (const col of columnsToChange) {
+        if (tableDesc[col]) {
+          // Change physical column type in Postgres if needed
+          const dialect = this.db.sequelize.getDialect();
+          if (dialect === 'postgres') {
+            await this.db.sequelize.query(`ALTER TABLE "${tableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`);
+          } else {
+            await queryInterface.changeColumn(tableName, col, {
+              type: 'TEXT',
+            });
+          }
+          
+          // Also update NocoBase metadata
+          const fieldMeta = await fieldRepo.findOne({
+            filter: { name: col, collectionName },
+          });
+
+          if (fieldMeta) {
+            await fieldRepo.update({
+              filterByTk: fieldMeta.get('id'),
+              values: { type: 'text' },
+            });
+          }
+          this.app.logger.info(`[skill-hub] Changed ${col} column type to text to support markdown`);
+        }
+      }
+    } catch (error) {
+      this.app.logger.error(`[skill-hub] Failed to change packages field type: ${error.message}`);
+    }
+  }
+}

package/src/server/migrations/20260427000001-change-other-json-to-text.ts

@@ -0,0 +1,57 @@
+import { Migration } from '@nocobase/server';
+
+export default class ChangeOtherJsonToTextMigration extends Migration {
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const dialect = this.db.sequelize.getDialect();
+    const fieldRepo = this.db.getRepository('fields');
+
+    const tablePrefix = this.db.options.tablePrefix || '';
+    
+    // 1. skillWorkerConfigs
+    const workerTableName = `${tablePrefix}skillWorkerConfigs`;
+    try {
+      if (await queryInterface.tableExists(workerTableName)) {
+        const tableDesc = await queryInterface.describeTable(workerTableName);
+        const columns = ['packageWhitelist', 'customPackages'];
+        
+        for (const col of columns) {
+          if (tableDesc[col]) {
+            if (dialect === 'postgres') {
+              await this.db.sequelize.query(`ALTER TABLE "${workerTableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`);
+            } else {
+              await queryInterface.changeColumn(workerTableName, col, { type: 'TEXT' });
+            }
+            const fieldMeta = await fieldRepo.findOne({ filter: { name: col, collectionName: 'skillWorkerConfigs' } });
+            if (fieldMeta) await fieldRepo.update({ filterByTk: fieldMeta.get('id'), values: { type: 'text' } });
+            this.app.logger.info(`[skill-hub] Changed ${col} in skillWorkerConfigs to text`);
+          }
+        }
+      }
+    } catch (e) {
+      this.app.logger.warn(`[skill-hub] Failed to migrate skillWorkerConfigs: ${e.message}`);
+    }
+
+    // 2. skillExecutions
+    const execTableName = `${tablePrefix}skillExecutions`;
+    try {
+      if (await queryInterface.tableExists(execTableName)) {
+        const tableDesc = await queryInterface.describeTable(execTableName);
+        const col = 'outputFiles';
+        
+        if (tableDesc[col]) {
+          if (dialect === 'postgres') {
+            await this.db.sequelize.query(`ALTER TABLE "${execTableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`);
+          } else {
+            await queryInterface.changeColumn(execTableName, col, { type: 'TEXT' });
+          }
+          const fieldMeta = await fieldRepo.findOne({ filter: { name: col, collectionName: 'skillExecutions' } });
+          if (fieldMeta) await fieldRepo.update({ filterByTk: fieldMeta.get('id'), values: { type: 'text' } });
+          this.app.logger.info(`[skill-hub] Changed ${col} in skillExecutions to text`);
+        }
+      }
+    } catch (e) {
+      this.app.logger.warn(`[skill-hub] Failed to migrate skillExecutions: ${e.message}`);
+    }
+  }
+}

package/src/server/migrations/20260429000000-add-llm-fields.ts

@@ -29,6 +29,15 @@ export default class AddLlmFieldsToOrchestratorConfig extends Migration {
       });
       console.log(`[AgentOrchestrator] Added model column to ${tableName}`);
     }
+
+    if (!tableDesc['recursionLimit']) {
+      await queryInterface.addColumn(tableName, 'recursionLimit', {
+        type: 'INTEGER',
+        allowNull: true,
+        defaultValue: 50,
+      });
+      console.log(`[AgentOrchestrator] Added recursionLimit column to ${tableName}`);
+    }
   }
 
   async down() {

package/src/server/migrations/20260429000000-fix-inputargs-json-to-text.ts

@@ -0,0 +1,38 @@
+import { Migration } from '@nocobase/server';
+
+/**
+ * Fix: inputArgs column in skillExecutions was json type but should be text.
+ *
+ * Root cause: The column was created as `json` from an older schema version,
+ * but the collection defines it as `text`. The `stringifyJsonText()` utility
+ * wraps values in markdown code fences (```json\n...\n```) which PostgreSQL
+ * rejects as invalid JSON syntax, causing SequelizeDatabaseError on every
+ * skill execution attempt.
+ */
+export default class FixInputArgsJsonToText extends Migration {
+  on = 'afterLoad';
+  appVersion = '>=0.1.0';
+
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+
+    // Check current column type
+    const tableDesc = await queryInterface.describeTable('skillExecutions').catch(() => null);
+    if (!tableDesc) return;
+
+    const col = tableDesc['inputArgs'];
+    if (!col) return;
+
+    // Only migrate if still json type
+    if (col.type && col.type.toLowerCase().includes('json')) {
+      await this.db.sequelize.query(
+        `ALTER TABLE "skillExecutions" ALTER COLUMN "inputArgs" TYPE text USING "inputArgs"::text`,
+      );
+      console.log('[skill-hub] Migration: converted skillExecutions.inputArgs from json to text');
+    }
+  }
+
+  async down() {
+    // No rollback — keeping as text is safe; json is more restrictive
+  }
+}

package/src/server/migrations/20260503000000-add-orchestrator-trace-fields.ts

@@ -0,0 +1,32 @@
+import { Migration } from '@nocobase/server';
+
+export default class AddOrchestratorTraceFieldsToSkillExecutions extends Migration {
+  on = 'afterLoad';
+  appVersion = '>=0.1.0';
+
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tablePrefix = this.db.options.tablePrefix || '';
+    const tableName = `${tablePrefix}skillExecutions`;
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+
+    const tableDesc = await queryInterface.describeTable(tableName);
+    const addIfMissing = async (name: string) => {
+      if (tableDesc[name]) return;
+      await queryInterface.addColumn(tableName, name, {
+        type: 'VARCHAR(100)',
+        allowNull: true,
+      });
+    };
+
+    await addIfMissing('orchestratorRootRunId');
+    await addIfMissing('orchestratorSpanId');
+    await addIfMissing('orchestratorParentSpanId');
+    await addIfMissing('orchestratorToolCallId');
+  }
+
+  async down() {
+    // No rollback: keeping nullable trace-link columns is safe.
+  }
+}

package/src/server/plugin.ts

@@ -2,20 +2,33 @@ import { Plugin } from '@nocobase/server';
 import path from 'path';
 import { createDelegateToolsProvider } from './tools/delegate-task';
 import { registerTracingResource } from './resources/tracing';
+import SkillHubSubFeature from './skill-hub/plugin';
 
 export class PluginAgentOrchestratorServer extends Plugin {
-  async afterAdd() {}
+  skillHub: SkillHubSubFeature;
+
+  async afterAdd() {
+    this.skillHub = new SkillHubSubFeature(this);
+  }
 
   async beforeLoad() {
     // Import collection definitions
     this.db.import({ directory: path.resolve(__dirname, 'collections') });
+
+    this.db.addMigrations({
+      namespace: this.name,
+      directory: path.resolve(__dirname, 'migrations'),
+      context: { plugin: this },
+    });
   }
 
   async load() {
+    await this.skillHub.load();
+
     // --- ACL ---
     this.app.acl.registerSnippet({
       name: `pm.${this.name}`,
-      actions: ['orchestratorConfig:*'],
+      actions: ['orchestratorConfig:*', 'orchestratorTracing:*', 'agentExecutionSpans:*', 'skillDefinitions:*', 'skillExecutions:*', 'skillHub:*', 'skillWorkerConfigs:*'],
     });
 
     // --- Register Dynamic Tools ---
@@ -29,18 +42,53 @@ export class PluginAgentOrchestratorServer extends Plugin {
     // Custom read-only resource for the Swarm Tracing admin page.
     registerTracingResource(this);
 
+    // --- Log Retention ---
+    // Daily prune of orchestratorLogs / agentExecutionSpans to keep tables bounded.
+    // Override window via env: ORCHESTRATOR_LOG_RETENTION_DAYS (default 30).
+    this.app.cronJobManager.addJob({
+      cronTime: '0 30 2 * * *',
+      onTick: async () => {
+        try {
+          const days = Number(process.env.ORCHESTRATOR_LOG_RETENTION_DAYS || 30);
+          if (!Number.isFinite(days) || days <= 0) return;
+          const cutoff = new Date(Date.now() - days * 86400000);
+          const repo = this.db.getRepository('orchestratorLogs');
+          const spansRepo = this.db.getRepository('agentExecutionSpans');
+          const deletedLogs = repo
+            ? await repo.destroy({
+                filter: { createdAt: { $lt: cutoff.toISOString() } },
+              })
+            : 0;
+          const deletedSpans = spansRepo
+            ? await spansRepo.destroy({
+                filter: { createdAt: { $lt: cutoff.toISOString() } },
+              })
+            : 0;
+          this.app.log.info(
+            `[AgentOrchestrator] Pruned ${deletedLogs} orchestratorLogs and ${deletedSpans} agentExecutionSpans rows older than ${days} day(s).`,
+          );
+        } catch (e) {
+          this.app.log.error('[AgentOrchestrator] Log retention job failed', e);
+        }
+      },
+    });
+
     // NOTE: The createReactAgent approach does NOT create aiConversation records,
     // so there is no need for a middleware to hide "headless" conversations.
     // If future versions need conversation logging, add it here.
   }
 
   async install() {
-    // No seed data needed on first install
+    await this.skillHub.install();
   }
 
   async afterEnable() {}
   async afterDisable() {}
   async remove() {}
+  
+  async beforeStop() {
+    await this.skillHub.beforeStop();
+  }
 }
 
 export default PluginAgentOrchestratorServer;