cowork-os 0.3.21

package/dist/electron/electron/agent/tools/cron-tools.js

@@ -0,0 +1,577 @@
+"use strict";
+/**
+ * CronTools - Agent tools for managing scheduled tasks
+ * Allows the AI agent to create, manage, and execute scheduled tasks
+ * through natural language interaction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronTools = void 0;
+const types_1 = require("../../../shared/types");
+const cron_1 = require("../../cron");
+// UUID validation regex
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * CronTools provides scheduled task management capabilities
+ * Enables agents to schedule reminders, recurring tasks, and one-time events
+ */
+class CronTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    /**
+     * Update the workspace for this tool
+     */
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    /**
+     * Get the status of the cron scheduler
+     */
+    async getStatus() {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'schedule_status',
+        });
+        const service = (0, cron_1.getCronService)();
+        if (!service) {
+            return { error: 'Scheduler service is not running' };
+        }
+        const status = await service.status();
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'schedule_status',
+            success: true,
+            jobCount: status.jobCount,
+        });
+        return status;
+    }
+    /**
+     * List all scheduled tasks
+     */
+    async listJobs(includeDisabled = false) {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'schedule_list',
+            includeDisabled,
+        });
+        const service = (0, cron_1.getCronService)();
+        if (!service) {
+            return { error: 'Scheduler service is not running' };
+        }
+        const jobs = await service.list({ includeDisabled });
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'schedule_list',
+            success: true,
+            count: jobs.length,
+        });
+        return jobs;
+    }
+    /**
+     * Create a new scheduled task
+     */
+    async createJob(params) {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'schedule_create',
+            name: params.name,
+            scheduleType: params.schedule.type,
+        });
+        const service = (0, cron_1.getCronService)();
+        if (!service) {
+            return { success: false, error: 'Scheduler service is not running' };
+        }
+        // Validate workspace ID is a proper UUID (not temp workspace)
+        if (this.workspace.id === types_1.TEMP_WORKSPACE_ID || !UUID_REGEX.test(this.workspace.id)) {
+            return {
+                success: false,
+                error: 'Cannot schedule tasks in the temporary workspace. ' +
+                    'Please create or select a proper workspace first, then try scheduling again.',
+            };
+        }
+        // Parse the schedule into CronSchedule format
+        let schedule;
+        try {
+            schedule = this.parseSchedule(params.schedule);
+        }
+        catch (error) {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'schedule_create',
+                error: error.message,
+            });
+            return { success: false, error: error.message };
+        }
+        // Create the job
+        const jobCreate = {
+            name: params.name,
+            description: params.description,
+            enabled: params.enabled ?? true,
+            deleteAfterRun: params.deleteAfterRun ?? (params.schedule.type === 'once'),
+            schedule,
+            workspaceId: this.workspace.id,
+            taskPrompt: params.prompt,
+            taskTitle: params.name,
+        };
+        const result = await service.add(jobCreate);
+        if (result.ok) {
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'schedule_create',
+                success: true,
+                jobId: result.job.id,
+                nextRun: result.job.state.nextRunAtMs,
+            });
+            return { success: true, job: result.job };
+        }
+        else {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'schedule_create',
+                error: result.error,
+            });
+            return { success: false, error: result.error };
+        }
+    }
+    /**
+     * Update an existing scheduled task
+     */
+    async updateJob(params) {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'schedule_update',
+            id: params.id,
+            name: params.name,
+        });
+        const service = (0, cron_1.getCronService)();
+        if (!service) {
+            return { success: false, error: 'Scheduler service is not running' };
+        }
+        // Find job by ID or name
+        let jobId = params.id;
+        if (!jobId && params.name) {
+            const jobs = await service.list({ includeDisabled: true });
+            const job = jobs.find((j) => j.name.toLowerCase() === params.name.toLowerCase());
+            if (job) {
+                jobId = job.id;
+            }
+        }
+        if (!jobId) {
+            return { success: false, error: 'Job not found. Provide a valid job ID or name.' };
+        }
+        // Build patch object
+        const patch = {};
+        if (params.updates.name)
+            patch.name = params.updates.name;
+        if (params.updates.description)
+            patch.description = params.updates.description;
+        if (params.updates.prompt)
+            patch.taskPrompt = params.updates.prompt;
+        if (params.updates.enabled !== undefined)
+            patch.enabled = params.updates.enabled;
+        if (params.updates.schedule) {
+            try {
+                patch.schedule = this.parseSchedule(params.updates.schedule);
+            }
+            catch (error) {
+                return { success: false, error: error.message };
+            }
+        }
+        const result = await service.update(jobId, patch);
+        if (result.ok) {
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'schedule_update',
+                success: true,
+                jobId: result.job.id,
+            });
+            return { success: true, job: result.job };
+        }
+        else {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'schedule_update',
+                error: result.error,
+            });
+            return { success: false, error: result.error };
+        }
+    }
+    /**
+     * Remove a scheduled task
+     */
+    async removeJob(params) {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'schedule_remove',
+            id: params.id,
+            name: params.name,
+        });
+        const service = (0, cron_1.getCronService)();
+        if (!service) {
+            return { success: false, removed: false, error: 'Scheduler service is not running' };
+        }
+        // Find job by ID or name
+        let jobId = params.id;
+        if (!jobId && params.name) {
+            const jobs = await service.list({ includeDisabled: true });
+            const job = jobs.find((j) => j.name.toLowerCase() === params.name.toLowerCase());
+            if (job) {
+                jobId = job.id;
+            }
+        }
+        if (!jobId) {
+            return { success: false, removed: false, error: 'Job not found. Provide a valid job ID or name.' };
+        }
+        const result = await service.remove(jobId);
+        if (result.ok) {
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'schedule_remove',
+                success: true,
+                removed: result.removed,
+            });
+            return { success: true, removed: result.removed };
+        }
+        else {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'schedule_remove',
+                error: result.error,
+            });
+            return { success: false, removed: false, error: result.error };
+        }
+    }
+    /**
+     * Run a scheduled task immediately
+     */
+    async runJob(params) {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'schedule_run',
+            id: params.id,
+            name: params.name,
+        });
+        const service = (0, cron_1.getCronService)();
+        if (!service) {
+            return { success: false, error: 'Scheduler service is not running' };
+        }
+        // Find job by ID or name
+        let jobId = params.id;
+        if (!jobId && params.name) {
+            const jobs = await service.list({ includeDisabled: true });
+            const job = jobs.find((j) => j.name.toLowerCase() === params.name.toLowerCase());
+            if (job) {
+                jobId = job.id;
+            }
+        }
+        if (!jobId) {
+            return { success: false, error: 'Job not found. Provide a valid job ID or name.' };
+        }
+        const result = await service.run(jobId, 'force');
+        if (result.ok && result.ran) {
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'schedule_run',
+                success: true,
+                taskId: result.taskId,
+            });
+            return { success: true, taskId: result.taskId };
+        }
+        else if (result.ok && !result.ran) {
+            return { success: false, error: `Job not run: ${result.reason}` };
+        }
+        else {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'schedule_run',
+                error: result.error,
+            });
+            return { success: false, error: result.error };
+        }
+    }
+    /**
+     * Get run history for a scheduled task
+     */
+    async getRunHistory(params) {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'schedule_history',
+            id: params.id,
+            name: params.name,
+        });
+        const service = (0, cron_1.getCronService)();
+        if (!service) {
+            return { error: 'Scheduler service is not running' };
+        }
+        // Find job by ID or name
+        let jobId = params.id;
+        if (!jobId && params.name) {
+            const jobs = await service.list({ includeDisabled: true });
+            const job = jobs.find((j) => j.name.toLowerCase() === params.name.toLowerCase());
+            if (job) {
+                jobId = job.id;
+            }
+        }
+        if (!jobId) {
+            return { error: 'Job not found. Provide a valid job ID or name.' };
+        }
+        const history = await service.getRunHistory(jobId);
+        if (history) {
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'schedule_history',
+                success: true,
+                totalRuns: history.totalRuns,
+            });
+            return history;
+        }
+        else {
+            return { error: 'Job not found' };
+        }
+    }
+    /**
+     * Parse user-friendly schedule format into CronSchedule
+     */
+    parseSchedule(schedule) {
+        switch (schedule.type) {
+            case 'once': {
+                if (!schedule.at) {
+                    throw new Error('Schedule type "once" requires "at" parameter (timestamp or ISO date)');
+                }
+                let atMs;
+                if (typeof schedule.at === 'number') {
+                    atMs = schedule.at;
+                }
+                else {
+                    // Parse ISO date string
+                    const date = new Date(schedule.at);
+                    if (isNaN(date.getTime())) {
+                        throw new Error(`Invalid date format: ${schedule.at}`);
+                    }
+                    atMs = date.getTime();
+                }
+                // Validate it's in the future
+                if (atMs <= Date.now()) {
+                    throw new Error('Scheduled time must be in the future');
+                }
+                return { kind: 'at', atMs };
+            }
+            case 'interval': {
+                if (!schedule.every) {
+                    throw new Error('Schedule type "interval" requires "every" parameter (e.g., "5m", "1h", "1d")');
+                }
+                const everyMs = this.parseInterval(schedule.every);
+                if (!everyMs) {
+                    throw new Error(`Invalid interval format: ${schedule.every}. Use formats like "5m", "1h", "2d"`);
+                }
+                // Minimum interval is 1 minute
+                if (everyMs < 60000) {
+                    throw new Error('Minimum interval is 1 minute');
+                }
+                return { kind: 'every', everyMs };
+            }
+            case 'cron': {
+                if (!schedule.cron) {
+                    throw new Error('Schedule type "cron" requires "cron" parameter (cron expression)');
+                }
+                // Basic validation: 5 fields
+                const parts = schedule.cron.trim().split(/\s+/);
+                if (parts.length !== 5) {
+                    throw new Error(`Invalid cron expression: expected 5 fields, got ${parts.length}`);
+                }
+                return {
+                    kind: 'cron',
+                    expr: schedule.cron,
+                    tz: schedule.timezone,
+                };
+            }
+            default:
+                throw new Error(`Unknown schedule type: ${schedule.type}`);
+        }
+    }
+    /**
+     * Parse interval string to milliseconds
+     */
+    parseInterval(interval) {
+        const match = interval
+            .trim()
+            .match(/^(\d+(?:\.\d+)?)\s*(s|sec|second|seconds|m|min|minute|minutes|h|hr|hour|hours|d|day|days)$/i);
+        if (!match)
+            return null;
+        const value = parseFloat(match[1]);
+        const unit = match[2].toLowerCase();
+        switch (unit) {
+            case 's':
+            case 'sec':
+            case 'second':
+            case 'seconds':
+                return value * 1000;
+            case 'm':
+            case 'min':
+            case 'minute':
+            case 'minutes':
+                return value * 60 * 1000;
+            case 'h':
+            case 'hr':
+            case 'hour':
+            case 'hours':
+                return value * 60 * 60 * 1000;
+            case 'd':
+            case 'day':
+            case 'days':
+                return value * 24 * 60 * 60 * 1000;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Static method to get tool definitions
+     */
+    static getToolDefinitions() {
+        return [
+            {
+                name: 'schedule_task',
+                description: 'Schedule a task to run at a specific time or on a recurring basis. ' +
+                    'Use this for reminders, recurring reports, automated checks, or any task that should run automatically. ' +
+                    'Supports one-time scheduling, intervals (every X minutes/hours/days), and cron expressions.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['create', 'list', 'update', 'remove', 'run', 'history', 'status'],
+                            description: 'Action to perform: ' +
+                                'create (new scheduled task), ' +
+                                'list (show all tasks), ' +
+                                'update (modify existing task), ' +
+                                'remove (delete task), ' +
+                                'run (execute immediately), ' +
+                                'history (get run history), ' +
+                                'status (get scheduler status)',
+                        },
+                        // For create action
+                        name: {
+                            type: 'string',
+                            description: 'Name/identifier for the scheduled task',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Optional description of what the task does',
+                        },
+                        prompt: {
+                            type: 'string',
+                            description: 'The task prompt that will be executed when the schedule triggers',
+                        },
+                        schedule: {
+                            type: 'object',
+                            description: 'Schedule configuration',
+                            properties: {
+                                type: {
+                                    type: 'string',
+                                    enum: ['once', 'interval', 'cron'],
+                                    description: 'Type of schedule: once (run once at specific time), ' +
+                                        'interval (run every X time), cron (cron expression)',
+                                },
+                                at: {
+                                    type: 'string',
+                                    description: 'For "once": ISO date string (e.g., "2025-01-31T09:00:00") or ' +
+                                        'relative time description for the agent to convert',
+                                },
+                                every: {
+                                    type: 'string',
+                                    description: 'For "interval": Duration like "5m" (5 minutes), "1h" (1 hour), "1d" (1 day)',
+                                },
+                                cron: {
+                                    type: 'string',
+                                    description: 'For "cron": Standard 5-field cron expression. ' +
+                                        'Examples: "0 9 * * *" (daily 9am), "0 9 * * 1-5" (weekdays 9am), ' +
+                                        '"*/15 * * * *" (every 15 min)',
+                                },
+                                timezone: {
+                                    type: 'string',
+                                    description: 'Timezone for cron schedules (e.g., "America/New_York")',
+                                },
+                            },
+                        },
+                        enabled: {
+                            type: 'boolean',
+                            description: 'Whether the task is enabled (default: true)',
+                        },
+                        deleteAfterRun: {
+                            type: 'boolean',
+                            description: 'Delete the task after it runs once (default: true for "once" type)',
+                        },
+                        // For update/remove/run/history actions
+                        id: {
+                            type: 'string',
+                            description: 'ID of the task to update/remove/run',
+                        },
+                        // For list action
+                        includeDisabled: {
+                            type: 'boolean',
+                            description: 'Include disabled tasks in the list (default: false)',
+                        },
+                        // For update action
+                        updates: {
+                            type: 'object',
+                            description: 'Fields to update',
+                            properties: {
+                                name: { type: 'string' },
+                                description: { type: 'string' },
+                                prompt: { type: 'string' },
+                                enabled: { type: 'boolean' },
+                                schedule: {
+                                    type: 'object',
+                                    properties: {
+                                        type: { type: 'string', enum: ['once', 'interval', 'cron'] },
+                                        at: { type: 'string' },
+                                        every: { type: 'string' },
+                                        cron: { type: 'string' },
+                                        timezone: { type: 'string' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    required: ['action'],
+                },
+            },
+        ];
+    }
+    /**
+     * Execute a schedule tool action
+     */
+    async executeAction(input) {
+        switch (input.action) {
+            case 'status':
+                return this.getStatus();
+            case 'list':
+                return this.listJobs(input.includeDisabled);
+            case 'create':
+                if (!input.name || !input.prompt || !input.schedule) {
+                    throw new Error('Create action requires: name, prompt, and schedule');
+                }
+                return this.createJob({
+                    name: input.name,
+                    description: input.description,
+                    prompt: input.prompt,
+                    schedule: input.schedule,
+                    enabled: input.enabled,
+                    deleteAfterRun: input.deleteAfterRun,
+                });
+            case 'update':
+                if (!input.id && !input.name) {
+                    throw new Error('Update action requires: id or name');
+                }
+                if (!input.updates) {
+                    throw new Error('Update action requires: updates object');
+                }
+                return this.updateJob({
+                    id: input.id,
+                    name: input.name,
+                    updates: input.updates,
+                });
+            case 'remove':
+                if (!input.id && !input.name) {
+                    throw new Error('Remove action requires: id or name');
+                }
+                return this.removeJob({ id: input.id, name: input.name });
+            case 'run':
+                if (!input.id && !input.name) {
+                    throw new Error('Run action requires: id or name');
+                }
+                return this.runJob({ id: input.id, name: input.name });
+            case 'history':
+                if (!input.id && !input.name) {
+                    throw new Error('History action requires: id or name');
+                }
+                return this.getRunHistory({ id: input.id, name: input.name });
+            default:
+                throw new Error(`Unknown action: ${input.action}`);
+        }
+    }
+}
+exports.CronTools = CronTools;