@exaudeus/workrail 0.8.5 → 0.9.0

package/dist/infrastructure/storage/git-workflow-storage.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMMUNITY_WORKFLOW_REPOS = exports.GitWorkflowStorage = void 0;
+exports.GitWorkflowStorage = void 0;
+const workflow_1 = require("../../types/workflow");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const path_1 = __importDefault(require("path"));
@@ -16,16 +17,17 @@ const logger_1 = require("../../utils/logger");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 const logger = (0, logger_1.createLogger)('GitWorkflowStorage');
 class GitWorkflowStorage {
-    constructor(config) {
+    constructor(config, source) {
+        this.kind = 'single';
         this.lastSync = 0;
         this.isCloning = false;
         this.config = this.validateAndNormalizeConfig(config);
         this.localPath = this.config.localPath;
+        this.source = source ?? (0, workflow_1.createGitRepositorySource)(this.config.repositoryUrl, this.config.branch, this.localPath);
         logger.info('Git workflow storage initialized', {
             repositoryUrl: this.config.repositoryUrl,
             branch: this.config.branch,
-            localPath: this.localPath,
-            syncInterval: this.config.syncInterval
+            localPath: this.localPath
         });
     }
     validateAndNormalizeConfig(config) {
@@ -39,8 +41,7 @@ class GitWorkflowStorage {
             maxFileSizeBytes: config.maxFileSize || 1024 * 1024
         });
         const defaultCacheDir = path_1.default.join(os_1.default.homedir(), '.workrail', 'cache');
-        const localPath = config.localPath ||
-            path_1.default.join(defaultCacheDir, 'community-workflows');
+        const localPath = config.localPath || path_1.default.join(defaultCacheDir, 'community-workflows');
         if (!config.skipSandboxCheck) {
             try {
                 const safeBaseDir = config.localPath
@@ -64,27 +65,27 @@ class GitWorkflowStorage {
     }
     isValidGitUrl(url) {
         const sshPattern = /^git@[\w.-]+:[\w\/-]+\.git$/;
-        if (sshPattern.test(url)) {
+        if (sshPattern.test(url))
             return true;
-        }
-        if (url.startsWith('ssh://')) {
+        if (url.startsWith('ssh://'))
             return true;
-        }
-        if (url.startsWith('/') || url.startsWith('file://')) {
+        if (url.startsWith('/') || url.startsWith('file://'))
             return true;
-        }
         try {
             const parsed = new URL(url);
-            const allowedHosts = [
-                'github.com', 'gitlab.com', 'bitbucket.org',
-                'dev.azure.com', 'sourceforge.net'
-            ];
             if (parsed.protocol === 'https:' || parsed.protocol === 'git:') {
-                return allowedHosts.some(host => parsed.hostname === host || parsed.hostname.endsWith(`.${host}`));
-            }
-            if (parsed.protocol === 'file:') {
+                const hostname = parsed.hostname;
+                const pathname = parsed.pathname;
+                if (!hostname || hostname.length === 0)
+                    return false;
+                if (!pathname || pathname === '/')
+                    return false;
+                if (hostname.includes('..') || pathname.includes('..'))
+                    return false;
                 return true;
             }
+            if (parsed.protocol === 'file:')
+                return true;
             return false;
         }
         catch {
@@ -111,7 +112,6 @@ class GitWorkflowStorage {
             }
             const files = await promises_1.default.readdir(workflowsPath);
             const jsonFiles = files.filter(f => f.endsWith('.json'));
-            logger.debug('Found workflow files', { count: jsonFiles.length });
             if (jsonFiles.length > this.config.maxFiles) {
                 throw new error_handler_1.StorageError(`Too many workflow files (${jsonFiles.length}), maximum allowed: ${this.config.maxFiles}`);
             }
@@ -123,13 +123,12 @@ class GitWorkflowStorage {
                     const stats = await promises_1.default.stat(filePath);
                     (0, storage_security_1.validateFileSize)(stats.size, this.config.maxFileSize, file);
                     const content = await promises_1.default.readFile(filePath, 'utf-8');
-                    const workflow = JSON.parse(content);
-                    const expectedFilename = `${(0, storage_security_1.sanitizeId)(workflow.id)}.json`;
+                    const definition = JSON.parse(content);
+                    const expectedFilename = `${(0, storage_security_1.sanitizeId)(definition.id)}.json`;
                     if (file !== expectedFilename) {
-                        throw new error_handler_1.InvalidWorkflowError(workflow.id, `Workflow ID '${workflow.id}' doesn't match filename '${file}'`);
+                        throw new error_handler_1.InvalidWorkflowError(definition.id, `Workflow ID '${definition.id}' doesn't match filename '${file}'`);
                     }
-                    workflows.push(workflow);
-                    logger.debug('Loaded workflow', { id: workflow.id, name: workflow.name });
+                    workflows.push((0, workflow_1.createWorkflow)(definition, this.source));
                 }
                 catch (error) {
                     if (error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.InvalidWorkflowError) {
@@ -140,15 +139,12 @@ class GitWorkflowStorage {
             }
             logger.info('Successfully loaded workflows from Git repository', {
                 repositoryUrl: this.config.repositoryUrl,
-                count: workflows.length,
-                workflows: workflows.map(w => ({ id: w.id, name: w.name }))
+                count: workflows.length
             });
             return workflows;
         }
         catch (error) {
-            logger.error('Failed to load workflows from Git repository', error, {
-                repositoryUrl: this.config.repositoryUrl
-            });
+            logger.error('Failed to load workflows from Git repository', error);
             if (error instanceof error_handler_1.StorageError || error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.InvalidWorkflowError) {
                 throw error;
             }
@@ -158,23 +154,17 @@ class GitWorkflowStorage {
     async getWorkflowById(id) {
         const sanitizedId = (0, storage_security_1.sanitizeId)(id);
         const workflows = await this.loadAllWorkflows();
-        return workflows.find(w => w.id === sanitizedId) || null;
+        return workflows.find(w => w.definition.id === sanitizedId) || null;
     }
     async listWorkflowSummaries() {
         const workflows = await this.loadAllWorkflows();
-        return workflows.map(workflow => ({
-            id: workflow.id,
-            name: workflow.name,
-            description: workflow.description,
-            category: 'community',
-            version: workflow.version
-        }));
+        return workflows.map(workflow_1.toWorkflowSummary);
     }
-    async save(workflow) {
+    async save(definition) {
         try {
-            const sanitizedId = (0, storage_security_1.sanitizeId)(workflow.id);
-            if (workflow.id !== sanitizedId) {
-                throw new error_handler_1.InvalidWorkflowError(workflow.id, `Invalid workflow ID: ${workflow.id}`);
+            const sanitizedId = (0, storage_security_1.sanitizeId)(definition.id);
+            if (definition.id !== sanitizedId) {
+                throw new error_handler_1.InvalidWorkflowError(definition.id, `Invalid workflow ID: ${definition.id}`);
             }
             await this.ensureRepository();
             const workflowsPath = path_1.default.join(this.localPath, 'workflows');
@@ -182,10 +172,10 @@ class GitWorkflowStorage {
             const filename = `${sanitizedId}.json`;
             const filePath = path_1.default.join(workflowsPath, filename);
             (0, storage_security_1.assertWithinBase)(filePath, workflowsPath);
-            const content = JSON.stringify(workflow, null, 2);
-            (0, storage_security_1.validateFileSize)(Buffer.byteLength(content, 'utf-8'), this.config.maxFileSize, workflow.id);
+            const content = JSON.stringify(definition, null, 2);
+            (0, storage_security_1.validateFileSize)(Buffer.byteLength(content, 'utf-8'), this.config.maxFileSize, definition.id);
             await promises_1.default.writeFile(filePath, content);
-            await this.gitCommitAndPush(workflow);
+            await this.gitCommitAndPush(definition);
         }
         catch (error) {
             if (error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.InvalidWorkflowError) {
@@ -209,9 +199,8 @@ class GitWorkflowStorage {
         }
         const shouldSync = !(0, fs_1.existsSync)(this.localPath) ||
             (Date.now() - this.lastSync) > (this.config.syncInterval * 60 * 1000);
-        if (!shouldSync) {
+        if (!shouldSync)
             return;
-        }
         this.isCloning = true;
         try {
             if (!(0, fs_1.existsSync)(this.localPath)) {
@@ -232,97 +221,70 @@ class GitWorkflowStorage {
     async cloneRepository() {
         logger.info('Cloning Git repository', {
             repositoryUrl: this.config.repositoryUrl,
-            branch: this.config.branch,
-            localPath: this.localPath
+            branch: this.config.branch
         });
         const parentDir = path_1.default.dirname(this.localPath);
         await promises_1.default.mkdir(parentDir, { recursive: true });
         let cloneUrl = this.config.repositoryUrl;
         if (cloneUrl.startsWith('/')) {
             cloneUrl = `file://${cloneUrl}`;
-            logger.debug('Converted local path to file:// URL', { cloneUrl });
         }
         if (!this.isSshUrl(this.config.repositoryUrl) && this.config.authToken && cloneUrl.startsWith('https://')) {
             cloneUrl = cloneUrl.replace('https://', `https://${this.config.authToken}@`);
-            logger.debug('Injected auth token into URL');
         }
         const escapedUrl = this.escapeShellArg(cloneUrl);
         const escapedBranch = this.escapeShellArg(this.config.branch);
         const escapedPath = this.escapeShellArg(this.localPath);
         let command = `git clone --branch ${escapedBranch} ${escapedUrl} ${escapedPath}`;
         try {
-            logger.debug('Executing git clone', { branch: this.config.branch });
             await execAsync(command, { timeout: 60000 });
             logger.info('Successfully cloned repository', { branch: this.config.branch });
         }
         catch (error) {
             const errorMsg = error.message;
             if (errorMsg.includes('Remote branch') && errorMsg.includes('not found')) {
-                logger.warn('Requested branch not found, trying default branch', {
-                    requestedBranch: this.config.branch
-                });
                 command = `git clone ${escapedUrl} ${escapedPath}`;
                 try {
                     await execAsync(command, { timeout: 60000 });
                     const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd: this.localPath });
-                    const actualBranch = stdout.trim();
-                    logger.info('Successfully cloned with default branch', {
-                        requestedBranch: this.config.branch,
-                        actualBranch
-                    });
-                    this.config.branch = actualBranch;
+                    this.config.branch = stdout.trim();
                 }
                 catch (fallbackError) {
-                    logger.error('Failed to clone repository with fallback', fallbackError);
                     throw new error_handler_1.StorageError(`Failed to clone workflow repository: ${fallbackError.message}`);
                 }
             }
             else {
-                logger.error('Failed to clone repository', error, { branch: this.config.branch });
                 throw new error_handler_1.StorageError(`Failed to clone workflow repository: ${errorMsg}`);
             }
         }
     }
     async pullRepository() {
-        logger.debug('Pulling latest changes from Git repository', {
-            branch: this.config.branch,
-            localPath: this.localPath
-        });
         const escapedPath = this.escapeShellArg(this.localPath);
         const escapedBranch = this.escapeShellArg(this.config.branch);
         try {
-            const fetchCommand = `cd ${escapedPath} && git fetch origin ${escapedBranch}`;
-            const resetCommand = `cd ${escapedPath} && git reset --hard origin/${escapedBranch}`;
-            await execAsync(fetchCommand, { timeout: 30000 });
-            await execAsync(resetCommand, { timeout: 30000 });
-            logger.info('Successfully updated repository', { branch: this.config.branch });
+            await execAsync(`cd ${escapedPath} && git fetch origin ${escapedBranch}`, { timeout: 30000 });
+            await execAsync(`cd ${escapedPath} && git reset --hard origin/${escapedBranch}`, { timeout: 30000 });
         }
-        catch (error) {
+        catch {
             try {
-                const pullCommand = `cd ${escapedPath} && git pull origin ${escapedBranch}`;
-                await execAsync(pullCommand, { timeout: 30000 });
-                logger.info('Successfully updated repository via pull', { branch: this.config.branch });
+                await execAsync(`cd ${escapedPath} && git pull origin ${escapedBranch}`, { timeout: 30000 });
             }
             catch (pullError) {
-                logger.warn('Git pull failed, using cached version', pullError, {
-                    repositoryUrl: this.config.repositoryUrl,
-                    branch: this.config.branch
-                });
+                logger.warn('Git pull failed, using cached version', pullError);
             }
         }
     }
-    async gitCommitAndPush(workflow) {
+    async gitCommitAndPush(definition) {
         const escapedPath = this.escapeShellArg(this.localPath);
-        const escapedFilename = this.escapeShellArg(`workflows/${workflow.id}.json`);
-        const escapedMessage = this.escapeShellArg(`Add/update workflow: ${workflow.name}`);
+        const escapedFilename = this.escapeShellArg(`workflows/${definition.id}.json`);
+        const escapedMessage = this.escapeShellArg(`Add/update workflow: ${definition.name}`);
         const escapedBranch = this.escapeShellArg(this.config.branch);
-        const commands = [
+        const command = [
             `cd ${escapedPath}`,
             `git add ${escapedFilename}`,
             `git commit -m ${escapedMessage}`,
             `git push origin ${escapedBranch}`
-        ];
-        const command = commands.join(' && ');
+        ].join(' && ');
         try {
             await execAsync(command, { timeout: 60000 });
         }
@@ -335,20 +297,3 @@ class GitWorkflowStorage {
     }
 }
 exports.GitWorkflowStorage = GitWorkflowStorage;
-exports.COMMUNITY_WORKFLOW_REPOS = {
-    official: {
-        repositoryUrl: 'https://github.com/EtienneBBeaulac/workrail-community-workflows.git',
-        branch: 'main',
-        syncInterval: 60,
-        maxFileSize: 1024 * 1024,
-        maxFiles: 100
-    },
-    personal: {
-        repositoryUrl: 'https://github.com/username/my-workflows.git',
-        branch: 'main',
-        syncInterval: 30,
-        authToken: process.env['GITHUB_TOKEN'],
-        maxFileSize: 1024 * 1024,
-        maxFiles: 50
-    }
-};

package/dist/infrastructure/storage/in-memory-storage.d.ts

@@ -1,11 +1,15 @@
-import { Workflow, WorkflowSummary } from '../../types/mcp-types';
+import { Workflow, WorkflowSummary, WorkflowDefinition, WorkflowSource } from '../../types/workflow';
 import { IWorkflowStorage } from '../../types/storage';
 export declare class InMemoryWorkflowStorage implements IWorkflowStorage {
+    readonly kind: "single";
+    readonly source: WorkflowSource;
     private workflows;
-    constructor(workflows?: Workflow[]);
-    setWorkflows(workflows: Workflow[]): void;
-    loadAllWorkflows(): Promise<Workflow[]>;
+    constructor(definitions?: readonly WorkflowDefinition[], source?: WorkflowSource);
+    setWorkflows(definitions: readonly WorkflowDefinition[]): void;
+    setWorkflowsRaw(workflows: readonly Workflow[]): void;
+    loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
-    listWorkflowSummaries(): Promise<WorkflowSummary[]>;
-    save(workflow: Workflow): Promise<void>;
+    listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
+    save(definition: WorkflowDefinition): Promise<void>;
 }
+export declare function createTestStorage(definitions?: readonly WorkflowDefinition[], source?: WorkflowSource): InMemoryWorkflowStorage;

package/dist/infrastructure/storage/in-memory-storage.js

@@ -1,30 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryWorkflowStorage = void 0;
+exports.createTestStorage = createTestStorage;
+const workflow_1 = require("../../types/workflow");
 class InMemoryWorkflowStorage {
-    constructor(workflows = []) {
-        this.workflows = [...workflows];
+    constructor(definitions = [], source = (0, workflow_1.createBundledSource)()) {
+        this.kind = 'single';
+        this.source = source;
+        this.workflows = definitions.map(def => (0, workflow_1.createWorkflow)(def, source));
+    }
+    setWorkflows(definitions) {
+        this.workflows = definitions.map(def => (0, workflow_1.createWorkflow)(def, this.source));
     }
-    setWorkflows(workflows) {
+    setWorkflowsRaw(workflows) {
         this.workflows = [...workflows];
     }
     async loadAllWorkflows() {
         return [...this.workflows];
     }
     async getWorkflowById(id) {
-        return this.workflows.find((wf) => wf.id === id) || null;
+        return this.workflows.find((wf) => wf.definition.id === id) || null;
     }
     async listWorkflowSummaries() {
-        return this.workflows.map((workflow) => ({
-            id: workflow.id,
-            name: workflow.name,
-            description: workflow.description,
-            category: 'default',
-            version: workflow.version
-        }));
+        return this.workflows.map(workflow_1.toWorkflowSummary);
     }
-    async save(workflow) {
-        const index = this.workflows.findIndex((w) => w.id === workflow.id);
+    async save(definition) {
+        const index = this.workflows.findIndex((w) => w.definition.id === definition.id);
+        const workflow = (0, workflow_1.createWorkflow)(definition, this.source);
         if (index >= 0) {
             this.workflows[index] = workflow;
         }
@@ -34,3 +36,6 @@ class InMemoryWorkflowStorage {
     }
 }
 exports.InMemoryWorkflowStorage = InMemoryWorkflowStorage;
+function createTestStorage(definitions = [], source) {
+    return new InMemoryWorkflowStorage(definitions, source);
+}

package/dist/infrastructure/storage/plugin-workflow-storage.d.ts

@@ -1,5 +1,5 @@
 import { IWorkflowStorage } from '../../types/storage';
-import { Workflow, WorkflowSummary } from '../../types/mcp-types';
+import { Workflow, WorkflowSummary, WorkflowSource } from '../../types/workflow';
 export interface WorkflowPlugin {
     name: string;
     version: string;
@@ -26,15 +26,17 @@ export interface ValidatedPluginWorkflowConfig extends Required<PluginWorkflowCo
     maxPlugins: number;
 }
 export declare class PluginWorkflowStorage implements IWorkflowStorage {
+    readonly kind: "single";
+    readonly source: WorkflowSource;
     private readonly config;
     private pluginCache;
     private lastScan;
-    constructor(config?: PluginWorkflowConfig);
+    constructor(config?: PluginWorkflowConfig, source?: WorkflowSource);
     private validateAndNormalizeConfig;
     private getDefaultPluginPaths;
-    loadAllWorkflows(): Promise<Workflow[]>;
+    loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
-    listWorkflowSummaries(): Promise<WorkflowSummary[]>;
+    listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
     save(): Promise<void>;
     private scanPlugins;
     private isWorkflowPlugin;
@@ -43,17 +45,3 @@ export declare class PluginWorkflowStorage implements IWorkflowStorage {
     getLoadedPlugins(): WorkflowPlugin[];
     getConfig(): ValidatedPluginWorkflowConfig;
 }
-export declare const PLUGIN_WORKFLOW_CONFIGS: {
-    development: {
-        scanInterval: number;
-        maxFileSize: number;
-        maxFiles: number;
-        maxPlugins: number;
-    };
-    production: {
-        scanInterval: number;
-        maxFileSize: number;
-        maxFiles: number;
-        maxPlugins: number;
-    };
-};

package/dist/infrastructure/storage/plugin-workflow-storage.js

@@ -3,17 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLUGIN_WORKFLOW_CONFIGS = exports.PluginWorkflowStorage = void 0;
+exports.PluginWorkflowStorage = void 0;
+const workflow_1 = require("../../types/workflow");
 const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
 const fs_1 = require("fs");
 const storage_security_1 = require("../../utils/storage-security");
 const error_handler_1 = require("../../core/error-handler");
 class PluginWorkflowStorage {
-    constructor(config = {}) {
+    constructor(config = {}, source) {
+        this.kind = 'single';
         this.pluginCache = new Map();
         this.lastScan = 0;
         this.config = this.validateAndNormalizeConfig(config);
+        this.source = source ?? (0, workflow_1.createPluginSource)('plugins', '1.0.0');
     }
     validateAndNormalizeConfig(config) {
         const securityOptions = (0, storage_security_1.validateSecurityOptions)({
@@ -50,10 +53,7 @@ class PluginWorkflowStorage {
             }
         }
         catch {
-            const commonPaths = [
-                '/usr/local/lib/node_modules',
-                '/usr/lib/node_modules'
-            ];
+            const commonPaths = ['/usr/local/lib/node_modules', '/usr/lib/node_modules'];
             for (const commonPath of commonPaths) {
                 if ((0, fs_1.existsSync)(commonPath)) {
                     paths.push(commonPath);
@@ -85,17 +85,11 @@ class PluginWorkflowStorage {
     async getWorkflowById(id) {
         const sanitizedId = (0, storage_security_1.sanitizeId)(id);
         const workflows = await this.loadAllWorkflows();
-        return workflows.find(w => w.id === sanitizedId) || null;
+        return workflows.find(w => w.definition.id === sanitizedId) || null;
     }
     async listWorkflowSummaries() {
         const workflows = await this.loadAllWorkflows();
-        return workflows.map(workflow => ({
-            id: workflow.id,
-            name: workflow.name,
-            description: workflow.description,
-            category: 'plugin',
-            version: workflow.version
-        }));
+        return workflows.map(workflow_1.toWorkflowSummary);
     }
     async save() {
         throw new error_handler_1.StorageError('Plugin-based storage is read-only. Publish workflows as npm packages instead.');
@@ -108,9 +102,8 @@ class PluginWorkflowStorage {
         this.pluginCache.clear();
         let pluginCount = 0;
         for (const pluginPath of this.config.pluginPaths) {
-            if (!(0, fs_1.existsSync)(pluginPath)) {
+            if (!(0, fs_1.existsSync)(pluginPath))
                 continue;
-            }
             try {
                 (0, storage_security_1.assertWithinBase)(pluginPath, pluginPath);
                 const entries = await promises_1.default.readdir(pluginPath);
@@ -145,9 +138,8 @@ class PluginWorkflowStorage {
         try {
             (0, storage_security_1.assertWithinBase)(pluginPath, path_1.default.dirname(pluginPath));
             const packageJsonPath = path_1.default.join(pluginPath, 'package.json');
-            if (!(0, fs_1.existsSync)(packageJsonPath)) {
+            if (!(0, fs_1.existsSync)(packageJsonPath))
                 return null;
-            }
             (0, storage_security_1.assertWithinBase)(packageJsonPath, pluginPath);
             const packageStats = await promises_1.default.stat(packageJsonPath);
             (0, storage_security_1.validateFileSize)(packageStats.size, Math.min(this.config.maxFileSize, 64 * 1024), 'package.json');
@@ -159,27 +151,27 @@ class PluginWorkflowStorage {
             catch (parseError) {
                 throw new error_handler_1.InvalidWorkflowError(pluginPath, `Invalid package.json: ${parseError.message}`);
             }
-            if (!packageJson.workrail || !packageJson.workrail.workflows) {
+            if (!packageJson['workrail'] || !packageJson['workrail']['workflows']) {
                 return null;
             }
-            if (!packageJson.name || typeof packageJson.name !== 'string') {
-                throw new error_handler_1.InvalidWorkflowError(pluginPath, `Invalid package name`);
+            if (!packageJson['name'] || typeof packageJson['name'] !== 'string') {
+                throw new error_handler_1.InvalidWorkflowError(pluginPath, 'Invalid package name');
             }
             const workflowsPath = path_1.default.join(pluginPath, 'workflows');
-            if (!(0, fs_1.existsSync)(workflowsPath)) {
+            if (!(0, fs_1.existsSync)(workflowsPath))
                 return null;
-            }
             (0, storage_security_1.assertWithinBase)(workflowsPath, pluginPath);
-            const workflows = await this.loadWorkflowsFromDirectory(workflowsPath);
+            const pluginSource = (0, workflow_1.createPluginSource)(packageJson['name'], packageJson['version'] || '0.0.0');
+            const workflows = await this.loadWorkflowsFromDirectory(workflowsPath, pluginSource);
             return {
-                name: packageJson.name,
-                version: packageJson.version || '0.0.0',
+                name: packageJson['name'],
+                version: packageJson['version'] || '0.0.0',
                 workflows,
                 metadata: {
-                    author: packageJson.author,
-                    description: packageJson.description,
-                    homepage: packageJson.homepage,
-                    repository: packageJson.repository?.url || packageJson.repository
+                    author: packageJson['author'],
+                    description: packageJson['description'],
+                    homepage: packageJson['homepage'],
+                    repository: packageJson['repository']?.['url'] || packageJson['repository']
                 }
             };
         }
@@ -190,7 +182,7 @@ class PluginWorkflowStorage {
             throw new error_handler_1.StorageError(`Failed to load plugin from ${pluginPath}: ${error.message}`);
         }
     }
-    async loadWorkflowsFromDirectory(workflowsPath) {
+    async loadWorkflowsFromDirectory(workflowsPath, pluginSource) {
         const workflows = [];
         try {
             const files = await promises_1.default.readdir(workflowsPath);
@@ -205,18 +197,18 @@ class PluginWorkflowStorage {
                     const stats = await promises_1.default.stat(filePath);
                     (0, storage_security_1.validateFileSize)(stats.size, this.config.maxFileSize, file);
                     const content = await promises_1.default.readFile(filePath, 'utf-8');
-                    let workflow;
+                    let definition;
                     try {
-                        workflow = JSON.parse(content);
+                        definition = JSON.parse(content);
                     }
                     catch (parseError) {
                         throw new error_handler_1.InvalidWorkflowError(file, `Invalid JSON in workflow file: ${parseError.message}`);
                     }
-                    const sanitizedId = (0, storage_security_1.sanitizeId)(workflow.id);
-                    if (workflow.id !== sanitizedId) {
-                        throw new error_handler_1.InvalidWorkflowError(workflow.id, `Invalid workflow ID in file ${file}`);
+                    const sanitizedId = (0, storage_security_1.sanitizeId)(definition.id);
+                    if (definition.id !== sanitizedId) {
+                        throw new error_handler_1.InvalidWorkflowError(definition.id, `Invalid workflow ID in file ${file}`);
                     }
-                    workflows.push(workflow);
+                    workflows.push((0, workflow_1.createWorkflow)(definition, pluginSource));
                 }
                 catch (error) {
                     if (error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.InvalidWorkflowError) {
@@ -242,17 +234,3 @@ class PluginWorkflowStorage {
     }
 }
 exports.PluginWorkflowStorage = PluginWorkflowStorage;
-exports.PLUGIN_WORKFLOW_CONFIGS = {
-    development: {
-        scanInterval: 60000,
-        maxFileSize: 2 * 1024 * 1024,
-        maxFiles: 100,
-        maxPlugins: 50
-    },
-    production: {
-        scanInterval: 300000,
-        maxFileSize: 1024 * 1024,
-        maxFiles: 50,
-        maxPlugins: 20
-    }
-};

package/dist/infrastructure/storage/remote-workflow-storage.d.ts

@@ -1,5 +1,5 @@
 import { IWorkflowStorage } from '../../types/storage';
-import { Workflow, WorkflowSummary } from '../../types/mcp-types';
+import { Workflow, WorkflowSummary, WorkflowDefinition, WorkflowSource } from '../../types/workflow';
 import { StorageSecurityOptions } from '../../utils/storage-security';
 export interface RemoteWorkflowRegistryConfig extends StorageSecurityOptions {
     baseUrl: string;
@@ -9,26 +9,17 @@ export interface RemoteWorkflowRegistryConfig extends StorageSecurityOptions {
     userAgent?: string;
 }
 export declare class RemoteWorkflowStorage implements IWorkflowStorage {
+    readonly kind: "single";
+    readonly source: WorkflowSource;
     private readonly config;
     private readonly securityOptions;
-    constructor(config: RemoteWorkflowRegistryConfig);
+    constructor(config: RemoteWorkflowRegistryConfig, source?: WorkflowSource);
     private validateConfig;
-    loadAllWorkflows(): Promise<Workflow[]>;
+    loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
-    listWorkflowSummaries(): Promise<WorkflowSummary[]>;
-    save(workflow: Workflow): Promise<void>;
+    listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
+    save(definition: WorkflowDefinition): Promise<void>;
     private fetchWithRetry;
     private parseResponse;
-    private validateWorkflows;
-    private validateSummaries;
-    private validateWorkflowForSave;
-}
-export declare class CommunityWorkflowStorage implements IWorkflowStorage {
-    private readonly sources;
-    private readonly remoteStorage;
-    constructor(bundledStorage: IWorkflowStorage, localStorage: IWorkflowStorage, remoteConfig: RemoteWorkflowRegistryConfig);
-    loadAllWorkflows(): Promise<Workflow[]>;
-    getWorkflowById(id: string): Promise<Workflow | null>;
-    listWorkflowSummaries(): Promise<WorkflowSummary[]>;
-    save(workflow: Workflow): Promise<void>;
+    private validateDefinitions;
 }