@exaudeus/workrail 0.8.6 → 0.9.0

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

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

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommunityWorkflowStorage = exports.RemoteWorkflowStorage = void 0;
+exports.RemoteWorkflowStorage = void 0;
+const workflow_1 = require("../../types/workflow");
 const storage_security_1 = require("../../utils/storage-security");
 const error_handler_1 = require("../../core/error-handler");
 class RemoteWorkflowStorage {
-    constructor(config) {
+    constructor(config, source) {
+        this.kind = 'single';
         this.validateConfig(config);
         this.securityOptions = (0, storage_security_1.validateSecurityOptions)(config);
         this.config = {
@@ -15,6 +17,7 @@ class RemoteWorkflowStorage {
             retryAttempts: config.retryAttempts || 3,
             userAgent: config.userAgent || 'workrail-mcp-server/1.0'
         };
+        this.source = source ?? (0, workflow_1.createRemoteRegistrySource)(this.config.baseUrl);
     }
     validateConfig(config) {
         if (!config.baseUrl) {
@@ -32,8 +35,9 @@ class RemoteWorkflowStorage {
         try {
             const response = await this.fetchWithRetry('/workflows');
             const data = await this.parseResponse(response);
-            const workflows = data.workflows || data.data || [];
-            return this.validateWorkflows(workflows);
+            const definitions = data.workflows || data.data || [];
+            const validDefinitions = this.validateDefinitions(definitions);
+            return validDefinitions.map(def => (0, workflow_1.createWorkflow)(def, this.source));
         }
         catch (error) {
             if (error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.StorageError) {
@@ -47,50 +51,41 @@ class RemoteWorkflowStorage {
             const sanitizedId = (0, storage_security_1.sanitizeId)(id);
             const response = await this.fetchWithRetry(`/workflows/${encodeURIComponent(sanitizedId)}`);
             if (!response.ok) {
-                if (response.status === 404) {
+                if (response.status === 404)
                     return null;
-                }
                 throw new error_handler_1.StorageError(`Remote registry returned ${response.status}: ${response.statusText}`, 'remote-fetch');
             }
-            const workflow = await this.parseResponse(response);
-            if (workflow.id !== sanitizedId) {
-                throw new error_handler_1.InvalidWorkflowError(sanitizedId, `Registry returned workflow with mismatched ID: ${workflow.id}`);
+            const definition = await this.parseResponse(response);
+            if (definition.id !== sanitizedId) {
+                throw new error_handler_1.InvalidWorkflowError(sanitizedId, `Registry returned workflow with mismatched ID: ${definition.id}`);
             }
-            return workflow;
+            return (0, workflow_1.createWorkflow)(definition, this.source);
         }
         catch (error) {
-            if (error instanceof error_handler_1.SecurityError ||
-                error instanceof error_handler_1.StorageError ||
-                error instanceof error_handler_1.InvalidWorkflowError) {
+            if (error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.StorageError || error instanceof error_handler_1.InvalidWorkflowError) {
                 throw error;
             }
             throw new error_handler_1.StorageError(`Failed to load workflow ${id} from remote registry: ${error.message}`, 'remote-fetch');
         }
     }
     async listWorkflowSummaries() {
-        try {
-            const response = await this.fetchWithRetry('/workflows/summaries');
-            const data = await this.parseResponse(response);
-            const summaries = data.summaries || data.data || [];
-            return this.validateSummaries(summaries);
-        }
-        catch (error) {
-            if (error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.StorageError) {
-                throw error;
-            }
-            throw new error_handler_1.StorageError(`Failed to load workflow summaries from remote registry: ${error.message}`, 'remote-fetch');
-        }
+        const workflows = await this.loadAllWorkflows();
+        return workflows.map(workflow_1.toWorkflowSummary);
     }
-    async save(workflow) {
+    async save(definition) {
         try {
-            const sanitizedWorkflow = this.validateWorkflowForSave(workflow);
+            if (!definition.id || !definition.name || !definition.steps) {
+                throw new error_handler_1.InvalidWorkflowError(definition.id || 'unknown', 'Workflow must have id, name, and steps');
+            }
+            const sanitizedId = (0, storage_security_1.sanitizeId)(definition.id);
+            const sanitizedDefinition = { ...definition, id: sanitizedId };
             const response = await this.fetchWithRetry('/workflows', {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
                     ...(this.config.apiKey && { 'Authorization': `Bearer ${this.config.apiKey}` })
                 },
-                body: JSON.stringify(sanitizedWorkflow)
+                body: JSON.stringify(sanitizedDefinition)
             });
             if (!response.ok) {
                 const errorData = await this.parseResponse(response);
@@ -98,9 +93,7 @@ class RemoteWorkflowStorage {
             }
         }
         catch (error) {
-            if (error instanceof error_handler_1.SecurityError ||
-                error instanceof error_handler_1.StorageError ||
-                error instanceof error_handler_1.InvalidWorkflowError) {
+            if (error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.StorageError || error instanceof error_handler_1.InvalidWorkflowError) {
                 throw error;
             }
             throw new error_handler_1.StorageError(`Failed to save workflow to remote registry: ${error.message}`, 'remote-save');
@@ -127,9 +120,8 @@ class RemoteWorkflowStorage {
             }
             catch (error) {
                 lastError = error;
-                if (attempt === this.config.retryAttempts) {
+                if (attempt === this.config.retryAttempts)
                     break;
-                }
                 const delay = Math.pow(2, attempt) * 1000 + Math.random() * 1000;
                 await new Promise(resolve => setTimeout(resolve, delay));
             }
@@ -145,26 +137,23 @@ class RemoteWorkflowStorage {
             return JSON.parse(text);
         }
         catch (error) {
-            if (error instanceof error_handler_1.StorageError) {
+            if (error instanceof error_handler_1.StorageError)
                 throw error;
-            }
             throw new error_handler_1.StorageError(`Failed to parse response from remote registry: ${error.message}`, 'parse-error');
         }
     }
-    validateWorkflows(workflows) {
-        if (!Array.isArray(workflows)) {
+    validateDefinitions(definitions) {
+        if (!Array.isArray(definitions)) {
             throw new error_handler_1.StorageError('Remote registry returned invalid workflows data', 'validation-error');
         }
-        return workflows.filter((workflow) => {
+        return definitions.filter((def) => {
             try {
-                if (!workflow || typeof workflow !== 'object') {
+                if (!def || typeof def !== 'object')
                     return false;
-                }
-                const wf = workflow;
-                if (!wf.id || !wf.name || !wf.steps) {
+                const d = def;
+                if (!d['id'] || !d['name'] || !d['steps'])
                     return false;
-                }
-                (0, storage_security_1.sanitizeId)(wf.id);
+                (0, storage_security_1.sanitizeId)(d['id']);
                 return true;
             }
             catch {
@@ -172,117 +161,5 @@ class RemoteWorkflowStorage {
             }
         });
     }
-    validateSummaries(summaries) {
-        if (!Array.isArray(summaries)) {
-            throw new error_handler_1.StorageError('Remote registry returned invalid summaries data', 'validation-error');
-        }
-        return summaries.filter((summary) => {
-            try {
-                if (!summary || typeof summary !== 'object') {
-                    return false;
-                }
-                const s = summary;
-                if (!s.id || !s.name) {
-                    return false;
-                }
-                (0, storage_security_1.sanitizeId)(s.id);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        });
-    }
-    validateWorkflowForSave(workflow) {
-        if (!workflow || typeof workflow !== 'object') {
-            throw new error_handler_1.InvalidWorkflowError('unknown', 'Workflow must be a valid object');
-        }
-        if (!workflow.id || !workflow.name || !workflow.steps) {
-            throw new error_handler_1.InvalidWorkflowError(workflow.id || 'unknown', 'Workflow must have id, name, and steps');
-        }
-        const sanitizedId = (0, storage_security_1.sanitizeId)(workflow.id);
-        return {
-            ...workflow,
-            id: sanitizedId
-        };
-    }
 }
 exports.RemoteWorkflowStorage = RemoteWorkflowStorage;
-class CommunityWorkflowStorage {
-    constructor(bundledStorage, localStorage, remoteConfig) {
-        this.remoteStorage = new RemoteWorkflowStorage(remoteConfig);
-        this.sources = [bundledStorage, localStorage, this.remoteStorage];
-    }
-    async loadAllWorkflows() {
-        const allWorkflows = [];
-        const seenIds = new Set();
-        for (const source of this.sources) {
-            try {
-                const workflows = await source.loadAllWorkflows();
-                for (const workflow of workflows) {
-                    if (seenIds.has(workflow.id)) {
-                        const existingIndex = allWorkflows.findIndex(wf => wf.id === workflow.id);
-                        if (existingIndex >= 0) {
-                            allWorkflows[existingIndex] = workflow;
-                        }
-                    }
-                    else {
-                        allWorkflows.push(workflow);
-                        seenIds.add(workflow.id);
-                    }
-                }
-            }
-            catch (error) {
-                if (error instanceof error_handler_1.StorageError) {
-                    console.warn(`Storage source failed (graceful degradation):`, error.message);
-                }
-                else {
-                    console.warn(`Unexpected error from storage source:`, error);
-                }
-            }
-        }
-        return allWorkflows;
-    }
-    async getWorkflowById(id) {
-        try {
-            const sanitizedId = (0, storage_security_1.sanitizeId)(id);
-            for (let i = this.sources.length - 1; i >= 0; i--) {
-                try {
-                    const workflow = await this.sources[i].getWorkflowById(sanitizedId);
-                    if (workflow) {
-                        return workflow;
-                    }
-                }
-                catch (error) {
-                    if (error instanceof error_handler_1.StorageError) {
-                        console.warn(`Storage source failed for workflow ${sanitizedId}:`, error.message);
-                    }
-                    else {
-                        console.warn(`Unexpected error from storage source for workflow ${sanitizedId}:`, error);
-                    }
-                }
-            }
-            return null;
-        }
-        catch (error) {
-            if (error instanceof error_handler_1.SecurityError || error instanceof error_handler_1.InvalidWorkflowError) {
-                throw error;
-            }
-            throw new error_handler_1.StorageError(`Failed to retrieve workflow ${id}: ${error.message}`, 'multi-source-error');
-        }
-    }
-    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
-        }));
-    }
-    async save(workflow) {
-        return this.remoteStorage.save(workflow);
-    }
-}
-exports.CommunityWorkflowStorage = CommunityWorkflowStorage;

package/dist/infrastructure/storage/schema-validating-workflow-storage.d.ts

@@ -1,18 +1,26 @@
-import { IWorkflowStorage } from '../../types/storage';
-import { Workflow } from '../../types/mcp-types';
+import { IWorkflowStorage, ICompositeWorkflowStorage } from '../../types/storage';
+import { Workflow, WorkflowSummary, WorkflowDefinition, WorkflowSource } from '../../types/workflow';
 export declare class SchemaValidatingWorkflowStorage implements IWorkflowStorage {
     private readonly inner;
-    private validator;
+    readonly kind: "single";
+    private readonly validator;
     constructor(inner: IWorkflowStorage);
-    private ensureValid;
-    loadAllWorkflows(): Promise<Workflow[]>;
+    get source(): WorkflowSource;
+    private validateDefinition;
+    loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
-    listWorkflowSummaries(): Promise<{
-        id: string;
-        name: string;
-        description: string;
-        category: string;
-        version: string;
-    }[]>;
-    save?(workflow: Workflow): Promise<void>;
+    listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
+    save(definition: WorkflowDefinition): Promise<void>;
+}
+export declare class SchemaValidatingCompositeWorkflowStorage implements ICompositeWorkflowStorage {
+    private readonly inner;
+    readonly kind: "composite";
+    private readonly validator;
+    constructor(inner: ICompositeWorkflowStorage);
+    private validateDefinition;
+    getSources(): readonly WorkflowSource[];
+    loadAllWorkflows(): Promise<readonly Workflow[]>;
+    getWorkflowById(id: string): Promise<Workflow | null>;
+    listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
+    save(definition: WorkflowDefinition): Promise<void>;
 }