@exaudeus/workrail 0.1.0 → 0.1.2

package/dist/infrastructure/storage/sqlite-migrator.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteMigrator = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+class SqliteMigrator {
+    constructor(databasePath, migrationsDir) {
+        this.maxRetries = 3;
+        this.lockTimeout = 10000;
+        this.db = new better_sqlite3_1.default(databasePath, {
+            verbose: undefined,
+            fileMustExist: false,
+            timeout: this.lockTimeout
+        });
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('synchronous = NORMAL');
+        this.db.pragma('cache_size = 1000');
+        this.db.pragma('temp_store = memory');
+        this.db.pragma('foreign_keys = ON');
+        this.migrationsDir = migrationsDir || path_1.default.join(__dirname, 'migrations');
+    }
+    async initialize() {
+        try {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS schema_version (
+          version INTEGER PRIMARY KEY,
+          applied_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          description TEXT NOT NULL,
+          checksum TEXT NOT NULL,
+          migration_duration_ms INTEGER DEFAULT NULL
+        );
+      `);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS migration_locks (
+          id TEXT PRIMARY KEY DEFAULT 'migration_lock',
+          locked_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+          locked_by TEXT NOT NULL,
+          expires_at DATETIME NOT NULL,
+          CHECK (id = 'migration_lock')
+        );
+      `);
+            console.log('✅ Migration system initialized');
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize migration system: ${error}`);
+        }
+    }
+    getCurrentVersion() {
+        try {
+            const result = this.db
+                .prepare('SELECT MAX(version) as version FROM schema_version')
+                .get();
+            return result?.version ?? 0;
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    loadAvailableMigrations() {
+        try {
+            if (!fs_1.default.existsSync(this.migrationsDir)) {
+                console.warn(`Migrations directory not found: ${this.migrationsDir}`);
+                return [];
+            }
+            const files = fs_1.default.readdirSync(this.migrationsDir)
+                .filter(file => file.endsWith('.sql'))
+                .sort();
+            const migrations = [];
+            for (const filename of files) {
+                const match = filename.match(/^(\d+)_(.+)\.sql$/);
+                if (!match) {
+                    console.warn(`Skipping invalid migration filename: ${filename}`);
+                    continue;
+                }
+                const version = parseInt(match[1], 10);
+                const description = match[2].replace(/[_-]/g, ' ');
+                const filepath = path_1.default.join(this.migrationsDir, filename);
+                const sql = fs_1.default.readFileSync(filepath, 'utf-8');
+                const checksum = this.calculateChecksum(sql);
+                migrations.push({
+                    version,
+                    filename,
+                    description,
+                    sql,
+                    checksum
+                });
+            }
+            return migrations.sort((a, b) => a.version - b.version);
+        }
+        catch (error) {
+            throw new Error(`Failed to load migrations: ${error}`);
+        }
+    }
+    getMigrationStatus() {
+        const currentVersion = this.getCurrentVersion();
+        const availableMigrations = this.loadAvailableMigrations();
+        const pendingMigrations = availableMigrations.filter(m => m.version > currentVersion);
+        const targetVersion = Math.max(...availableMigrations.map(m => m.version), currentVersion);
+        const appliedMigrations = this.db
+            .prepare('SELECT version, description, applied_at, checksum FROM schema_version ORDER BY version')
+            .all();
+        return {
+            currentVersion,
+            targetVersion,
+            pendingMigrations,
+            appliedMigrations
+        };
+    }
+    async migrate() {
+        const results = [];
+        const status = this.getMigrationStatus();
+        if (status.pendingMigrations.length === 0) {
+            console.log('📊 Database is up to date');
+            return results;
+        }
+        console.log(`📊 Applying ${status.pendingMigrations.length} pending migrations...`);
+        for (const migration of status.pendingMigrations) {
+            const result = await this.applyMigration(migration);
+            results.push(result);
+            if (!result.success) {
+                console.error(`❌ Migration failed at version ${migration.version}, stopping`);
+                break;
+            }
+        }
+        return results;
+    }
+    async applyMigration(migration) {
+        const startTime = Date.now();
+        let lockId = null;
+        try {
+            lockId = await this.acquireMigrationLock();
+            const currentVersion = this.getCurrentVersion();
+            if (migration.version <= currentVersion) {
+                await this.releaseMigrationLock(lockId);
+                return {
+                    success: true,
+                    appliedVersion: migration.version,
+                    duration: Date.now() - startTime
+                };
+            }
+            await this.validateMigrationChecksum(migration);
+            console.log(`📦 Applying migration ${migration.version}: ${migration.description}`);
+            const transaction = this.db.transaction(() => {
+                this.db.exec(migration.sql);
+                this.db
+                    .prepare(`
+            INSERT INTO schema_version (version, description, checksum, migration_duration_ms) 
+            VALUES (?, ?, ?, ?)
+          `)
+                    .run(migration.version, migration.description, migration.checksum, Date.now() - startTime);
+            });
+            transaction();
+            const duration = Date.now() - startTime;
+            console.log(`✅ Migration ${migration.version} completed in ${duration}ms`);
+            await this.releaseMigrationLock(lockId);
+            return {
+                success: true,
+                appliedVersion: migration.version,
+                duration
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            console.error(`❌ Migration ${migration.version} failed:`, error);
+            if (lockId) {
+                try {
+                    await this.releaseMigrationLock(lockId);
+                }
+                catch (lockError) {
+                    console.error('Failed to release migration lock:', lockError);
+                }
+            }
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                duration
+            };
+        }
+    }
+    async acquireMigrationLock() {
+        const lockId = crypto_1.default.randomUUID();
+        const expiresAt = new Date(Date.now() + this.lockTimeout);
+        let attempts = 0;
+        while (attempts < this.maxRetries) {
+            try {
+                this.db
+                    .prepare('DELETE FROM migration_locks WHERE expires_at < CURRENT_TIMESTAMP')
+                    .run();
+                this.db
+                    .prepare(`
+            INSERT INTO migration_locks (locked_by, expires_at) 
+            VALUES (?, ?)
+          `)
+                    .run(lockId, expiresAt.toISOString());
+                return lockId;
+            }
+            catch (error) {
+                attempts++;
+                if (attempts >= this.maxRetries) {
+                    throw new Error(`Failed to acquire migration lock after ${this.maxRetries} attempts`);
+                }
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+        throw new Error('Unable to acquire migration lock');
+    }
+    async releaseMigrationLock(lockId) {
+        try {
+            this.db
+                .prepare('DELETE FROM migration_locks WHERE locked_by = ?')
+                .run(lockId);
+        }
+        catch (error) {
+            console.warn(`Failed to release migration lock ${lockId}:`, error);
+        }
+    }
+    async validateMigrationChecksum(migration) {
+        try {
+            const existingMigration = this.db
+                .prepare('SELECT checksum FROM schema_version WHERE version = ?')
+                .get(migration.version);
+            if (existingMigration && existingMigration.checksum !== migration.checksum) {
+                throw new Error(`Migration ${migration.version} checksum mismatch. ` +
+                    `Expected: ${existingMigration.checksum}, Got: ${migration.checksum}. ` +
+                    `Migration file may have been modified after being applied.`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('checksum mismatch')) {
+                throw error;
+            }
+        }
+    }
+    calculateChecksum(content) {
+        return crypto_1.default
+            .createHash('sha256')
+            .update(content.trim())
+            .digest('hex');
+    }
+    async validateIntegrity() {
+        try {
+            const result = this.db.prepare('PRAGMA integrity_check').get();
+            if (result.integrity_check !== 'ok') {
+                console.error('❌ Database integrity check failed:', result.integrity_check);
+                return false;
+            }
+            const fkCheck = this.db.prepare('PRAGMA foreign_key_check').all();
+            if (fkCheck.length > 0) {
+                console.error('❌ Foreign key constraints violated:', fkCheck);
+                return false;
+            }
+            console.log('✅ Database integrity validated');
+            return true;
+        }
+        catch (error) {
+            console.error('❌ Failed to validate database integrity:', error);
+            return false;
+        }
+    }
+    close() {
+        try {
+            this.db.close();
+        }
+        catch (error) {
+            console.warn('Warning during database close:', error);
+        }
+    }
+    getStats() {
+        try {
+            const stats = this.db.prepare('PRAGMA database_list').all();
+            const pageCount = this.db.prepare('PRAGMA page_count').get();
+            const pageSize = this.db.prepare('PRAGMA page_size').get();
+            const walMode = this.db.prepare('PRAGMA journal_mode').get();
+            return {
+                databases: stats,
+                totalPages: pageCount.page_count,
+                pageSize: pageSize.page_size,
+                estimatedSize: pageCount.page_count * pageSize.page_size,
+                journalMode: walMode.journal_mode,
+                currentVersion: this.getCurrentVersion()
+            };
+        }
+        catch (error) {
+            return { error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+}
+exports.SqliteMigrator = SqliteMigrator;

package/dist/types/context-types.d.ts

@@ -0,0 +1,236 @@
+export declare enum ContextLayer {
+    CRITICAL = "CRITICAL",
+    IMPORTANT = "IMPORTANT",
+    USEFUL = "USEFUL",
+    EPHEMERAL = "EPHEMERAL"
+}
+export interface ClassifiedContext {
+    [ContextLayer.CRITICAL]: Record<string, any>;
+    [ContextLayer.IMPORTANT]: Record<string, any>;
+    [ContextLayer.USEFUL]: Record<string, any>;
+    [ContextLayer.EPHEMERAL]: Record<string, any>;
+}
+export interface RawContext {
+    [key: string]: any;
+}
+export interface PersistableContext extends Record<string, any> {
+    readonly _contextSize?: number;
+    readonly _timestamp?: string;
+}
+export interface CheckpointMetadata {
+    id: string;
+    sessionId: string;
+    name?: string;
+    agentId?: string;
+    createdAt: string;
+    tags?: string[];
+    contextSizeBytes: number;
+    contextHash: string;
+    blobPath: string;
+    classificationSummary?: ClassificationSummary;
+    status: 'active' | 'archived' | 'corrupt';
+}
+export interface ClassificationSummary {
+    criticalCount: number;
+    importantCount: number;
+    usefulCount: number;
+    ephemeralCount: number;
+}
+export interface SessionInfo {
+    id: string;
+    createdAt: string;
+    lastAccessedAt: string;
+    workflowId?: string;
+    tags?: string[];
+    totalSizeBytes: number;
+}
+export interface CheckpointData {
+    metadata: CheckpointMetadata;
+    context: RawContext;
+}
+export interface CompressedBlob {
+    data: Buffer;
+    originalSize: number;
+    compressedSize: number;
+    compressionRatio: number;
+    algorithm: 'gzip' | 'deflate' | 'none';
+}
+export interface BlobMetadata {
+    checkpointId: string;
+    sessionId: string;
+    path: string;
+    sizeBytes: number;
+    hash: string;
+    encrypted: boolean;
+}
+export interface ClassificationRules {
+    patterns: {
+        [K in ContextLayer]: ClassificationPattern[];
+    };
+    heuristics: ClassificationHeuristics;
+    overrides: Record<string, ContextLayer>;
+}
+export interface ClassificationPattern {
+    keyPattern: string;
+    valuePattern?: string;
+    weight: number;
+    description: string;
+}
+export interface ClassificationHeuristics {
+    lengthThresholds: {
+        [K in ContextLayer]: number;
+    };
+    keywordWeights: Record<string, number>;
+    defaultLayer: ContextLayer;
+}
+export interface ContextConfig {
+    storage: StorageConfig;
+    classification: ClassificationRules;
+    compression: CompressionConfig;
+    encryption: EncryptionConfig;
+    quotas: QuotaConfig;
+}
+export interface StorageConfig {
+    dataDir: string;
+    maxCheckpoints: number;
+    maxSessionSize: number;
+    maxTotalSize: number;
+    cleanupInterval: number;
+}
+export interface CompressionConfig {
+    enabled: boolean;
+    algorithm: 'gzip' | 'deflate';
+    level: number;
+    layerSettings: {
+        [K in ContextLayer]: {
+            enabled: boolean;
+            aggressiveness: 'none' | 'light' | 'medium' | 'aggressive';
+        };
+    };
+}
+export interface EncryptionConfig {
+    enabled: boolean;
+    algorithm: 'aes-256-gcm';
+    keySource: 'os-keychain' | 'env' | 'file';
+}
+export interface QuotaConfig {
+    maxCheckpointsPerSession: number;
+    maxContextSizePerCheckpoint: number;
+    maxTotalStoragePerSession: number;
+    maxGlobalStorage: number;
+    warningThreshold: number;
+    cleanupThreshold: number;
+}
+export interface IContextManagementService {
+    saveCheckpoint(params: SaveCheckpointParams): Promise<SaveCheckpointResult>;
+    loadCheckpoint(params: LoadCheckpointParams): Promise<LoadCheckpointResult>;
+    listCheckpoints(params: ListCheckpointsParams): Promise<CheckpointMetadata[]>;
+    markCritical(params: MarkCriticalParams): Promise<MarkCriticalResult>;
+}
+export interface IContextPersistenceService {
+    processPersistencePipeline(context: RawContext, workflowId: string): Promise<PersistableContext>;
+    restoreFromPersistence(persistableContext: PersistableContext): Promise<RawContext>;
+    classifyContext(context: RawContext): Promise<ClassifiedContext>;
+    getMetrics(): any;
+    resetMetrics(): void;
+}
+export interface IClassificationEngine {
+    classify(context: RawContext): Promise<ClassifiedContext>;
+    markCritical(sessionId: string, contextKey: string): Promise<void>;
+    loadRules(config?: Partial<ClassificationRules>): Promise<void>;
+}
+export interface ICompressionService {
+    compress(classified: ClassifiedContext): Promise<CompressedBlob>;
+    decompress(blob: CompressedBlob): Promise<RawContext>;
+    getStats(): CompressionStats;
+}
+export interface IContextStorage {
+    saveCheckpoint(persistableContext: PersistableContext, metadata: CheckpointMetadata): Promise<void>;
+    loadCheckpoint(checkpointId: string): Promise<{
+        persistableContext: PersistableContext;
+    }>;
+    getCheckpoint(checkpointId: string): Promise<CheckpointMetadata | null>;
+    listCheckpoints(params: {
+        sessionId: string;
+        limit?: number;
+        offset?: number;
+        tags?: string[];
+    }): Promise<CheckpointMetadata[]>;
+    deleteCheckpoint(checkpointId: string): Promise<void>;
+    getSession(sessionId: string): Promise<SessionInfo | null>;
+    upsertSession(session: SessionInfo): Promise<void>;
+}
+export interface SaveCheckpointParams {
+    sessionId?: string;
+    context: RawContext;
+    metadata?: {
+        name?: string;
+        tags?: string[];
+    };
+    force?: boolean;
+}
+export interface SaveCheckpointResult {
+    checkpointId: string;
+    sessionId: string;
+    status: 'SAVED' | 'SKIPPED_UNCHANGED';
+    sizeBytes?: number;
+}
+export interface LoadCheckpointParams {
+    checkpointId?: string;
+    sessionId?: string;
+}
+export interface LoadCheckpointResult {
+    checkpointId: string;
+    sessionId: string;
+    context: RawContext;
+    metadata: CheckpointMetadata;
+}
+export interface ListCheckpointsParams {
+    sessionId: string;
+    limit?: number;
+    offset?: number;
+    tags?: string[];
+}
+export interface MarkCriticalParams {
+    sessionId: string;
+    contextKey: string;
+}
+export interface MarkCriticalResult {
+    status: 'SUCCESS' | 'KEY_NOT_FOUND';
+    message: string;
+}
+export interface CompressionStats {
+    totalOperations: number;
+    averageRatio: number;
+    totalSizeReduction: number;
+    averageCompressionTime: number;
+}
+export interface ContextMetrics {
+    saveOperations: OperationMetrics;
+    loadOperations: OperationMetrics;
+    classificationTime: OperationMetrics;
+    compressionTime: OperationMetrics;
+}
+export interface OperationMetrics {
+    count: number;
+    averageTime: number;
+    p50Time: number;
+    p95Time: number;
+    p99Time: number;
+    errorRate: number;
+}
+export interface SystemHealth {
+    status: 'healthy' | 'degraded' | 'unavailable';
+    storage: {
+        available: boolean;
+        usedSpace: number;
+        availableSpace: number;
+        quotaUsage: number;
+    };
+    performance: {
+        averageSaveTime: number;
+        averageLoadTime: number;
+        compressionRatio: number;
+    };
+    errors: string[];
+}

package/dist/types/context-types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextLayer = void 0;
+var ContextLayer;
+(function (ContextLayer) {
+    ContextLayer["CRITICAL"] = "CRITICAL";
+    ContextLayer["IMPORTANT"] = "IMPORTANT";
+    ContextLayer["USEFUL"] = "USEFUL";
+    ContextLayer["EPHEMERAL"] = "EPHEMERAL";
+})(ContextLayer || (exports.ContextLayer = ContextLayer = {}));

package/dist/utils/storage-security.js

@@ -50,7 +50,7 @@ function validateSecureUrl(url) {
             hostname === '127.0.0.1' ||
             hostname.startsWith('192.168.') ||
             hostname.startsWith('10.') ||
-            hostname.startsWith('172.')) {
+            /^172\.(1[6-9]|2[0-9]|3[01])\./.test(hostname)) {
             throw new error_handler_1.SecurityError('Access to local/private networks not allowed', 'url-validation');
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "MCP server for structured workflow orchestration and step-by-step task guidance",
   "license": "MIT",
   "bin": {
@@ -13,6 +13,7 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
+    "release": "./scripts/release.sh",
     "dev": "npm run build && node dist/mcp-server.js",
     "prepare": "npm run build",
     "watch": "tsc --watch"
@@ -24,6 +25,7 @@
     "commander": "^14.0.0",
     "dotenv": "^17.2.0",
     "json-rpc-2.0": "^1.7.1",
+    "semver": "^7.7.2",
     "tsconfig-paths": "^4.2.0",
     "tslib": "^2.8.1",
     "zod": "^3.22.4"
@@ -38,6 +40,7 @@
   ],
   "devDependencies": {
     "@types/node": "^20.19.9",
+    "@types/semver": "^7.7.0",
     "typescript": "^5.8.3"
   }
 }