plugin-agent-orchestrator 1.0.14 → 1.0.15

package/src/server/skill-hub/plugin.ts

@@ -95,14 +95,14 @@ export class SkillHubSubFeature {
     // 2. Init services
     const storagePath = resolve(process.cwd(), 'storage', 'plugin-skill-hub'); // Keep old storage path for backwards compatibility
     this.fileManager = new FileManager(storagePath);
-    this.sandboxRunner = new SandboxRunner(this.fileManager, this.app.logger, storagePath);
-    this.skillManager = new SkillManager(this.db);
-    this.workerEnvManager = new WorkerEnvManager(this.app, this.db, storagePath);
+    this.sandboxRunner = new SandboxRunner(this.fileManager, (this as any).app.logger, storagePath);
+    this.skillManager = new SkillManager((this as any).db);
+    this.workerEnvManager = new WorkerEnvManager((this as any).app, (this as any).db, storagePath);
     this.skillRepoService = new SkillRepositoryService(storagePath);
     this.mcpController = new McpController(this);
 
     // 3. Register REST actions
-    this.app.resourceManager.define({
+    (this as any).app.resourceManager.define({
       name: 'skillHub',
       actions: {
         download: this.handleDownload.bind(this),
@@ -119,7 +119,7 @@ export class SkillHubSubFeature {
 
 
     // 4.5. Register DB hooks for automatic storage physical cleanup
-    this.db.on('skillExecutions.afterDestroy', async (model, options) => {
+    (this as any).db.on('skillExecutions.afterDestroy', async (model, options) => {
       const execId = model.get('id');
       try {
         const dir = this.fileManager.getExecDir(String(execId));
@@ -127,29 +127,29 @@ export class SkillHubSubFeature {
           require('fs').rmSync(dir, { recursive: true, force: true });
         }
       } catch (err) {
-        this.app.logger.error(`[skill-hub] Failed to cleanup physical storage for execId ${execId}`, { error: err });
+        (this as any).app.logger.error(`[skill-hub] Failed to cleanup physical storage for execId ${execId}`, { error: err });
       }
     });
 
-    this.db.on('skillDefinitions.afterSave', async (model, options) => {
+    (this as any).db.on('skillDefinitions.afterSave', async (model, options) => {
       // If a zip file was uploaded, extract it and update the skill record
       if (model.changed('fileId') && model.get('fileId')) {
         try {
-          const attachment = await this.db.getRepository('attachments').findOne({
+          const attachment = await (this as any).db.getRepository('attachments').findOne({
             filter: { id: model.get('fileId') },
             transaction: options.transaction,
           });
 
           if (attachment) {
-            const fileManager = this.app.pm.get('@nocobase/plugin-file-manager') as any;
+            const fileManager = (this as any).app.pm.get('@nocobase/plugin-file-manager') as any;
             if (!fileManager) {
-              this.app.logger.warn('[skill-hub] plugin-file-manager not found, cannot extract skill package');
+              (this as any).app.logger.warn('[skill-hub] plugin-file-manager not found, cannot extract skill package');
               return;
             }
 
             const streamData = await fileManager.getFileStream(attachment);
             if (!streamData || !streamData.stream) {
-              this.app.logger.warn(`[skill-hub] Could not get file stream for attachment ${attachment.get('id')}`);
+              (this as any).app.logger.warn(`[skill-hub] Could not get file stream for attachment ${attachment.get('id')}`);
               return;
             }
 
@@ -179,54 +179,54 @@ export class SkillHubSubFeature {
               if (metadata.timeoutSeconds) updateValues.timeoutSeconds = metadata.timeoutSeconds;
               if (instructions) updateValues.instructions = instructions;
 
-              await this.db.getRepository('skillDefinitions').update({
+              await (this as any).db.getRepository('skillDefinitions').update({
                 filter: { id: model.get('id') },
                 values: updateValues,
                 transaction: options.transaction,
               });
               
               unlinkSync(tempZipPath);
-              this.app.logger.info(`[skill-hub] Successfully extracted zip and updated skill: ${skillName}`);
+              (this as any).app.logger.info(`[skill-hub] Successfully extracted zip and updated skill: ${skillName}`);
             }
           }
         } catch (err) {
-          this.app.logger.error(`[skill-hub] Failed to unpack skill zip`, { error: err });
+          (this as any).app.logger.error(`[skill-hub] Failed to unpack skill zip`, { error: err });
         }
       }
     });
 
     // 5. Subscribe PubSub — worker processes skill execution tasks
-    this.app.pubSubManager.subscribe('skill-hub.task', async (payload: any) => {
+    (this as any).app.pubSubManager.subscribe('skill-hub.task', async (payload: any) => {
       if (process.env.SKILL_HUB_SANDBOX === 'false') return;
       await this.onQueueTask(payload);
     });
 
     // 5b. Subscribe PubSub — worker processes init-env tasks
-    this.app.pubSubManager.subscribe('skill-hub.init-env', async (payload: any) => {
+    (this as any).app.pubSubManager.subscribe('skill-hub.init-env', async (payload: any) => {
       if (process.env.SKILL_HUB_SANDBOX === 'false') return;
       await this.workerEnvManager.executeInit(payload);
     });
 
     // 6. Register AI tools + subscriptions (deferred — after all plugins loaded)
-    this.app.on('afterStart', async () => {
+    (this as any).app.on('afterStart', async () => {
       this.registerAITools();
       this.startCleanupInterval();
       await this.subscribeInitEnvDone();
       // Ensure any newly added built-in skills are seeded automatically on upgrade/restart
       await this.skillManager.seedDefaults().catch((e) => {
-        this.app.logger.error(`[skill-hub] Failed to seed default skills: ${e.message}`);
+        (this as any).app.logger.error(`[skill-hub] Failed to seed default skills: ${e.message}`);
       });
     });
   }
 
   private async onQueueTask(message: { id: string }) {
-    this.app.logger.info(`[skill-hub] Worker received queue task: ${message.id}`);
-    const execution = await this.db.getRepository('skillExecutions').findOne({
+    (this as any).app.logger.info(`[skill-hub] Worker received queue task: ${message.id}`);
+    const execution = await (this as any).db.getRepository('skillExecutions').findOne({
       filter: { id: message.id },
       appends: ['skill'],
     });
     if (!execution) {
-      this.app.logger.warn(`[skill-hub] Task ${message.id} ignored: execution record not found.`);
+      (this as any).app.logger.warn(`[skill-hub] Task ${message.id} ignored: execution record not found.`);
       return;
     }
 
@@ -235,7 +235,7 @@ export class SkillHubSubFeature {
       this.sandboxRunner,
       this.fileManager,
       this.skillRepoService,
-      this.app,
+      (this as any).app,
     );
     await task.run();
   }
@@ -259,7 +259,7 @@ export class SkillHubSubFeature {
       }
     }
 
-    const execution = await this.db.getRepository('skillExecutions').create({
+    const execution = await (this as any).db.getRepository('skillExecutions').create({
       values: {
         skillId: skill.id,
         status: 'pending',
@@ -271,7 +271,7 @@ export class SkillHubSubFeature {
 
     const execId = String(execution.id);
 
-    this.app.logger.info(
+    (this as any).app.logger.info(
       `[skill-hub] Queued execution ${execId}: skill=${skill.get ? skill.get('name') : skill.name}, ` +
       `user=${userId || 'system'}`,
     );
@@ -317,10 +317,10 @@ export class SkillHubSubFeature {
       };
 
       // Subscribe progress and completion FIRST (before dispatching)
-      await this.app.pubSubManager.subscribe(progressChannel, progressCallback);
+      await (this as any).app.pubSubManager.subscribe(progressChannel, progressCallback);
       cleanups.push({ channel: progressChannel, callback: progressCallback });
 
-      await this.app.pubSubManager.subscribe(doneChannel, doneCallback);
+      await (this as any).app.pubSubManager.subscribe(doneChannel, doneCallback);
       cleanups.push({ channel: doneChannel, callback: doneCallback });
 
       // Handle user abort (cancel chat) → propagate to worker
@@ -329,9 +329,9 @@ export class SkillHubSubFeature {
         signal.addEventListener?.('abort', () => {
           clearTimeout(timeout);
           // Publish abort to worker via PubSub
-          this.app.pubSubManager.publish(abortChannel, { reason: 'user_cancel' }).catch(() => {});
+          (this as any).app.pubSubManager.publish(abortChannel, { reason: 'user_cancel' }).catch(() => {});
           // Also update the execution status
-          this.db.getRepository('skillExecutions').update({
+          (this as any).db.getRepository('skillExecutions').update({
             filter: { id: execId },
             values: { status: 'canceled' },
           }).catch(() => {});
@@ -340,7 +340,7 @@ export class SkillHubSubFeature {
       }
 
       // NOW Dispatch to worker via EventQueue
-      await this.app.pubSubManager.publish('skill-hub.task', { id: execId });
+      await (this as any).app.pubSubManager.publish('skill-hub.task', { id: execId });
 
       // Wait for completion
       result = await resultPromise;
@@ -348,7 +348,7 @@ export class SkillHubSubFeature {
       // Cleanup all PubSub subscriptions
       for (const { channel, callback } of cleanups) {
         try {
-          await this.app.pubSubManager.unsubscribe(channel, callback);
+          await (this as any).app.pubSubManager.unsubscribe(channel, callback);
         } catch {
           // ignore cleanup errors
         }
@@ -383,7 +383,7 @@ export class SkillHubSubFeature {
       ctx.throw(401, 'Unauthorized');
     }
 
-    const execution = await this.db.getRepository('skillExecutions').findOne({
+    const execution = await (this as any).db.getRepository('skillExecutions').findOne({
       filter: { id: execId },
     });
 
@@ -414,7 +414,7 @@ export class SkillHubSubFeature {
       ctx.throw(400, 'Missing skillId');
     }
 
-    const skill = await this.db.getRepository('skillDefinitions').findOne({
+    const skill = await (this as any).db.getRepository('skillDefinitions').findOne({
       filter: { id: skillId },
     });
     if (!skill) {
@@ -465,20 +465,20 @@ export class SkillHubSubFeature {
         if (data.status === 'succeeded' && data.whitelist) {
           values.packageWhitelist = stringifyJsonText(data.whitelist, { python: [], node: [], apt: [] });
         }
-        await this.db.getRepository('skillWorkerConfigs').update({
+        await (this as any).db.getRepository('skillWorkerConfigs').update({
           filter: {},
           values,
           forceUpdate: true,
         });
-        this.app.logger.info(`[skill-hub] Init env ${data.status}`);
+        (this as any).app.logger.info(`[skill-hub] Init env ${data.status}`);
       } catch (err) {
-        this.app.logger.warn('[skill-hub] Failed to update init env status:', err);
+        (this as any).app.logger.warn('[skill-hub] Failed to update init env status:', err);
       }
     };
     
     this.initEnvProgressCallback = async (data: any) => {
       try {
-        await this.db.getRepository('skillWorkerConfigs').update({
+        await (this as any).db.getRepository('skillWorkerConfigs').update({
           filter: {},
           values: {
             initProgressPercent: data.percent,
@@ -491,15 +491,15 @@ export class SkillHubSubFeature {
       }
     };
 
-    await this.app.pubSubManager.subscribe('skill-hub.init-env.done', this.initEnvDoneCallback);
-    await this.app.pubSubManager.subscribe('skill-hub.init-env.progress', this.initEnvProgressCallback);
+    await (this as any).app.pubSubManager.subscribe('skill-hub.init-env.done', this.initEnvDoneCallback);
+    await (this as any).app.pubSubManager.subscribe('skill-hub.init-env.progress', this.initEnvProgressCallback);
   }
 
   private registerAITools() {
     try {
-      const aiPlugin = this.app.pm.get('@nocobase/plugin-ai') as any;
+      const aiPlugin = (this as any).app.pm.get('@nocobase/plugin-ai') as any;
       if (!aiPlugin?.ai?.toolsManager) {
-        this.app.logger.warn('[skill-hub] plugin-ai not available, skip AI tool registration.');
+        (this as any).app.logger.warn('[skill-hub] plugin-ai not available, skip AI tool registration.');
         return;
       }
 
@@ -509,7 +509,7 @@ export class SkillHubSubFeature {
       // 2. Dynamic tools — each enabled skill becomes a separate AI tool.
       aiPlugin.ai.toolsManager.registerDynamicTools(async (register: { registerTools: (options: any) => void }) => {
         try {
-          const skills = await this.db.getRepository('skillDefinitions').find({
+          const skills = await (this as any).db.getRepository('skillDefinitions').find({
             filter: { enabled: true },
           });
 
@@ -539,7 +539,7 @@ export class SkillHubSubFeature {
               },
               invoke: async (toolCtx: any, args: any) => {
                 // Re-fetch skill to get latest version (hot-reload support)
-                const latestSkill = await this.db.getRepository('skillDefinitions').findOne({
+                const latestSkill = await (this as any).db.getRepository('skillDefinitions').findOne({
                   filter: { id: skill.get('id'), enabled: true },
                 });
                 if (!latestSkill) {
@@ -556,13 +556,13 @@ export class SkillHubSubFeature {
 
           register.registerTools(tools);
         } catch (err) {
-          this.app.logger.warn('[skill-hub] Failed to provide dynamic tools', err);
+          (this as any).app.logger.warn('[skill-hub] Failed to provide dynamic tools', err);
         }
       });
 
-      this.app.logger.info('[skill-hub] AI tools registered (dynamic provider + general tool).');
+      (this as any).app.logger.info('[skill-hub] AI tools registered (dynamic provider + general tool).');
     } catch (error) {
-      this.app.logger.warn('[skill-hub] Failed to register AI tools:', error);
+      (this as any).app.logger.warn('[skill-hub] Failed to register AI tools:', error);
     }
   }
 
@@ -573,13 +573,13 @@ export class SkillHubSubFeature {
     this.cleanupInterval = setInterval(async () => {
       // 1. Storage Retention Cleanup
       try {
-        const config = await this.db.getRepository('skillWorkerConfigs').findOne();
+        const config = await (this as any).db.getRepository('skillWorkerConfigs').findOne();
         const hours = config ? config.get('retentionHours') : 24;
         
         if (hours && hours > 0) {
           const MAX_AGE_MS = hours * 60 * 60 * 1000;
           const cutoff = new Date(Date.now() - MAX_AGE_MS);
-          const repo = this.db.getRepository('skillExecutions');
+          const repo = (this as any).db.getRepository('skillExecutions');
           
           const outdated = await repo.find({
             where: { createdAt: { $lt: cutoff } }
@@ -589,11 +589,11 @@ export class SkillHubSubFeature {
             for (const record of outdated) {
               await record.destroy(); // Fires afterDestroy hook which removes physical folder
             }
-            this.app.logger.info(`[skill-hub] Auto-cleaned up ${outdated.length} expired execution records`);
+            (this as any).app.logger.info(`[skill-hub] Auto-cleaned up ${outdated.length} expired execution records`);
           }
         }
       } catch (err) {
-        this.app.logger.warn('[skill-hub] Auto Cleanup error:', err);
+        (this as any).app.logger.warn('[skill-hub] Auto Cleanup error:', err);
       }
 
       // 2. Cleanup rate limiter stale entries
@@ -605,12 +605,12 @@ export class SkillHubSubFeature {
     // Unsubscribe PubSub
     if (this.initEnvDoneCallback) {
       try {
-        await this.app.pubSubManager.unsubscribe('skill-hub.init-env.done', this.initEnvDoneCallback);
+        await (this as any).app.pubSubManager.unsubscribe('skill-hub.init-env.done', this.initEnvDoneCallback);
       } catch { /* ignore */ }
     }
     if (this.initEnvProgressCallback) {
       try {
-        await this.app.pubSubManager.unsubscribe('skill-hub.init-env.progress', this.initEnvProgressCallback);
+        await (this as any).app.pubSubManager.unsubscribe('skill-hub.init-env.progress', this.initEnvProgressCallback);
       } catch { /* ignore */ }
     }
 
@@ -624,7 +624,7 @@ export class SkillHubSubFeature {
   // --- Handlers ---
   private async handleClearStorage(ctx: any, next: () => Promise<any>) {
     const { type } = ctx.request.body || ctx.action.params.values;
-    const repo = this.db.getRepository('skillExecutions');
+    const repo = (this as any).db.getRepository('skillExecutions');
     let count = 0;
 
     if (type === 'all') {
@@ -634,7 +634,7 @@ export class SkillHubSubFeature {
       }
       count = results.length;
     } else if (type === 'expired') {
-      const config = await this.db.getRepository('skillWorkerConfigs').findOne();
+      const config = await (this as any).db.getRepository('skillWorkerConfigs').findOne();
       const hours = config ? config.get('retentionHours') : 24;
       if (hours > 0) {
         const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000);
@@ -653,7 +653,7 @@ export class SkillHubSubFeature {
   private async handleListTemplates(ctx: any, next: () => Promise<any>) {
     // Dynamic Pull: discover templates from all active plugins in the system
     try {
-      const allPlugins = this.app.pm.getPlugins();
+      const allPlugins = (this as any).app.pm.getPlugins();
       for (const [, pluginInstance] of allPlugins) {
         if (typeof (pluginInstance as any).getSkillTemplates === 'function') {
           const pluginSkills = (pluginInstance as any).getSkillTemplates();
@@ -667,7 +667,7 @@ export class SkillHubSubFeature {
         }
       }
     } catch (e) {
-      this.app.logger.warn(`[skill-hub] Failed to discover some plugin skills: ${e.message}`);
+      (this as any).app.logger.warn(`[skill-hub] Failed to discover some plugin skills: ${e.message}`);
     }
 
     ctx.body = { data: Array.from(this.skillTemplates.values()) };
@@ -683,7 +683,7 @@ export class SkillHubSubFeature {
    */
   registerSkillTemplate(pluginName: string, skillDef: any) {
     this.skillTemplates.set(skillDef.name, this.hydrateSkillTemplate(pluginName, skillDef));
-    this.app.logger.info(`[skill-hub] Registered skill template "${skillDef.name}" from plugin "${pluginName}"`);
+    (this as any).app.logger.info(`[skill-hub] Registered skill template "${skillDef.name}" from plugin "${pluginName}"`);
   }
 
   resolveSkillTemplate(templateName: string) {
@@ -692,7 +692,7 @@ export class SkillHubSubFeature {
     if (cached) return cached;
 
     try {
-      const allPlugins = this.app.pm.getPlugins();
+      const allPlugins = (this as any).app.pm.getPlugins();
       for (const [, pluginInstance] of allPlugins) {
         if (typeof (pluginInstance as any).getSkillTemplates !== 'function') continue;
         const pluginSkills = (pluginInstance as any).getSkillTemplates();
@@ -705,7 +705,7 @@ export class SkillHubSubFeature {
         }
       }
     } catch (e: any) {
-      this.app.logger.warn(`[skill-hub] Failed to resolve plugin skill "${templateName}": ${e.message}`);
+      (this as any).app.logger.warn(`[skill-hub] Failed to resolve plugin skill "${templateName}": ${e.message}`);
     }
 
     return null;

package/src/server/skill-hub/tasks/SkillExecutionTask.ts

@@ -1,8 +1,10 @@
 import Application from '@nocobase/server';
-import { resolve } from 'path';
+import { cpSync, existsSync, readFileSync, rmSync } from 'fs';
+import { resolve, sep } from 'path';
 import { SandboxRunner } from '../../services/SandboxRunner';
 import { FileManager } from '../../services/FileManager';
 import { SkillRepositoryService } from '../../services/SkillRepositoryService';
+import { CodeValidator } from '../../services/CodeValidator';
 import { parseJsonText, stringifyJsonText } from '../utils/json-fields';
 
 /**
@@ -62,13 +64,13 @@ export class SkillExecutionTask {
     const abortController = new TaskAbortController();
     const abortChannel = `skill-hub.abort.${execId}`;
     const abortCallback = async () => {
-      this.app.logger.info(`[skill-hub] Task ${execId}: received abort signal`);
+      (this as any).app.logger.info(`[skill-hub] Task ${execId}: received abort signal`);
       abortController.abort();
     };
 
     try {
       // Subscribe to abort channel before starting execution
-      await this.app.pubSubManager.subscribe(abortChannel, abortCallback);
+      await (this as any).app.pubSubManager.subscribe(abortChannel, abortCallback);
 
       // Render code template with input args
       const inputArgs = parseJsonText(this.execution.get('inputArgs'), {});
@@ -84,7 +86,7 @@ export class SkillExecutionTask {
 
       if (storageType === 'plugin') {
         const pluginSkillName = (skill.get ? skill.get('pluginSource') : skill.pluginSource) || skillName;
-        const orchestratorPlugin = this.app.pm.get('plugin-agent-orchestrator') as any;
+        const orchestratorPlugin = (this as any).app.pm.get('plugin-agent-orchestrator') as any;
         const skillHub = orchestratorPlugin?.skillHub;
         let pluginTemplate = typeof skillHub?.resolveSkillTemplate === 'function'
           ? skillHub.resolveSkillTemplate(pluginSkillName)
@@ -92,7 +94,7 @@ export class SkillExecutionTask {
 
         // Fallback: discover dynamically if not cached (e.g. executed in worker before UI was loaded)
         if (!pluginTemplate && skillHub) {
-          const allPlugins = this.app.pm.getPlugins();
+          const allPlugins = (this as any).app.pm.getPlugins();
           for (const [, pInstance] of allPlugins) {
             if (typeof (pInstance as any).getSkillTemplates === 'function') {
               const pluginSkills = (pInstance as any).getSkillTemplates();
@@ -148,7 +150,7 @@ export class SkillExecutionTask {
       // Load package whitelist for import validation
       let packageWhitelist: string[] = [];
       try {
-        const workerConfig = await this.app.db.getRepository('skillWorkerConfigs').findOne();
+        const workerConfig = await (this as any).app.db.getRepository('skillWorkerConfigs').findOne();
         if (workerConfig) {
           const wl = parseJsonText(
             workerConfig.get ? workerConfig.get('packageWhitelist') : workerConfig.packageWhitelist,
@@ -167,8 +169,8 @@ export class SkillExecutionTask {
 
       // In multi-node setups, local cache might be missing on this specific worker node. Re-download from S3 if needed.
       if (!require('fs').existsSync(this.skillRepoService.getSkillPath(skillName)) && fileId) {
-        const fmPlugin = this.app.pm.get('@nocobase/plugin-file-manager') as any;
-        const attachment = await this.app.db.getRepository('attachments').findOne({ filter: { id: fileId } });
+        const fmPlugin = (this as any).app.pm.get('@nocobase/plugin-file-manager') as any;
+        const attachment = await (this as any).app.db.getRepository('attachments').findOne({ filter: { id: fileId } });
         if (fmPlugin && attachment) {
           try {
             const streamData = await fmPlugin.getFileStream(attachment);
@@ -183,12 +185,12 @@ export class SkillExecutionTask {
               });
               await this.skillRepoService.extractSkillPackage(skillName, tempZipPath);
               require('fs').unlinkSync(tempZipPath);
-              this.app.logger.info(
+              (this as any).app.logger.info(
                 `[skill-hub] Task ${execId}: Auto-restored skill package ${skillName} from S3/Storage`,
               );
             }
           } catch (fetchErr) {
-            this.app.logger.warn(
+            (this as any).app.logger.warn(
               `[skill-hub] Task ${execId}: Failed to fetch skill package ${skillName} from storage`,
               { error: fetchErr },
             );
@@ -212,10 +214,17 @@ export class SkillExecutionTask {
         packageWhitelist,
         onProgress: (progress) => {
           // Worker → PubSub → Main Server → runtime.writer → SSE → Client
-          this.app.pubSubManager.publish(`skill-hub.progress.${execId}`, progress);
+          (this as any).app.pubSubManager.publish(`skill-hub.progress.${execId}`, progress);
         },
       });
 
+      if (result.success) {
+        const installMessage = await this.installGeneratedSkillIfRequested(execId);
+        if (installMessage) {
+          result.stdout = [result.stdout, installMessage].filter(Boolean).join('\n');
+        }
+      }
+
       // Determine final status
       let status: string;
       if (result.canceled) {
@@ -235,7 +244,7 @@ export class SkillExecutionTask {
       });
 
       // Notify main server: task completed
-      await this.app.pubSubManager.publish(`skill-hub.done.${execId}`, {
+      await (this as any).app.pubSubManager.publish(`skill-hub.done.${execId}`, {
         status,
         stdout: result.stdout?.slice(0, 3000),
         stderr: result.stderr?.slice(0, 1000),
@@ -244,7 +253,7 @@ export class SkillExecutionTask {
       });
 
       // Log execution metrics
-      this.app.logger.info(
+      (this as any).app.logger.info(
         `[skill-hub] Execution ${execId} ${status}: ` +
           `skill=${skill.get ? skill.get('name') : skill.name}, ` +
           `language=${language}, ` +
@@ -260,18 +269,18 @@ export class SkillExecutionTask {
         stderr: errorMessage,
       });
 
-      await this.app.pubSubManager.publish(`skill-hub.done.${execId}`, {
+      await (this as any).app.pubSubManager.publish(`skill-hub.done.${execId}`, {
         status: 'failed',
         stderr: errorMessage,
         files: [],
         durationMs: 0,
       });
 
-      this.app.logger.error(`[skill-hub] Execution ${execId} error: ${errorMessage}`);
+      (this as any).app.logger.error(`[skill-hub] Execution ${execId} error: ${errorMessage}`);
     } finally {
       // Always cleanup abort subscription
       try {
-        await this.app.pubSubManager.unsubscribe(abortChannel, abortCallback);
+        await (this as any).app.pubSubManager.unsubscribe(abortChannel, abortCallback);
       } catch {
         // ignore cleanup errors
       }
@@ -294,4 +303,141 @@ export class SkillExecutionTask {
     code = code.replaceAll('{{skillDir}}', (skillDir || '').replace(/\\/g, '/'));
     return code;
   }
+
+  private async installGeneratedSkillIfRequested(execId: string): Promise<string | null> {
+    const manifestPath = this.fileManager.getOutputFilePath(execId, 'skill-hub-install.json');
+    if (!manifestPath) return null;
+
+    let manifest: any;
+    try {
+      manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    } catch (error) {
+      throw new Error(`Generated skill install manifest is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    if (!manifest?.autoInstall) return null;
+
+    const skill = manifest.skill || {};
+    const name = String(skill.name || '').trim();
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
+      throw new Error(`Generated skill name "${name}" is invalid. Use lowercase letters, numbers, and hyphens.`);
+    }
+
+    const language = skill.language;
+    if (language !== 'python' && language !== 'node') {
+      throw new Error(`Generated skill "${name}" has unsupported language "${language}".`);
+    }
+
+    if (!skill.codeTemplate) {
+      throw new Error(`Generated skill "${name}" is missing codeTemplate.`);
+    }
+
+    const validator = new CodeValidator();
+    validator.validate(skill.codeTemplate, language);
+    await this.validateGeneratedSkillPackages(name, language, skill.packages);
+
+    const outputDir = this.fileManager.getOutputDir(execId);
+    const outputRoot = resolve(outputDir);
+    const packageDirName = String(manifest.packageDir || name);
+    const packageDir = resolve(outputRoot, packageDirName);
+    if ((packageDir !== outputRoot && !packageDir.startsWith(outputRoot + sep)) || !existsSync(packageDir)) {
+      throw new Error(`Generated skill package directory "${packageDirName}" was not found in output.`);
+    }
+
+    if (manifest.testInput && Object.keys(manifest.testInput).length > 0) {
+      const verifyExecId = `${execId}-verify-${name}`;
+      const verifyCode = this.renderTemplate(skill.codeTemplate, manifest.testInput, verifyExecId, packageDir);
+      const verifyResult = await this.sandboxRunner.execute({
+        language,
+        code: verifyCode,
+        execId: verifyExecId,
+        timeoutSeconds: Math.min(Number(skill.timeoutSeconds || 60), 30),
+        maxOutputSizeMb: Math.min(Number(skill.maxOutputSizeMb || 50), 10),
+        skillDir: packageDir,
+      });
+
+      if (!verifyResult.success) {
+        throw new Error(
+          `Generated skill "${name}" failed smoke verification: ${verifyResult.stderr || verifyResult.stdout || 'unknown error'}`,
+        );
+      }
+    }
+
+    const skillRepoDir = this.skillRepoService.getSkillPath(name);
+    if (existsSync(skillRepoDir)) {
+      rmSync(skillRepoDir, { recursive: true, force: true });
+    }
+    cpSync(packageDir, skillRepoDir, {
+      recursive: true,
+      force: true,
+      filter: (src) => {
+        const leaf = src.split(/[\\/]/).pop();
+        return !['node_modules', '.git', '__pycache__'].includes(leaf || '') && !src.endsWith('.pyc');
+      },
+    });
+
+    const values: any = {
+      name,
+      title: skill.title || name,
+      description: skill.description || '',
+      instructions: skill.instructions || '',
+      language,
+      codeTemplate: skill.codeTemplate,
+      inputSchema: stringifyJsonText(skill.inputSchema || { type: 'object', properties: {} }),
+      packages: stringifyJsonText(skill.packages || [], []),
+      timeoutSeconds: skill.timeoutSeconds || 60,
+      maxOutputSizeMb: skill.maxOutputSizeMb || 50,
+      enabled: skill.enabled !== false,
+      toolScope: skill.toolScope || 'CUSTOM',
+      autoCall: !!skill.autoCall,
+      storageType: 'local',
+      storageUrl: `local://generated/${name}`,
+    };
+
+    if (skill.interactionSchema) {
+      values.interactionSchema = stringifyJsonText(skill.interactionSchema);
+    }
+
+    const repo = (this as any).app.db.getRepository('skillDefinitions');
+    const existing = await repo.findOne({ filter: { name } });
+    if (existing) {
+      if (manifest.overwrite === false) {
+        throw new Error(`Skill "${name}" already exists and overwrite=false.`);
+      }
+      await repo.update({ filter: { name }, values });
+      return `[skill-hub] Updated generated skill "${name}" in Skill Hub.`;
+    }
+
+    await repo.create({ values });
+    return `[skill-hub] Installed generated skill "${name}" in Skill Hub.`;
+  }
+
+  private async validateGeneratedSkillPackages(name: string, language: 'python' | 'node', packages: any) {
+    if (!Array.isArray(packages) || packages.length === 0) return;
+    if (!packages.every((pkg) => typeof pkg === 'string' && pkg.trim())) {
+      throw new Error(`Generated skill "${name}" has invalid packages. Use an array of package names.`);
+    }
+
+    const workerConfig = await (this as any).app.db.getRepository('skillWorkerConfigs').findOne();
+    if (!workerConfig) return;
+
+    const whitelist = parseJsonText(
+      workerConfig.get ? workerConfig.get('packageWhitelist') : workerConfig.packageWhitelist,
+      null,
+    );
+    const allowed = whitelist?.[language];
+    if (!Array.isArray(allowed) || allowed.length === 0) return;
+
+    const allowedSet = new Set(allowed.map((pkg: string) => pkg.toLowerCase()));
+    const missing = packages
+      .map((pkg: string) => pkg.trim())
+      .filter((pkg: string) => !allowedSet.has(pkg.toLowerCase()));
+
+    if (missing.length > 0) {
+      throw new Error(
+        `Generated skill "${name}" requires ${language} package(s) not available in the Skill Hub worker environment: ` +
+          `${missing.join(', ')}. Add them to the worker environment and refresh/init Skill Hub before installing this skill.`,
+      );
+    }
+  }
 }