overai 1.4.0

package/dist/cli/features/background-jobs.js

@@ -0,0 +1,416 @@
+"use strict";
+/**
+ * Background Jobs - Persisted job queue with adapter support
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobQueue = exports.FileJobStorage = exports.MemoryJobStorage = void 0;
+exports.createJobQueue = createJobQueue;
+exports.createFileJobStorage = createFileJobStorage;
+/**
+ * In-memory job storage adapter
+ */
+class MemoryJobStorage {
+    constructor() {
+        this.jobs = new Map();
+    }
+    async save(job) {
+        this.jobs.set(job.id, { ...job });
+    }
+    async get(id) {
+        return this.jobs.get(id) || null;
+    }
+    async getAll() {
+        return Array.from(this.jobs.values());
+    }
+    async getByStatus(status) {
+        return Array.from(this.jobs.values()).filter(j => j.status === status);
+    }
+    async update(id, updates) {
+        const job = this.jobs.get(id);
+        if (job) {
+            this.jobs.set(id, { ...job, ...updates });
+        }
+    }
+    async delete(id) {
+        this.jobs.delete(id);
+    }
+    async clear() {
+        this.jobs.clear();
+    }
+}
+exports.MemoryJobStorage = MemoryJobStorage;
+/**
+ * File-based job storage adapter
+ */
+class FileJobStorage {
+    constructor(filePath) {
+        this.jobs = new Map();
+        this.initialized = false;
+        this.filePath = filePath;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const content = await fs.readFile(this.filePath, 'utf-8');
+            const data = JSON.parse(content);
+            for (const job of data) {
+                job.createdAt = new Date(job.createdAt);
+                if (job.startedAt)
+                    job.startedAt = new Date(job.startedAt);
+                if (job.completedAt)
+                    job.completedAt = new Date(job.completedAt);
+                this.jobs.set(job.id, job);
+            }
+        }
+        catch {
+            // File doesn't exist yet
+        }
+        this.initialized = true;
+    }
+    async persist() {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        const data = Array.from(this.jobs.values());
+        await fs.writeFile(this.filePath, JSON.stringify(data, null, 2));
+    }
+    async save(job) {
+        await this.init();
+        this.jobs.set(job.id, { ...job });
+        await this.persist();
+    }
+    async get(id) {
+        await this.init();
+        return this.jobs.get(id) || null;
+    }
+    async getAll() {
+        await this.init();
+        return Array.from(this.jobs.values());
+    }
+    async getByStatus(status) {
+        await this.init();
+        return Array.from(this.jobs.values()).filter(j => j.status === status);
+    }
+    async update(id, updates) {
+        await this.init();
+        const job = this.jobs.get(id);
+        if (job) {
+            this.jobs.set(id, { ...job, ...updates });
+            await this.persist();
+        }
+    }
+    async delete(id) {
+        await this.init();
+        this.jobs.delete(id);
+        await this.persist();
+    }
+    async clear() {
+        this.jobs.clear();
+        await this.persist();
+    }
+}
+exports.FileJobStorage = FileJobStorage;
+/**
+ * Job Queue class
+ */
+class JobQueue {
+    constructor(config = {}) {
+        this.handlers = new Map();
+        this.running = false;
+        this.activeJobs = 0;
+        this.config = {
+            name: 'default',
+            concurrency: 1,
+            maxAttempts: 3,
+            retryDelay: 1000,
+            ...config
+        };
+        this.storage = config.storage || new MemoryJobStorage();
+    }
+    /**
+     * Register a job handler
+     */
+    register(name, handler) {
+        this.handlers.set(name, handler);
+    }
+    /**
+     * Add a job to the queue
+     */
+    async add(name, data, options = {}) {
+        const job = {
+            id: `job_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            name,
+            data,
+            status: 'pending',
+            priority: options.priority || 'normal',
+            attempts: 0,
+            maxAttempts: options.maxAttempts || this.config.maxAttempts || 3,
+            createdAt: new Date(),
+            metadata: options.metadata
+        };
+        await this.storage.save(job);
+        return job;
+    }
+    /**
+     * Get a job by ID
+     */
+    async get(id) {
+        return this.storage.get(id);
+    }
+    /**
+     * Get all jobs
+     */
+    async getAll() {
+        return this.storage.getAll();
+    }
+    /**
+     * Get jobs by status
+     */
+    async getByStatus(status) {
+        return this.storage.getByStatus(status);
+    }
+    /**
+     * Cancel a job
+     */
+    async cancel(id) {
+        const job = await this.storage.get(id);
+        if (!job || job.status === 'running' || job.status === 'completed') {
+            return false;
+        }
+        await this.storage.update(id, { status: 'cancelled' });
+        return true;
+    }
+    /**
+     * Retry a failed job
+     */
+    async retry(id) {
+        const job = await this.storage.get(id);
+        if (!job || job.status !== 'failed') {
+            return false;
+        }
+        await this.storage.update(id, {
+            status: 'pending',
+            attempts: 0,
+            error: undefined
+        });
+        return true;
+    }
+    /**
+     * Start processing jobs
+     */
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.processInterval = setInterval(() => this.process(), 100);
+    }
+    /**
+     * Stop processing jobs
+     */
+    stop() {
+        this.running = false;
+        if (this.processInterval) {
+            clearInterval(this.processInterval);
+            this.processInterval = undefined;
+        }
+    }
+    /**
+     * Process pending jobs
+     */
+    async process() {
+        if (!this.running)
+            return;
+        if (this.activeJobs >= (this.config.concurrency || 1))
+            return;
+        const pendingJobs = await this.storage.getByStatus('pending');
+        // Sort by priority and creation time
+        const priorityOrder = {
+            critical: 0,
+            high: 1,
+            normal: 2,
+            low: 3
+        };
+        pendingJobs.sort((a, b) => {
+            const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+            if (priorityDiff !== 0)
+                return priorityDiff;
+            return a.createdAt.getTime() - b.createdAt.getTime();
+        });
+        for (const job of pendingJobs) {
+            if (this.activeJobs >= (this.config.concurrency || 1))
+                break;
+            this.runJob(job);
+        }
+    }
+    /**
+     * Run a single job
+     */
+    async runJob(job) {
+        const handler = this.handlers.get(job.name);
+        if (!handler) {
+            await this.storage.update(job.id, {
+                status: 'failed',
+                error: `No handler registered for job type: ${job.name}`
+            });
+            return;
+        }
+        this.activeJobs++;
+        await this.storage.update(job.id, {
+            status: 'running',
+            startedAt: new Date(),
+            attempts: job.attempts + 1
+        });
+        const context = {
+            updateProgress: async (progress) => {
+                await this.storage.update(job.id, { progress });
+            },
+            log: (message) => {
+                console.log(`[Job ${job.id}] ${message}`);
+            }
+        };
+        try {
+            const result = await handler(job, context);
+            await this.storage.update(job.id, {
+                status: 'completed',
+                completedAt: new Date(),
+                result,
+                progress: 100
+            });
+        }
+        catch (error) {
+            const attempts = job.attempts + 1;
+            if (attempts < job.maxAttempts) {
+                // Retry after delay
+                setTimeout(async () => {
+                    await this.storage.update(job.id, {
+                        status: 'pending',
+                        error: error.message
+                    });
+                }, this.config.retryDelay || 1000);
+            }
+            else {
+                await this.storage.update(job.id, {
+                    status: 'failed',
+                    completedAt: new Date(),
+                    error: error.message
+                });
+            }
+        }
+        finally {
+            this.activeJobs--;
+        }
+    }
+    /**
+     * Process a job immediately (bypass queue)
+     */
+    async processNow(id) {
+        const job = await this.storage.get(id);
+        if (!job)
+            throw new Error(`Job ${id} not found`);
+        const handler = this.handlers.get(job.name);
+        if (!handler)
+            throw new Error(`No handler for job type: ${job.name}`);
+        await this.storage.update(job.id, {
+            status: 'running',
+            startedAt: new Date()
+        });
+        const context = {
+            updateProgress: async (progress) => {
+                await this.storage.update(job.id, { progress });
+            },
+            log: console.log
+        };
+        try {
+            const result = await handler(job, context);
+            await this.storage.update(job.id, {
+                status: 'completed',
+                completedAt: new Date(),
+                result
+            });
+            return result;
+        }
+        catch (error) {
+            await this.storage.update(job.id, {
+                status: 'failed',
+                completedAt: new Date(),
+                error: error.message
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get queue stats
+     */
+    async getStats() {
+        const all = await this.storage.getAll();
+        return {
+            pending: all.filter(j => j.status === 'pending').length,
+            running: all.filter(j => j.status === 'running').length,
+            completed: all.filter(j => j.status === 'completed').length,
+            failed: all.filter(j => j.status === 'failed').length,
+            cancelled: all.filter(j => j.status === 'cancelled').length
+        };
+    }
+    /**
+     * Clear completed/failed jobs
+     */
+    async cleanup(olderThan) {
+        const all = await this.storage.getAll();
+        let count = 0;
+        for (const job of all) {
+            if (job.status === 'completed' || job.status === 'failed' || job.status === 'cancelled') {
+                if (!olderThan || (job.completedAt && job.completedAt < olderThan)) {
+                    await this.storage.delete(job.id);
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+}
+exports.JobQueue = JobQueue;
+/**
+ * Create a job queue
+ */
+function createJobQueue(config) {
+    return new JobQueue(config);
+}
+/**
+ * Create a file-based job storage
+ */
+function createFileJobStorage(filePath) {
+    return new FileJobStorage(filePath);
+}

package/dist/cli/features/checkpoints.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Checkpoints - Snapshot session/run state for recovery
+ */
+export interface CheckpointData {
+    id: string;
+    name: string;
+    timestamp: Date;
+    sessionId?: string;
+    runId?: string;
+    agentId?: string;
+    state: Record<string, any>;
+    messages?: any[];
+    metadata?: Record<string, any>;
+}
+export interface CheckpointConfig {
+    storage?: CheckpointStorage;
+    autoSave?: boolean;
+    autoSaveInterval?: number;
+    maxCheckpoints?: number;
+}
+export interface CheckpointStorage {
+    save(checkpoint: CheckpointData): Promise<void>;
+    load(id: string): Promise<CheckpointData | null>;
+    list(): Promise<CheckpointData[]>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * In-memory checkpoint storage
+ */
+export declare class MemoryCheckpointStorage implements CheckpointStorage {
+    private checkpoints;
+    save(checkpoint: CheckpointData): Promise<void>;
+    load(id: string): Promise<CheckpointData | null>;
+    list(): Promise<CheckpointData[]>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * File-based checkpoint storage
+ */
+export declare class FileCheckpointStorage implements CheckpointStorage {
+    private dirPath;
+    constructor(dirPath: string);
+    private ensureDir;
+    private getFilePath;
+    save(checkpoint: CheckpointData): Promise<void>;
+    load(id: string): Promise<CheckpointData | null>;
+    list(): Promise<CheckpointData[]>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * Checkpoint Manager class
+ */
+export declare class CheckpointManager {
+    private config;
+    private storage;
+    private autoSaveTimer?;
+    private currentState;
+    constructor(config?: CheckpointConfig);
+    /**
+     * Create a checkpoint
+     */
+    create(name: string, options?: Partial<CheckpointData>): Promise<CheckpointData>;
+    /**
+     * Restore from a checkpoint
+     */
+    restore(id: string): Promise<CheckpointData | null>;
+    /**
+     * Restore the latest checkpoint
+     */
+    restoreLatest(): Promise<CheckpointData | null>;
+    /**
+     * Get a checkpoint by ID
+     */
+    get(id: string): Promise<CheckpointData | null>;
+    /**
+     * List all checkpoints
+     */
+    list(): Promise<CheckpointData[]>;
+    /**
+     * Delete a checkpoint
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Clear all checkpoints
+     */
+    clear(): Promise<void>;
+    /**
+     * Update current state
+     */
+    setState(state: Record<string, any>): void;
+    /**
+     * Get current state
+     */
+    getState(): Record<string, any>;
+    /**
+     * Start auto-save
+     */
+    startAutoSave(): void;
+    /**
+     * Stop auto-save
+     */
+    stopAutoSave(): void;
+    /**
+     * Enforce maximum checkpoints limit
+     */
+    private enforceMaxCheckpoints;
+    /**
+     * Export checkpoint to JSON string
+     */
+    export(id: string): Promise<string | null>;
+    /**
+     * Import checkpoint from JSON string
+     */
+    import(json: string): Promise<CheckpointData>;
+}
+/**
+ * Create a checkpoint manager
+ */
+export declare function createCheckpointManager(config?: CheckpointConfig): CheckpointManager;
+/**
+ * Create file-based checkpoint storage
+ */
+export declare function createFileCheckpointStorage(dirPath: string): FileCheckpointStorage;