cowork-os 0.3.21

package/dist/electron/electron/cron/service.js

@@ -0,0 +1,614 @@
+"use strict";
+/**
+ * CronService - Manages scheduled task execution
+ * Handles job lifecycle, timer management, and task creation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronService = void 0;
+exports.getCronService = getCronService;
+exports.setCronService = setCronService;
+const uuid_1 = require("uuid");
+const store_1 = require("./store");
+const schedule_1 = require("./schedule");
+const webhook_1 = require("./webhook");
+// Maximum timeout value to prevent overflow warnings (2^31 - 1 ms, ~24.8 days)
+const MAX_TIMEOUT_MS = 2147483647;
+// Defaults
+const DEFAULT_MAX_CONCURRENT_RUNS = 1;
+const DEFAULT_JOB_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+const DEFAULT_MAX_HISTORY_ENTRIES = 10;
+// Default logger
+const defaultLog = {
+    debug: (msg, data) => console.log(`[Cron] ${msg}`, data ?? ''),
+    info: (msg, data) => console.log(`[Cron] ${msg}`, data ?? ''),
+    warn: (msg, data) => console.warn(`[Cron] ${msg}`, data ?? ''),
+    error: (msg, data) => console.error(`[Cron] ${msg}`, data ?? ''),
+};
+class CronService {
+    constructor(deps) {
+        this.state = {
+            deps: {
+                ...deps,
+                nowMs: deps.nowMs ?? (() => Date.now()),
+                log: deps.log ?? defaultLog,
+                maxConcurrentRuns: deps.maxConcurrentRuns ?? DEFAULT_MAX_CONCURRENT_RUNS,
+                defaultTimeoutMs: deps.defaultTimeoutMs ?? DEFAULT_JOB_TIMEOUT_MS,
+                maxHistoryEntries: deps.maxHistoryEntries ?? DEFAULT_MAX_HISTORY_ENTRIES,
+                webhook: deps.webhook,
+                deliverToChannel: deps.deliverToChannel,
+            },
+            store: null,
+            timer: null,
+            running: false,
+            runningJobIds: new Set(),
+            opLock: Promise.resolve(),
+            webhookServer: null,
+        };
+    }
+    /**
+     * Start the cron service
+     * Loads jobs from store and arms the timer
+     */
+    async start() {
+        await this.withLock(async () => {
+            const { deps, log } = this.getContext();
+            if (!deps.cronEnabled) {
+                log.info('Cron service disabled');
+                return;
+            }
+            const storePath = (0, store_1.resolveCronStorePath)(deps.storePath);
+            this.state.store = await (0, store_1.loadCronStore)(storePath);
+            const enabledCount = this.state.store.jobs.filter((j) => j.enabled).length;
+            log.info(`Cron service started with ${enabledCount} enabled jobs`);
+            // Compute next run times for all enabled jobs
+            const nowMs = deps.nowMs();
+            for (const job of this.state.store.jobs) {
+                if (job.enabled && !job.state.nextRunAtMs) {
+                    job.state.nextRunAtMs = (0, schedule_1.computeNextRunAtMs)(job.schedule, nowMs);
+                }
+            }
+            await this.persist();
+            this.armTimer();
+            // Start webhook server if configured
+            if (deps.webhook?.enabled) {
+                await this.startWebhookServer();
+            }
+        });
+    }
+    /**
+     * Start the webhook server for external triggers
+     */
+    async startWebhookServer() {
+        const { deps, log } = this.getContext();
+        if (!deps.webhook?.enabled)
+            return;
+        try {
+            this.state.webhookServer = new webhook_1.CronWebhookServer({
+                enabled: true,
+                port: deps.webhook.port,
+                host: deps.webhook.host,
+                secret: deps.webhook.secret,
+            });
+            // Set up the trigger handler
+            this.state.webhookServer.setTriggerHandler(async (jobId, force) => {
+                return this.run(jobId, force ? 'force' : 'due');
+            });
+            // Set up job lookup
+            this.state.webhookServer.setJobLookup(async () => {
+                const jobs = await this.list({ includeDisabled: true });
+                return jobs.map((j) => ({ id: j.id, name: j.name }));
+            });
+            await this.state.webhookServer.start();
+            log.info(`Webhook server started on port ${deps.webhook.port}`);
+        }
+        catch (error) {
+            log.error('Failed to start webhook server:', error);
+        }
+    }
+    /**
+     * Stop the cron service
+     */
+    async stop() {
+        this.stopTimer();
+        // Stop webhook server if running
+        if (this.state.webhookServer) {
+            await this.state.webhookServer.stop();
+            this.state.webhookServer = null;
+        }
+        this.state.store = null;
+        this.getContext().log.info('Cron service stopped');
+    }
+    /**
+     * Get service status
+     */
+    async status() {
+        return this.withLock(async () => {
+            const { deps } = this.getContext();
+            const store = this.ensureStore();
+            const nextJob = store.jobs
+                .filter((j) => j.enabled && j.state.nextRunAtMs)
+                .sort((a, b) => (a.state.nextRunAtMs ?? Infinity) - (b.state.nextRunAtMs ?? Infinity))[0];
+            const webhookAddr = this.state.webhookServer?.getAddress();
+            return {
+                enabled: deps.cronEnabled,
+                storePath: (0, store_1.resolveCronStorePath)(deps.storePath),
+                jobCount: store.jobs.length,
+                enabledJobCount: store.jobs.filter((j) => j.enabled).length,
+                runningJobCount: this.state.runningJobIds.size,
+                maxConcurrentRuns: deps.maxConcurrentRuns,
+                nextWakeAtMs: nextJob?.state.nextRunAtMs ?? null,
+                webhook: webhookAddr
+                    ? {
+                        enabled: true,
+                        host: webhookAddr.host,
+                        port: webhookAddr.port,
+                    }
+                    : undefined,
+            };
+        });
+    }
+    /**
+     * Get run history for a job
+     */
+    async getRunHistory(jobId) {
+        return this.withLock(async () => {
+            const store = this.ensureStore();
+            const job = store.jobs.find((j) => j.id === jobId);
+            if (!job)
+                return null;
+            return {
+                jobId: job.id,
+                jobName: job.name,
+                entries: job.state.runHistory ?? [],
+                totalRuns: job.state.totalRuns ?? 0,
+                successfulRuns: job.state.successfulRuns ?? 0,
+                failedRuns: job.state.failedRuns ?? 0,
+            };
+        });
+    }
+    /**
+     * List all jobs
+     */
+    async list(opts) {
+        return this.withLock(async () => {
+            const { deps } = this.getContext();
+            const store = this.ensureStore();
+            let jobs = [...store.jobs];
+            if (!opts?.includeDisabled) {
+                jobs = jobs.filter((j) => j.enabled);
+            }
+            // Sort by next run time
+            jobs.sort((a, b) => (a.state.nextRunAtMs ?? Infinity) - (b.state.nextRunAtMs ?? Infinity));
+            return jobs;
+        });
+    }
+    /**
+     * Get a single job by ID
+     */
+    async get(id) {
+        return this.withLock(async () => {
+            const store = this.ensureStore();
+            return store.jobs.find((j) => j.id === id) ?? null;
+        });
+    }
+    /**
+     * Add a new job
+     */
+    async add(input) {
+        return this.withLock(async () => {
+            const { deps, log } = this.getContext();
+            const store = this.ensureStore();
+            const nowMs = deps.nowMs();
+            const job = {
+                id: (0, uuid_1.v4)(),
+                name: input.name,
+                description: input.description,
+                enabled: input.enabled,
+                deleteAfterRun: input.deleteAfterRun,
+                createdAtMs: nowMs,
+                updatedAtMs: nowMs,
+                schedule: input.schedule,
+                workspaceId: input.workspaceId,
+                taskPrompt: input.taskPrompt,
+                taskTitle: input.taskTitle,
+                // Advanced options
+                timeoutMs: input.timeoutMs,
+                modelKey: input.modelKey,
+                maxHistoryEntries: input.maxHistoryEntries,
+                delivery: input.delivery,
+                state: {
+                    ...input.state,
+                    nextRunAtMs: input.enabled ? (0, schedule_1.computeNextRunAtMs)(input.schedule, nowMs) : undefined,
+                    runHistory: [],
+                    totalRuns: 0,
+                    successfulRuns: 0,
+                    failedRuns: 0,
+                },
+            };
+            store.jobs.push(job);
+            await this.persist();
+            this.armTimer();
+            log.info(`Added job: ${job.name} (${job.id})`);
+            this.emit({ jobId: job.id, action: 'added', nextRunAtMs: job.state.nextRunAtMs });
+            return { ok: true, job };
+        });
+    }
+    /**
+     * Update an existing job
+     */
+    async update(id, patch) {
+        return this.withLock(async () => {
+            const { deps, log } = this.getContext();
+            const store = this.ensureStore();
+            const nowMs = deps.nowMs();
+            const index = store.jobs.findIndex((j) => j.id === id);
+            if (index === -1) {
+                return { ok: false, error: 'Job not found' };
+            }
+            const job = store.jobs[index];
+            const wasEnabled = job.enabled;
+            // Apply patch - basic fields
+            if (patch.name !== undefined)
+                job.name = patch.name;
+            if (patch.description !== undefined)
+                job.description = patch.description;
+            if (patch.enabled !== undefined)
+                job.enabled = patch.enabled;
+            if (patch.deleteAfterRun !== undefined)
+                job.deleteAfterRun = patch.deleteAfterRun;
+            if (patch.schedule !== undefined)
+                job.schedule = patch.schedule;
+            if (patch.workspaceId !== undefined)
+                job.workspaceId = patch.workspaceId;
+            if (patch.taskPrompt !== undefined)
+                job.taskPrompt = patch.taskPrompt;
+            if (patch.taskTitle !== undefined)
+                job.taskTitle = patch.taskTitle;
+            // Apply patch - advanced options
+            if (patch.timeoutMs !== undefined)
+                job.timeoutMs = patch.timeoutMs;
+            if (patch.modelKey !== undefined)
+                job.modelKey = patch.modelKey;
+            if (patch.maxHistoryEntries !== undefined)
+                job.maxHistoryEntries = patch.maxHistoryEntries;
+            if (patch.delivery !== undefined)
+                job.delivery = patch.delivery;
+            if (patch.state) {
+                job.state = { ...job.state, ...patch.state };
+            }
+            job.updatedAtMs = nowMs;
+            // Recompute next run time if schedule changed or job was enabled
+            if (patch.schedule || (!wasEnabled && job.enabled)) {
+                job.state.nextRunAtMs = job.enabled ? (0, schedule_1.computeNextRunAtMs)(job.schedule, nowMs) : undefined;
+            }
+            // Clear next run time if disabled
+            if (!job.enabled) {
+                job.state.nextRunAtMs = undefined;
+            }
+            await this.persist();
+            this.armTimer();
+            log.info(`Updated job: ${job.name} (${job.id})`);
+            this.emit({ jobId: job.id, action: 'updated', nextRunAtMs: job.state.nextRunAtMs });
+            return { ok: true, job };
+        });
+    }
+    /**
+     * Remove a job
+     */
+    async remove(id) {
+        return this.withLock(async () => {
+            const { log } = this.getContext();
+            const store = this.ensureStore();
+            const index = store.jobs.findIndex((j) => j.id === id);
+            if (index === -1) {
+                return { ok: true, removed: false };
+            }
+            const job = store.jobs[index];
+            store.jobs.splice(index, 1);
+            await this.persist();
+            this.armTimer();
+            log.info(`Removed job: ${job.name} (${job.id})`);
+            this.emit({ jobId: id, action: 'removed' });
+            return { ok: true, removed: true };
+        });
+    }
+    /**
+     * Run a job immediately or when due
+     */
+    async run(id, mode = 'due') {
+        return this.withLock(async () => {
+            const { deps, log } = this.getContext();
+            const store = this.ensureStore();
+            const nowMs = deps.nowMs();
+            const job = store.jobs.find((j) => j.id === id);
+            if (!job) {
+                return { ok: true, ran: false, reason: 'not-found' };
+            }
+            if (!job.enabled && mode !== 'force') {
+                return { ok: true, ran: false, reason: 'disabled' };
+            }
+            // Check if due (unless forcing)
+            if (mode === 'due') {
+                const nextRun = job.state.nextRunAtMs;
+                if (!nextRun || nextRun > nowMs) {
+                    return { ok: true, ran: false, reason: 'not-due' };
+                }
+            }
+            // Execute the job
+            return this.executeJob(job, nowMs);
+        });
+    }
+    // =====================
+    // Private Methods
+    // =====================
+    getContext() {
+        return {
+            deps: this.state.deps,
+            log: this.state.deps.log,
+        };
+    }
+    ensureStore() {
+        if (!this.state.store) {
+            this.state.store = { version: 1, jobs: [] };
+        }
+        return this.state.store;
+    }
+    async persist() {
+        const store = this.ensureStore();
+        const storePath = (0, store_1.resolveCronStorePath)(this.state.deps.storePath);
+        await (0, store_1.saveCronStore)(storePath, store);
+    }
+    emit(evt) {
+        this.state.deps.onEvent?.(evt);
+    }
+    async withLock(fn) {
+        const prevOp = this.state.opLock;
+        let resolve;
+        this.state.opLock = new Promise((r) => {
+            resolve = r;
+        });
+        try {
+            await prevOp;
+            return await fn();
+        }
+        finally {
+            resolve();
+        }
+    }
+    /**
+     * Execute a job and create a task
+     */
+    async executeJob(job, nowMs) {
+        const { deps, log } = this.getContext();
+        const store = this.ensureStore();
+        // Track that this job is running
+        this.state.runningJobIds.add(job.id);
+        log.info(`Executing job: ${job.name} (${job.id})`);
+        this.emit({ jobId: job.id, action: 'started', runAtMs: nowMs });
+        job.state.runningAtMs = nowMs;
+        job.state.lastRunAtMs = nowMs;
+        const startTime = Date.now();
+        let taskId;
+        let status = 'ok';
+        let errorMsg;
+        try {
+            // Create a task with optional model override
+            const result = await deps.createTask({
+                title: job.taskTitle || `Scheduled: ${job.name}`,
+                prompt: job.taskPrompt,
+                workspaceId: job.workspaceId,
+                modelKey: job.modelKey,
+            });
+            taskId = result.id;
+            job.state.lastTaskId = taskId;
+            log.info(`Job ${job.name} created task ${taskId}`);
+        }
+        catch (error) {
+            errorMsg = error instanceof Error ? error.message : String(error);
+            status = 'error';
+            log.error(`Job ${job.name} failed: ${errorMsg}`);
+        }
+        const durationMs = Date.now() - startTime;
+        // Update job state
+        job.state.lastDurationMs = durationMs;
+        job.state.runningAtMs = undefined;
+        job.state.lastStatus = status;
+        job.state.lastError = errorMsg;
+        // Update run statistics
+        job.state.totalRuns = (job.state.totalRuns ?? 0) + 1;
+        if (status === 'ok') {
+            job.state.successfulRuns = (job.state.successfulRuns ?? 0) + 1;
+        }
+        else {
+            job.state.failedRuns = (job.state.failedRuns ?? 0) + 1;
+        }
+        // Add to run history
+        const historyEntry = {
+            runAtMs: nowMs,
+            durationMs,
+            status,
+            error: errorMsg,
+            taskId,
+        };
+        job.state.runHistory = job.state.runHistory ?? [];
+        job.state.runHistory.unshift(historyEntry);
+        // Trim history to max entries
+        const maxEntries = job.maxHistoryEntries ?? deps.maxHistoryEntries;
+        if (job.state.runHistory.length > maxEntries) {
+            job.state.runHistory = job.state.runHistory.slice(0, maxEntries);
+        }
+        // Remove from running jobs
+        this.state.runningJobIds.delete(job.id);
+        // Handle one-shot jobs
+        if (job.deleteAfterRun) {
+            const index = store.jobs.findIndex((j) => j.id === job.id);
+            if (index !== -1) {
+                store.jobs.splice(index, 1);
+            }
+            log.info(`Deleted one-shot job: ${job.name}`);
+        }
+        else {
+            // Compute next run time
+            job.state.nextRunAtMs = job.enabled ? (0, schedule_1.computeNextRunAtMs)(job.schedule, nowMs) : undefined;
+        }
+        await this.persist();
+        this.armTimer();
+        // Deliver results to channel if configured
+        await this.deliverToChannel(job, status, taskId, errorMsg);
+        this.emit({
+            jobId: job.id,
+            action: 'finished',
+            runAtMs: nowMs,
+            durationMs,
+            status,
+            error: errorMsg,
+            taskId,
+            nextRunAtMs: job.state.nextRunAtMs,
+        });
+        if (taskId) {
+            return { ok: true, ran: true, taskId };
+        }
+        else {
+            return { ok: false, error: errorMsg || 'Unknown error' };
+        }
+    }
+    /**
+     * Deliver job results to a configured channel
+     */
+    async deliverToChannel(job, status, taskId, error) {
+        const { deps, log } = this.getContext();
+        // Check if delivery is configured and enabled
+        if (!job.delivery?.enabled || !deps.deliverToChannel) {
+            return;
+        }
+        const { channelType, channelId, deliverOnSuccess, deliverOnError, summaryOnly } = job.delivery;
+        // Check if we should deliver based on status
+        const isSuccess = status === 'ok';
+        const shouldDeliver = (isSuccess && deliverOnSuccess !== false) || (!isSuccess && deliverOnError !== false);
+        if (!shouldDeliver || !channelType || !channelId) {
+            return;
+        }
+        try {
+            await deps.deliverToChannel({
+                channelType,
+                channelId,
+                jobName: job.name,
+                status,
+                taskId,
+                error,
+                summaryOnly,
+            });
+            log.info(`Delivered results for job "${job.name}" to ${channelType}:${channelId}`);
+        }
+        catch (deliveryError) {
+            log.error(`Failed to deliver results for job "${job.name}":`, deliveryError);
+        }
+    }
+    /**
+     * Arm the timer for the next job execution
+     */
+    armTimer() {
+        this.stopTimer();
+        const { deps, log } = this.getContext();
+        if (!deps.cronEnabled)
+            return;
+        const store = this.ensureStore();
+        const nowMs = deps.nowMs();
+        // Find the next job to run
+        const nextJob = store.jobs
+            .filter((j) => j.enabled && j.state.nextRunAtMs)
+            .sort((a, b) => (a.state.nextRunAtMs ?? Infinity) - (b.state.nextRunAtMs ?? Infinity))[0];
+        if (!nextJob || !nextJob.state.nextRunAtMs) {
+            log.debug('No jobs scheduled');
+            return;
+        }
+        let delayMs = nextJob.state.nextRunAtMs - nowMs;
+        // Clamp delay to prevent overflow
+        if (delayMs > MAX_TIMEOUT_MS) {
+            log.debug(`Clamping timer delay from ${delayMs}ms to ${MAX_TIMEOUT_MS}ms`);
+            delayMs = MAX_TIMEOUT_MS;
+        }
+        // Don't set timer for past times
+        if (delayMs <= 0) {
+            delayMs = 1;
+        }
+        log.debug(`Next job "${nextJob.name}" in ${Math.round(delayMs / 1000)}s`);
+        this.state.timer = setTimeout(() => {
+            this.onTimer().catch((err) => {
+                log.error('Timer callback error:', err);
+            });
+        }, delayMs);
+    }
+    stopTimer() {
+        if (this.state.timer) {
+            clearTimeout(this.state.timer);
+            this.state.timer = null;
+        }
+    }
+    /**
+     * Timer callback - runs due jobs
+     */
+    async onTimer() {
+        // Prevent concurrent timer callbacks
+        if (this.state.running)
+            return;
+        this.state.running = true;
+        try {
+            const { deps, log } = this.getContext();
+            const store = this.ensureStore();
+            const nowMs = deps.nowMs();
+            // Find all due jobs that aren't already running
+            const dueJobs = store.jobs.filter((j) => j.enabled &&
+                j.state.nextRunAtMs &&
+                j.state.nextRunAtMs <= nowMs &&
+                !this.state.runningJobIds.has(j.id));
+            // Sort by next run time (oldest first)
+            dueJobs.sort((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0));
+            // Execute due jobs up to max concurrent limit
+            const availableSlots = deps.maxConcurrentRuns - this.state.runningJobIds.size;
+            const jobsToRun = dueJobs.slice(0, Math.max(0, availableSlots));
+            if (dueJobs.length > jobsToRun.length) {
+                log.debug(`${dueJobs.length} jobs due, running ${jobsToRun.length} (max concurrent: ${deps.maxConcurrentRuns})`);
+            }
+            // Execute jobs
+            for (const job of jobsToRun) {
+                try {
+                    await this.executeJob(job, nowMs);
+                }
+                catch (error) {
+                    log.error(`Failed to execute job ${job.name}:`, error);
+                }
+            }
+        }
+        finally {
+            this.state.running = false;
+            this.armTimer();
+        }
+    }
+    /**
+     * Clear run history for a job
+     */
+    async clearRunHistory(jobId) {
+        return this.withLock(async () => {
+            const store = this.ensureStore();
+            const job = store.jobs.find((j) => j.id === jobId);
+            if (!job)
+                return false;
+            job.state.runHistory = [];
+            job.state.totalRuns = 0;
+            job.state.successfulRuns = 0;
+            job.state.failedRuns = 0;
+            await this.persist();
+            return true;
+        });
+    }
+}
+exports.CronService = CronService;
+// Singleton instance
+let cronService = null;
+function getCronService() {
+    return cronService;
+}
+function setCronService(service) {
+    cronService = service;
+}