@exaudeus/workrail 0.8.5 → 0.9.0

package/dist/infrastructure/session/SessionDataValidator.js

@@ -1,7 +1,14 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionDataValidator = void 0;
-class SessionDataValidator {
+const tsyringe_1 = require("tsyringe");
+let SessionDataValidator = class SessionDataValidator {
     validate(workflowId, data, sessionId) {
         const warnings = [];
         switch (workflowId) {
@@ -267,5 +274,8 @@ class SessionDataValidator {
             });
         }
     }
-}
+};
 exports.SessionDataValidator = SessionDataValidator;
+exports.SessionDataValidator = SessionDataValidator = __decorate([
+    (0, tsyringe_1.singleton)()
+], SessionDataValidator);

package/dist/infrastructure/session/SessionManager.d.ts

@@ -1,4 +1,6 @@
 import { EventEmitter } from 'events';
+import { SessionDataNormalizer } from './SessionDataNormalizer';
+import { SessionDataValidator } from './SessionDataValidator';
 export interface Session {
     id: string;
     workflowId: string;
@@ -16,13 +18,13 @@ export interface ProjectMetadata {
     workflows: string[];
 }
 export declare class SessionManager extends EventEmitter {
+    private normalizer;
+    private validator;
     private sessionsRoot;
     private projectId;
     private projectPath;
     private watchers;
-    private normalizer;
-    private validator;
-    constructor(projectPath?: string);
+    constructor(normalizer: SessionDataNormalizer, validator: SessionDataValidator, projectPath: string);
     private hashProjectPath;
     private resolveProjectPath;
     private findGitRepoRoot;

package/dist/infrastructure/session/SessionManager.js

@@ -1,4 +1,16 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -11,18 +23,20 @@ const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
 const events_1 = require("events");
+const tsyringe_1 = require("tsyringe");
+const tokens_js_1 = require("../../di/tokens.js");
 const SessionDataNormalizer_1 = require("./SessionDataNormalizer");
 const SessionDataValidator_1 = require("./SessionDataValidator");
-class SessionManager extends events_1.EventEmitter {
-    constructor(projectPath = process.cwd()) {
+let SessionManager = class SessionManager extends events_1.EventEmitter {
+    constructor(normalizer, validator, projectPath) {
         super();
+        this.normalizer = normalizer;
+        this.validator = validator;
         this.watchers = new Map();
         this.sessionsRoot = path_1.default.join(os_1.default.homedir(), '.workrail', 'sessions');
         const resolvedPath = this.resolveProjectPath(projectPath);
         this.projectPath = resolvedPath;
         this.projectId = this.hashProjectPath(resolvedPath);
-        this.normalizer = new SessionDataNormalizer_1.SessionDataNormalizer();
-        this.validator = new SessionDataValidator_1.SessionDataValidator();
     }
     hashProjectPath(projectPath) {
         return (0, crypto_1.createHash)('sha256')
@@ -347,10 +361,17 @@ class SessionManager extends events_1.EventEmitter {
         if (this.watchers.has(watchKey)) {
             return;
         }
+        const MAX_CONSECUTIVE_ERRORS = 5;
+        let consecutiveErrorCount = 0;
+        let debounceTimer = null;
         try {
             const watcher = fs_1.default.watch(sessionPath, (eventType) => {
                 if (eventType === 'change') {
-                    setTimeout(async () => {
+                    if (debounceTimer) {
+                        clearTimeout(debounceTimer);
+                    }
+                    debounceTimer = setTimeout(async () => {
+                        debounceTimer = null;
                         try {
                             const session = await this.getSession(workflowId, sessionId);
                             if (session) {
@@ -360,15 +381,32 @@ class SessionManager extends events_1.EventEmitter {
                                     session
                                 });
                             }
+                            consecutiveErrorCount = 0;
                         }
                         catch (error) {
+                            if (error.code === 'EBUSY') {
+                                return;
+                            }
+                            consecutiveErrorCount++;
+                            console.error(`[SessionManager] Watch error for ${watchKey} (${consecutiveErrorCount}/${MAX_CONSECUTIVE_ERRORS}):`, error.message || error);
+                            if (consecutiveErrorCount >= MAX_CONSECUTIVE_ERRORS) {
+                                console.error(`[SessionManager] Too many errors, closing watcher for ${watchKey}`);
+                                this.unwatchSession(workflowId, sessionId);
+                            }
                         }
                     }, 100);
                 }
             });
+            watcher.on('error', (error) => {
+                console.error(`[SessionManager] Watcher error for ${watchKey}:`, error);
+                this.unwatchSession(workflowId, sessionId);
+            });
             this.watchers.set(watchKey, watcher);
         }
         catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`[SessionManager] Failed to start watcher for ${watchKey}:`, error.message || error);
+            }
         }
     }
     unwatchSession(workflowId, sessionId) {
@@ -415,5 +453,13 @@ class SessionManager extends events_1.EventEmitter {
             console.error('[SessionManager] Failed to log validation warnings:', error);
         }
     }
-}
+};
 exports.SessionManager = SessionManager;
+exports.SessionManager = SessionManager = __decorate([
+    (0, tsyringe_1.singleton)(),
+    __param(0, (0, tsyringe_1.inject)(SessionDataNormalizer_1.SessionDataNormalizer)),
+    __param(1, (0, tsyringe_1.inject)(SessionDataValidator_1.SessionDataValidator)),
+    __param(2, (0, tsyringe_1.inject)(tokens_js_1.DI.Config.ProjectPath)),
+    __metadata("design:paramtypes", [SessionDataNormalizer_1.SessionDataNormalizer,
+        SessionDataValidator_1.SessionDataValidator, String])
+], SessionManager);

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

@@ -1,18 +1,42 @@
-import { IWorkflowStorage } from '../../types/storage';
-import { Workflow, WorkflowSummary } from '../../types/mcp-types';
+import { IWorkflowStorage, ICompositeWorkflowStorage } from '../../types/storage';
+import { Workflow, WorkflowSummary, WorkflowDefinition, WorkflowSource } from '../../types/workflow';
 export declare class CachingWorkflowStorage implements IWorkflowStorage {
     private readonly inner;
     private readonly ttlMs;
-    private cache;
+    readonly kind: "single";
+    private workflowCache;
+    private summaryCache;
     private stats;
     constructor(inner: IWorkflowStorage, ttlMs: number);
+    get source(): WorkflowSource;
     getCacheStats(): {
         hits: number;
         misses: number;
     };
+    clearCache(): void;
     private isFresh;
-    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>;
+}
+export declare class CachingCompositeWorkflowStorage implements ICompositeWorkflowStorage {
+    private readonly inner;
+    private readonly ttlMs;
+    readonly kind: "composite";
+    private workflowCache;
+    private summaryCache;
+    private stats;
+    constructor(inner: ICompositeWorkflowStorage, ttlMs: number);
+    private isFresh;
+    getSources(): readonly WorkflowSource[];
+    loadAllWorkflows(): Promise<readonly Workflow[]>;
+    getWorkflowById(id: string): Promise<Workflow | null>;
+    listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
+    save(definition: WorkflowDefinition): Promise<void>;
+    getCacheStats(): {
+        hits: number;
+        misses: number;
+    };
+    clearCache(): void;
 }

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CachingWorkflowStorage = void 0;
+exports.CachingCompositeWorkflowStorage = exports.CachingWorkflowStorage = void 0;
 const deepClone = (obj) => {
-    if (typeof global.structuredClone === 'function') {
-        return global.structuredClone(obj);
+    if (typeof globalThis.structuredClone === 'function') {
+        return globalThis.structuredClone(obj);
     }
     return JSON.parse(JSON.stringify(obj));
 };
@@ -11,44 +11,126 @@ class CachingWorkflowStorage {
     constructor(inner, ttlMs) {
         this.inner = inner;
         this.ttlMs = ttlMs;
-        this.cache = null;
+        this.kind = 'single';
+        this.workflowCache = null;
+        this.summaryCache = null;
         this.stats = { hits: 0, misses: 0 };
     }
+    get source() {
+        return this.inner.source;
+    }
     getCacheStats() {
         return { ...this.stats };
     }
-    isFresh() {
-        return this.cache !== null && Date.now() - this.cache.timestamp < this.ttlMs;
+    clearCache() {
+        this.workflowCache = null;
+        this.summaryCache = null;
+    }
+    isFresh(cache) {
+        return cache !== null && Date.now() - cache.timestamp < this.ttlMs;
     }
     async loadAllWorkflows() {
-        if (this.isFresh()) {
+        if (this.isFresh(this.workflowCache)) {
             this.stats.hits += 1;
-            return deepClone(this.cache.value);
+            return deepClone(this.workflowCache.value);
         }
         this.stats.misses += 1;
         const workflows = await this.inner.loadAllWorkflows();
-        this.cache = { value: workflows, timestamp: Date.now() };
+        this.workflowCache = { value: workflows, timestamp: Date.now() };
+        this.summaryCache = null;
         return deepClone(workflows);
     }
     async getWorkflowById(id) {
-        const workflows = await this.loadAllWorkflows();
-        const wf = workflows.find((wf) => wf.id === id);
-        return wf ? deepClone(wf) : null;
+        if (this.isFresh(this.workflowCache)) {
+            const wf = this.workflowCache.value.find((w) => w.definition.id === id);
+            if (wf) {
+                this.stats.hits += 1;
+                return deepClone(wf);
+            }
+        }
+        this.stats.misses += 1;
+        const workflow = await this.inner.getWorkflowById(id);
+        return workflow ? deepClone(workflow) : null;
     }
     async listWorkflowSummaries() {
-        const workflows = await this.loadAllWorkflows();
-        return workflows.map((wf) => ({
-            id: wf.id,
-            name: wf.name,
-            description: wf.description,
-            category: 'default',
-            version: wf.version
-        }));
-    }
-    async save(workflow) {
+        if (this.isFresh(this.summaryCache)) {
+            this.stats.hits += 1;
+            return deepClone(this.summaryCache.value);
+        }
+        this.stats.misses += 1;
+        const summaries = await this.inner.listWorkflowSummaries();
+        this.summaryCache = { value: summaries, timestamp: Date.now() };
+        return deepClone(summaries);
+    }
+    async save(definition) {
         if (typeof this.inner.save === 'function') {
-            return this.inner.save(workflow);
+            await this.inner.save(definition);
+            this.clearCache();
         }
     }
 }
 exports.CachingWorkflowStorage = CachingWorkflowStorage;
+class CachingCompositeWorkflowStorage {
+    constructor(inner, ttlMs) {
+        this.inner = inner;
+        this.ttlMs = ttlMs;
+        this.kind = 'composite';
+        this.workflowCache = null;
+        this.summaryCache = null;
+        this.stats = { hits: 0, misses: 0 };
+    }
+    isFresh(cache) {
+        return cache !== null && Date.now() - cache.timestamp < this.ttlMs;
+    }
+    getSources() {
+        return this.inner.getSources();
+    }
+    async loadAllWorkflows() {
+        if (this.isFresh(this.workflowCache)) {
+            this.stats.hits += 1;
+            return deepClone(this.workflowCache.value);
+        }
+        this.stats.misses += 1;
+        const workflows = await this.inner.loadAllWorkflows();
+        this.workflowCache = { value: workflows, timestamp: Date.now() };
+        this.summaryCache = null;
+        return deepClone(workflows);
+    }
+    async getWorkflowById(id) {
+        if (this.isFresh(this.workflowCache)) {
+            const wf = this.workflowCache.value.find((w) => w.definition.id === id);
+            if (wf) {
+                this.stats.hits += 1;
+                return deepClone(wf);
+            }
+        }
+        this.stats.misses += 1;
+        const workflow = await this.inner.getWorkflowById(id);
+        return workflow ? deepClone(workflow) : null;
+    }
+    async listWorkflowSummaries() {
+        if (this.isFresh(this.summaryCache)) {
+            this.stats.hits += 1;
+            return deepClone(this.summaryCache.value);
+        }
+        this.stats.misses += 1;
+        const summaries = await this.inner.listWorkflowSummaries();
+        this.summaryCache = { value: summaries, timestamp: Date.now() };
+        return deepClone(summaries);
+    }
+    async save(definition) {
+        if (typeof this.inner.save === 'function') {
+            await this.inner.save(definition);
+            this.workflowCache = null;
+            this.summaryCache = null;
+        }
+    }
+    getCacheStats() {
+        return { ...this.stats };
+    }
+    clearCache() {
+        this.workflowCache = null;
+        this.summaryCache = null;
+    }
+}
+exports.CachingCompositeWorkflowStorage = CachingCompositeWorkflowStorage;

package/dist/infrastructure/storage/enhanced-multi-source-workflow-storage.d.ts

@@ -1,8 +1,9 @@
-import { IWorkflowStorage } from '../../types/storage';
-import { Workflow, WorkflowSummary } from '../../types/mcp-types';
+import { ICompositeWorkflowStorage } from '../../types/storage';
+import { Workflow, WorkflowSummary, WorkflowDefinition, WorkflowSource } from '../../types/workflow';
 import { GitWorkflowConfig } from './git-workflow-storage';
 import { RemoteWorkflowRegistryConfig } from './remote-workflow-storage';
 import { PluginWorkflowConfig } from './plugin-workflow-storage';
+import type { IFeatureFlagProvider } from '../../config/feature-flags';
 interface FileWorkflowStorageOptions {
     maxFileSizeBytes?: number;
     cacheTTLms?: number;
@@ -23,19 +24,22 @@ export interface EnhancedMultiSourceConfig {
     warnOnSourceFailure?: boolean;
     gracefulDegradation?: boolean;
 }
-export declare class EnhancedMultiSourceWorkflowStorage implements IWorkflowStorage {
+export declare class EnhancedMultiSourceWorkflowStorage implements ICompositeWorkflowStorage {
+    private readonly featureFlagProvider;
+    readonly kind: "composite";
     private readonly storageInstances;
     private readonly config;
-    private readonly sourceNames;
-    constructor(config?: EnhancedMultiSourceConfig);
+    constructor(config?: EnhancedMultiSourceConfig, featureFlagProvider?: IFeatureFlagProvider | null);
+    getSources(): readonly WorkflowSource[];
     private initializeStorageSources;
-    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>;
     getSourceInfo(): Array<{
         name: string;
         type: string;
+        source: WorkflowSource;
     }>;
     private handleSourceError;
     private getBundledWorkflowsPath;
@@ -44,5 +48,5 @@ export declare class EnhancedMultiSourceWorkflowStorage implements IWorkflowStor
     private extractRepoName;
     private getStorageType;
 }
-export declare function createEnhancedMultiSourceWorkflowStorage(overrides?: EnhancedMultiSourceConfig): EnhancedMultiSourceWorkflowStorage;
+export declare function createEnhancedMultiSourceWorkflowStorage(overrides?: EnhancedMultiSourceConfig, featureFlagProvider?: IFeatureFlagProvider): EnhancedMultiSourceWorkflowStorage;
 export {};