crewly 1.5.11 → 1.5.13

package/dist/backend/backend/src/services/workflow/cron-task.service.js

@@ -5,19 +5,27 @@
  * Unlike scheduled messages (agent-created/cancellable), cron tasks
  * can only be cancelled by user or orchestrator.
  *
- * Storage: ~/.crewly/cron-tasks.json
+ * Storage: Per-team at ~/.crewly/teams/{teamId}/cron-tasks.json
+ * Migration: Global ~/.crewly/cron-tasks.json is auto-migrated on first startup.
  *
  * @module services/workflow/cron-task.service
  */
 import * as os from 'os';
 import * as path from 'path';
-import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
 import { v4 as uuidv4 } from 'uuid';
 import { LoggerService } from '../core/logger.service.js';
 /**
  * Check interval for cron task evaluation (60 seconds).
  */
 const CRON_CHECK_INTERVAL_MS = 60_000;
+/** Name of the per-team cron task file */
+const CRON_TASKS_FILENAME = 'cron-tasks.json';
+/** Suffix appended to the global file after successful migration */
+const MIGRATED_SUFFIX = '.migrated';
+/** Team ID value used for orchestrator-level cron tasks (not team-scoped) */
+const ORCHESTRATOR_TEAM_ID = 'orchestrator';
 /**
  * Extract date/time parts from a Date in a specific IANA timezone.
  *
@@ -153,26 +161,35 @@ export function getNextRunTime(cronExpression, timezone, after) {
     return new Date(now.getTime() + 24 * 60 * 60 * 1000).toISOString();
 }
 /**
- * Service for managing cron tasks.
+ * Service for managing cron tasks with per-team scoped storage.
+ *
+ * Storage layout:
+ *   ~/.crewly/teams/{teamId}/cron-tasks.json
+ *
+ * On first startup, migrates the legacy global file
+ * (~/.crewly/cron-tasks.json) by grouping tasks by targetTeamId
+ * and writing per-team files. The global file is renamed to
+ * cron-tasks.json.migrated to prevent re-migration.
  *
  * Lifecycle:
  * 1. Get singleton via `getInstance()`
  * 2. Wire callbacks: `setExecutionCallback()`, `setAgentStatusCallback()`, `setAgentStartCallback()`
- * 3. Call `start()` to begin the evaluation loop
- * 4. On startup, call `recalculateAllNextRunTimes()` to self-heal stale values
+ * 3. Call `migrateGlobalToTeamScoped()` to auto-migrate legacy storage
+ * 4. Call `start()` to begin the evaluation loop
+ * 5. On startup, call `recalculateAllNextRunTimes()` to self-heal stale values
  */
 export class CronTaskService {
     static instance = null;
     logger;
-    storeFile;
+    /** Root crewly home directory (e.g. ~/.crewly) */
+    crewlyHome;
     timer = null;
     executionCallback = null;
     agentStatusCallback = null;
     agentStartCallback = null;
     constructor(crewlyHome) {
         this.logger = LoggerService.getInstance().createComponentLogger('CronTaskService');
-        const home = crewlyHome || path.join(os.homedir(), '.crewly');
-        this.storeFile = path.join(home, 'cron-tasks.json');
+        this.crewlyHome = crewlyHome || path.join(os.homedir(), '.crewly');
     }
     /**
      * Get singleton instance.
@@ -192,6 +209,98 @@ export class CronTaskService {
         }
         CronTaskService.instance = null;
     }
+    /**
+     * Get the store file path for a specific team.
+     *
+     * @param teamId - Team ID
+     * @returns Absolute path to the team's cron-tasks.json
+     */
+    getStoreFile(teamId) {
+        return path.join(this.crewlyHome, 'teams', teamId, CRON_TASKS_FILENAME);
+    }
+    /**
+     * Get the legacy global store file path.
+     *
+     * @returns Absolute path to the global cron-tasks.json
+     */
+    getGlobalStoreFile() {
+        return path.join(this.crewlyHome, CRON_TASKS_FILENAME);
+    }
+    /**
+     * Migrate legacy global cron-tasks.json to per-team files.
+     *
+     * Orchestrator-targeted tasks (targetTeamId === 'orchestrator') are kept
+     * in the global file since they don't belong to any specific team.
+     * All other tasks are grouped by targetTeamId and written to per-team files.
+     *
+     * After migration, the global file is rewritten to contain only orchestrator
+     * tasks, and a .migrated marker is created to prevent re-running.
+     *
+     * Idempotent: skips if the .migrated marker already exists or no global file exists.
+     *
+     * @returns Number of tasks migrated to per-team files (excludes orchestrator tasks kept in global)
+     */
+    async migrateGlobalToTeamScoped() {
+        const globalFile = this.getGlobalStoreFile();
+        const migratedFile = globalFile + MIGRATED_SUFFIX;
+        // Skip if already migrated or no global file exists
+        if (existsSync(migratedFile) || !existsSync(globalFile)) {
+            return 0;
+        }
+        let globalStore;
+        try {
+            const data = await readFile(globalFile, 'utf-8');
+            globalStore = JSON.parse(data);
+        }
+        catch {
+            // Cannot read/parse global file — nothing to migrate
+            return 0;
+        }
+        if (globalStore.tasks.length === 0) {
+            // Empty store — write marker and skip
+            await writeFile(migratedFile, '', 'utf-8');
+            return 0;
+        }
+        // Partition: orchestrator tasks stay global, everything else goes per-team
+        const orchestratorTasks = [];
+        const teamGroups = new Map();
+        for (const task of globalStore.tasks) {
+            if (task.targetTeamId === ORCHESTRATOR_TEAM_ID) {
+                orchestratorTasks.push(task);
+            }
+            else {
+                const teamId = task.targetTeamId;
+                if (!teamGroups.has(teamId)) {
+                    teamGroups.set(teamId, []);
+                }
+                teamGroups.get(teamId).push(task);
+            }
+        }
+        // Write team-scoped tasks to per-team files
+        let migratedCount = 0;
+        for (const [teamId, tasks] of teamGroups) {
+            const teamStore = await this.loadTeamStore(teamId);
+            // Merge: add migrated tasks that don't already exist
+            const existingIds = new Set(teamStore.tasks.map(t => t.id));
+            for (const task of tasks) {
+                if (!existingIds.has(task.id)) {
+                    teamStore.tasks.push(task);
+                    migratedCount++;
+                }
+            }
+            await this.saveTeamStore(teamId, teamStore);
+        }
+        // Rewrite global file with only orchestrator tasks
+        await this.saveGlobalStore({ tasks: orchestratorTasks });
+        // Write migration marker to prevent re-running
+        await writeFile(migratedFile, new Date().toISOString(), 'utf-8');
+        this.logger.info('Migrated global cron-tasks.json to per-team storage', {
+            migratedCount,
+            orchestratorKept: orchestratorTasks.length,
+            teamCount: teamGroups.size,
+        });
+        return migratedCount;
+    }
     /**
      * Set the callback invoked when a cron task is due for execution.
      * The callback receives the task and should delegate it to the target agent.
@@ -265,15 +374,15 @@ export class CronTaskService {
      * @returns Number of tasks whose nextRunAt was updated
      */
     async recalculateAllNextRunTimes() {
-        const store = await this.loadStore();
+        const allTasks = await this.loadAllTasks();
         const now = new Date();
         let updated = 0;
-        for (const task of store.tasks) {
+        // Group tasks back by team for saving
+        const dirtyTeams = new Set();
+        for (const task of allTasks) {
             if (!task.enabled)
                 continue;
             // If task has never run AND its nextRunAt is in the past, this is a missed first run.
-            // Keep the stale nextRunAt so evaluateTasks() picks it up and fires immediately,
-            // rather than silently advancing to the next occurrence.
             if (!task.lastRunAt && task.nextRunAt && new Date(task.nextRunAt) <= now) {
                 this.logger.info('Missed first run detected — keeping stale nextRunAt for immediate execution', {
                     id: task.id,
@@ -293,10 +402,15 @@ export class CronTaskService {
                 });
                 task.nextRunAt = recalculated;
                 updated++;
+                dirtyTeams.add(task.targetTeamId);
             }
         }
-        if (updated > 0) {
-            await this.saveStore(store);
+        // Save only modified team stores
+        if (dirtyTeams.size > 0) {
+            for (const teamId of dirtyTeams) {
+                const teamTasks = allTasks.filter(t => t.targetTeamId === teamId);
+                await this.saveTeamStore(teamId, { tasks: teamTasks });
+            }
             this.logger.info('Recalculated nextRunAt for stale tasks', { count: updated });
         }
         return updated;
@@ -323,20 +437,45 @@ export class CronTaskService {
             lastRunAt: null,
             nextRunAt,
         };
-        const store = await this.loadStore();
-        store.tasks.push(task);
-        await this.saveStore(store);
-        this.logger.info('Cron task created', { id: task.id, cron: task.cronExpression, target: task.targetAgent });
+        // Orchestrator tasks go to global store; team tasks go to per-team store
+        if (task.targetTeamId === ORCHESTRATOR_TEAM_ID) {
+            const store = await this.loadGlobalStore();
+            store.tasks.push(task);
+            await this.saveGlobalStore(store);
+        }
+        else {
+            const store = await this.loadTeamStore(task.targetTeamId);
+            store.tasks.push(task);
+            await this.saveTeamStore(task.targetTeamId, store);
+        }
+        this.logger.info('Cron task created', { id: task.id, cron: task.cronExpression, target: task.targetAgent, teamId: task.targetTeamId });
         return task;
     }
     /**
-     * List all cron tasks, optionally filtered.
+     * List all cron tasks across all teams, optionally filtered.
      *
      * @param filter - Optional filter criteria
      * @returns Array of matching cron tasks
      */
     async list(filter) {
-        const store = await this.loadStore();
+        let tasks = await this.loadAllTasks();
+        if (filter?.targetAgent) {
+            tasks = tasks.filter(t => t.targetAgent === filter.targetAgent);
+        }
+        if (filter?.enabled !== undefined) {
+            tasks = tasks.filter(t => t.enabled === filter.enabled);
+        }
+        return tasks;
+    }
+    /**
+     * List cron tasks for a specific team.
+     *
+     * @param teamId - Team ID to filter by
+     * @param filter - Optional additional filter criteria
+     * @returns Array of matching cron tasks for the team
+     */
+    async getByTeam(teamId, filter) {
+        const store = await this.loadTeamStore(teamId);
         let tasks = store.tasks;
         if (filter?.targetAgent) {
             tasks = tasks.filter(t => t.targetAgent === filter.targetAgent);
@@ -347,61 +486,92 @@ export class CronTaskService {
         return tasks;
     }
     /**
-     * Get a single cron task by ID.
+     * Get a single cron task by ID. Searches across all teams.
      *
      * @param id - Cron task ID
      * @returns The cron task or null
      */
     async get(id) {
-        const store = await this.loadStore();
-        return store.tasks.find(t => t.id === id) || null;
+        const allTasks = await this.loadAllTasks();
+        return allTasks.find(t => t.id === id) || null;
     }
     /**
-     * Update a cron task. Agents can update description/expression/enabled
-     * but cannot delete.
+     * Update a cron task. Searches across all teams to find the task.
      *
      * @param id - Cron task ID
      * @param updates - Fields to update
      * @returns Updated task or null if not found
      */
     async update(id, updates) {
-        const store = await this.loadStore();
-        const task = store.tasks.find(t => t.id === id);
-        if (!task)
-            return null;
-        if (updates.cronExpression !== undefined) {
-            task.cronExpression = updates.cronExpression;
-            task.nextRunAt = getNextRunTime(updates.cronExpression, task.timezone);
-        }
-        if (updates.timezone !== undefined) {
-            task.timezone = updates.timezone;
-            task.nextRunAt = getNextRunTime(task.cronExpression, task.timezone);
-        }
-        if (updates.taskDescription !== undefined) {
-            task.taskDescription = updates.taskDescription;
-        }
-        if (updates.enabled !== undefined) {
-            task.enabled = updates.enabled;
-        }
-        await this.saveStore(store);
-        this.logger.info('Cron task updated', { id, updates: Object.keys(updates) });
-        return task;
+        // Helper to apply updates to a task
+        const applyUpdates = (task) => {
+            if (updates.cronExpression !== undefined) {
+                task.cronExpression = updates.cronExpression;
+                task.nextRunAt = getNextRunTime(updates.cronExpression, task.timezone);
+            }
+            if (updates.timezone !== undefined) {
+                task.timezone = updates.timezone;
+                task.nextRunAt = getNextRunTime(task.cronExpression, task.timezone);
+            }
+            if (updates.taskDescription !== undefined) {
+                task.taskDescription = updates.taskDescription;
+            }
+            if (updates.enabled !== undefined) {
+                task.enabled = updates.enabled;
+            }
+        };
+        // Search global store first (orchestrator tasks)
+        const globalStore = await this.loadGlobalStore();
+        const globalTask = globalStore.tasks.find(t => t.id === id);
+        if (globalTask) {
+            applyUpdates(globalTask);
+            await this.saveGlobalStore(globalStore);
+            this.logger.info('Cron task updated', { id, location: 'global', updates: Object.keys(updates) });
+            return globalTask;
+        }
+        // Search per-team stores
+        const teamIds = await this.getTeamIds();
+        for (const teamId of teamIds) {
+            const store = await this.loadTeamStore(teamId);
+            const task = store.tasks.find(t => t.id === id);
+            if (!task)
+                continue;
+            applyUpdates(task);
+            await this.saveTeamStore(teamId, store);
+            this.logger.info('Cron task updated', { id, teamId, updates: Object.keys(updates) });
+            return task;
+        }
+        return null;
     }
     /**
-     * Delete a cron task. Only user/orchestrator should call this.
+     * Delete a cron task. Searches across all teams to find and remove it.
      *
      * @param id - Cron task ID
      * @returns true if deleted, false if not found
      */
     async delete(id) {
-        const store = await this.loadStore();
-        const index = store.tasks.findIndex(t => t.id === id);
-        if (index === -1)
-            return false;
-        store.tasks.splice(index, 1);
-        await this.saveStore(store);
-        this.logger.info('Cron task deleted', { id });
-        return true;
+        // Search global store first (orchestrator tasks)
+        const globalStore = await this.loadGlobalStore();
+        const globalIndex = globalStore.tasks.findIndex(t => t.id === id);
+        if (globalIndex !== -1) {
+            globalStore.tasks.splice(globalIndex, 1);
+            await this.saveGlobalStore(globalStore);
+            this.logger.info('Cron task deleted', { id, location: 'global' });
+            return true;
+        }
+        // Search per-team stores
+        const teamIds = await this.getTeamIds();
+        for (const teamId of teamIds) {
+            const store = await this.loadTeamStore(teamId);
+            const index = store.tasks.findIndex(t => t.id === id);
+            if (index === -1)
+                continue;
+            store.tasks.splice(index, 1);
+            await this.saveTeamStore(teamId, store);
+            this.logger.info('Cron task deleted', { id, teamId });
+            return true;
+        }
+        return false;
     }
     /**
      * Evaluate all enabled tasks and execute those whose nextRunAt has passed.
@@ -410,95 +580,153 @@ export class CronTaskService {
      * attempts to auto-start the agent before executing.
      */
     async evaluateTasks() {
-        const store = await this.loadStore();
         const now = new Date();
-        let updated = false;
-        for (const task of store.tasks) {
-            if (!task.enabled || !task.nextRunAt)
-                continue;
-            const nextRun = new Date(task.nextRunAt);
-            if (nextRun > now)
-                continue;
-            // Task is due — check agent status before executing
-            let agentOnline = true;
-            if (this.agentStatusCallback) {
-                try {
-                    agentOnline = await this.agentStatusCallback(task.targetAgent, task.targetTeamId);
-                }
-                catch (error) {
-                    this.logger.warn('Agent status check failed, assuming offline', {
-                        id: task.id,
-                        target: task.targetAgent,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    agentOnline = false;
-                }
+        // Evaluate global orchestrator tasks
+        const globalStore = await this.loadGlobalStore();
+        let globalUpdated = false;
+        for (const task of globalStore.tasks) {
+            const result = await this.evaluateSingleTask(task, now);
+            if (result)
+                globalUpdated = true;
+        }
+        if (globalUpdated) {
+            await this.saveGlobalStore(globalStore);
+        }
+        // Evaluate per-team tasks
+        const teamIds = await this.getTeamIds();
+        for (const teamId of teamIds) {
+            const store = await this.loadTeamStore(teamId);
+            let updated = false;
+            for (const task of store.tasks) {
+                const result = await this.evaluateSingleTask(task, now);
+                if (result)
+                    updated = true;
             }
-            // Auto-start offline agent if callback is available
-            if (!agentOnline && this.agentStartCallback) {
-                this.logger.info('Agent offline for cron task, attempting auto-start', {
-                    id: task.id,
-                    target: task.targetAgent,
-                });
-                try {
-                    const started = await this.agentStartCallback(task.targetAgent, task.targetTeamId);
-                    if (started) {
-                        agentOnline = true;
-                        this.logger.info('Agent auto-started successfully', {
-                            id: task.id,
-                            target: task.targetAgent,
-                        });
-                    }
-                }
-                catch (error) {
-                    this.logger.error('Agent auto-start failed', {
-                        id: task.id,
-                        target: task.targetAgent,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
+            if (updated) {
+                await this.saveTeamStore(teamId, store);
+            }
+        }
+    }
+    /**
+     * Evaluate a single cron task: check if due, verify agent status, execute.
+     * Mutates the task in-place (lastRunAt, nextRunAt).
+     *
+     * @param task - The cron task to evaluate
+     * @param now - Current time for comparison
+     * @returns true if the task was modified (needs saving)
+     */
+    async evaluateSingleTask(task, now) {
+        if (!task.enabled || !task.nextRunAt)
+            return false;
+        const nextRun = new Date(task.nextRunAt);
+        if (nextRun > now)
+            return false;
+        // Task is due — check agent status before executing
+        let agentOnline = true;
+        if (this.agentStatusCallback) {
+            try {
+                agentOnline = await this.agentStatusCallback(task.targetAgent, task.targetTeamId);
             }
-            if (!agentOnline) {
-                this.logger.warn('Skipping cron task — agent offline and auto-start unavailable', {
+            catch (error) {
+                this.logger.warn('Agent status check failed, assuming offline', {
                     id: task.id,
                     target: task.targetAgent,
+                    error: error instanceof Error ? error.message : String(error),
                 });
-                // Still advance nextRunAt to prevent re-evaluating the same missed slot
-                task.nextRunAt = getNextRunTime(task.cronExpression, task.timezone, now);
-                updated = true;
-                continue;
+                agentOnline = false;
             }
-            this.logger.info('Cron task due, executing', {
+        }
+        // Auto-start offline agent if callback is available
+        if (!agentOnline && this.agentStartCallback) {
+            this.logger.info('Agent offline for cron task, attempting auto-start', {
                 id: task.id,
                 target: task.targetAgent,
-                nextRunAt: task.nextRunAt,
             });
             try {
-                if (this.executionCallback) {
-                    await this.executionCallback(task);
+                const started = await this.agentStartCallback(task.targetAgent, task.targetTeamId);
+                if (started) {
+                    agentOnline = true;
+                    this.logger.info('Agent auto-started successfully', {
+                        id: task.id,
+                        target: task.targetAgent,
+                    });
                 }
             }
             catch (error) {
-                this.logger.error('Cron task execution failed', {
+                this.logger.error('Agent auto-start failed', {
                     id: task.id,
+                    target: task.targetAgent,
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
-            // Update run times regardless of execution success
-            task.lastRunAt = now.toISOString();
+        }
+        if (!agentOnline) {
+            this.logger.warn('Skipping cron task — agent offline and auto-start unavailable', {
+                id: task.id,
+                target: task.targetAgent,
+            });
+            // Still advance nextRunAt to prevent re-evaluating the same missed slot
             task.nextRunAt = getNextRunTime(task.cronExpression, task.timezone, now);
-            updated = true;
+            return true;
+        }
+        this.logger.info('Cron task due, executing', {
+            id: task.id,
+            target: task.targetAgent,
+            nextRunAt: task.nextRunAt,
+        });
+        try {
+            if (this.executionCallback) {
+                await this.executionCallback(task);
+            }
+        }
+        catch (error) {
+            this.logger.error('Cron task execution failed', {
+                id: task.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
         }
-        if (updated) {
-            await this.saveStore(store);
+        // Update run times regardless of execution success
+        task.lastRunAt = now.toISOString();
+        task.nextRunAt = getNextRunTime(task.cronExpression, task.timezone, now);
+        return true;
+    }
+    // ============ Storage Methods ============
+    /**
+     * Load cron task store for a specific team.
+     *
+     * @param teamId - Team ID
+     * @returns Team's cron task store (empty if file doesn't exist)
+     */
+    async loadTeamStore(teamId) {
+        try {
+            const filePath = this.getStoreFile(teamId);
+            const data = await readFile(filePath, 'utf-8');
+            return JSON.parse(data);
         }
+        catch {
+            return { tasks: [] };
+        }
+    }
+    /**
+     * Save cron task store for a specific team.
+     *
+     * @param teamId - Team ID
+     * @param store - Store data to persist
+     */
+    async saveTeamStore(teamId, store) {
+        const filePath = this.getStoreFile(teamId);
+        const dir = path.dirname(filePath);
+        await mkdir(dir, { recursive: true });
+        await writeFile(filePath, JSON.stringify(store, null, 2), 'utf-8');
     }
     /**
-     * Load the cron task store from disk.
+     * Load the global cron task store (orchestrator tasks only).
+     *
+     * @returns Global store (empty if file doesn't exist)
      */
-    async loadStore() {
+    async loadGlobalStore() {
         try {
-            const data = await readFile(this.storeFile, 'utf-8');
+            const data = await readFile(this.getGlobalStoreFile(), 'utf-8');
             return JSON.parse(data);
         }
         catch {
@@ -506,12 +734,61 @@ export class CronTaskService {
         }
     }
     /**
-     * Save the cron task store to disk.
+     * Save the global cron task store (orchestrator tasks only).
+     *
+     * @param store - Store data to persist
      */
-    async saveStore(store) {
-        const dir = path.dirname(this.storeFile);
+    async saveGlobalStore(store) {
+        const filePath = this.getGlobalStoreFile();
+        const dir = path.dirname(filePath);
         await mkdir(dir, { recursive: true });
-        await writeFile(this.storeFile, JSON.stringify(store, null, 2), 'utf-8');
+        await writeFile(filePath, JSON.stringify(store, null, 2), 'utf-8');
+    }
+    /**
+     * Load all tasks from all team stores plus the global store,
+     * aggregated into a single array.
+     *
+     * @returns All cron tasks across all teams and the global orchestrator store
+     */
+    async loadAllTasks() {
+        const teamIds = await this.getTeamIds();
+        const allTasks = [];
+        // Load orchestrator tasks from global store
+        const globalStore = await this.loadGlobalStore();
+        allTasks.push(...globalStore.tasks);
+        // Load per-team tasks
+        for (const teamId of teamIds) {
+            const store = await this.loadTeamStore(teamId);
+            allTasks.push(...store.tasks);
+        }
+        return allTasks;
+    }
+    /**
+     * Discover all team IDs that have cron task files.
+     *
+     * Scans ~/.crewly/teams/ for directories containing cron-tasks.json.
+     *
+     * @returns Array of team IDs
+     */
+    async getTeamIds() {
+        const teamsDir = path.join(this.crewlyHome, 'teams');
+        try {
+            const entries = await readdir(teamsDir, { withFileTypes: true });
+            const teamIds = [];
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const cronFile = path.join(teamsDir, entry.name, CRON_TASKS_FILENAME);
+                if (existsSync(cronFile)) {
+                    teamIds.push(entry.name);
+                }
+            }
+            return teamIds;
+        }
+        catch {
+            // teams directory doesn't exist yet
+            return [];
+        }
     }
 }
 //# sourceMappingURL=cron-task.service.js.map