@plusplusoneplusplus/coc 1.0.0

package/dist/server/schedule-manager.js

@@ -0,0 +1,707 @@
+"use strict";
+/**
+ * ScheduleManager
+ *
+ * In-memory schedule state with cron-based timer management.
+ * Triggers pipeline/task runs via the queue manager.
+ * Supports overlap skipping and missed-run detection.
+ *
+ * Cross-platform compatible (Linux/Mac/Windows).
+ */
+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.ScheduleManager = exports.slugifyName = exports.describeCron = exports.nextCronTime = exports.parseCron = void 0;
+const events_1 = require("events");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const yaml = __importStar(require("js-yaml"));
+const fs_utils_1 = require("./shared/fs-utils");
+const repo_schedule_loader_1 = require("./repo-schedule-loader");
+const cron_utils_1 = require("./cron-utils");
+// Re-export cron utilities for backward compatibility
+var cron_utils_2 = require("./cron-utils");
+Object.defineProperty(exports, "parseCron", { enumerable: true, get: function () { return cron_utils_2.parseCron; } });
+Object.defineProperty(exports, "nextCronTime", { enumerable: true, get: function () { return cron_utils_2.nextCronTime; } });
+Object.defineProperty(exports, "describeCron", { enumerable: true, get: function () { return cron_utils_2.describeCron; } });
+Object.defineProperty(exports, "slugifyName", { enumerable: true, get: function () { return cron_utils_2.slugifyName; } });
+// ============================================================================
+// ScheduleManager
+// ============================================================================
+const MAX_HISTORY_PER_SCHEDULE = 100;
+/** Stamp completedAt, durationMs, and optionally error on a run record. */
+function finaliseRun(run, status, error) {
+    run.status = status;
+    run.completedAt = new Date().toISOString();
+    run.durationMs = new Date(run.completedAt).getTime() - new Date(run.startedAt).getTime();
+    if (error !== undefined) {
+        run.error = (0, fs_utils_1.getErrorMessage)(error);
+    }
+}
+class ScheduleManager extends events_1.EventEmitter {
+    constructor(persistence, queueManager = null, overrideStore = null) {
+        super();
+        // repoId → scheduleId → ScheduleEntry (user-managed)
+        this.schedules = new Map();
+        // repoId → scheduleId → ScheduleEntry (repo-managed, from .github/schedules/)
+        this.repoSchedules = new Map();
+        // repoId → workspace rootPath
+        this.workspacePaths = new Map();
+        // scheduleId → timer handle
+        this.timers = new Map();
+        // scheduleId → currently running flag
+        this.runningSchedules = new Set();
+        // scheduleId → run history (most recent first)
+        this.runHistory = new Map();
+        // file watchers: repoId → fs.FSWatcher
+        this.repoWatchers = new Map();
+        // debounce timers for file watch events
+        this.watchDebounceTimers = new Map();
+        this.runPersistence = null;
+        this.disposed = false;
+        this.persistence = persistence;
+        this.queueManager = queueManager;
+        this.overrideStore = overrideStore;
+    }
+    /**
+     * Restore schedules from persistence and start timers for active ones.
+     */
+    restore() {
+        const allSchedules = this.persistence.loadAll();
+        let total = 0;
+        for (const [repoId, entries] of allSchedules) {
+            const map = new Map();
+            for (const entry of entries) {
+                map.set(entry.id, entry);
+                if (entry.status === 'active') {
+                    this.scheduleNextRun(repoId, entry);
+                }
+                total++;
+            }
+            this.schedules.set(repoId, map);
+        }
+        if (total > 0) {
+            process.stderr.write(`[ScheduleManager] Restored ${total} schedule(s)\n`);
+        }
+    }
+    /**
+     * Restore run history from persistence and inject into in-memory runHistory map.
+     * Must be called after restore().
+     */
+    restoreRunHistory(persistence) {
+        this.runPersistence = persistence;
+        const restored = persistence.loadAll();
+        for (const [scheduleId, runs] of restored) {
+            this.runHistory.set(scheduleId, runs);
+        }
+        if (restored.size > 0) {
+            process.stderr.write(`[ScheduleManager] Restored run history for ${restored.size} schedule(s)\n`);
+        }
+    }
+    /**
+     * Get all schedules for a repo (user + repo-defined merged).
+     */
+    getSchedules(repoId) {
+        const result = [];
+        const userMap = this.schedules.get(repoId);
+        if (userMap)
+            result.push(...userMap.values());
+        const repoMap = this.repoSchedules.get(repoId);
+        if (repoMap)
+            result.push(...repoMap.values());
+        return result;
+    }
+    /**
+     * Get a single schedule (checks user schedules first, then repo schedules).
+     */
+    getSchedule(repoId, scheduleId) {
+        return this.schedules.get(repoId)?.get(scheduleId)
+            ?? this.repoSchedules.get(repoId)?.get(scheduleId);
+    }
+    /**
+     * Create a new schedule.
+     */
+    addSchedule(repoId, entry) {
+        // Validate cron
+        (0, cron_utils_1.parseCron)(entry.cron);
+        const schedule = {
+            ...entry,
+            id: 'sch_' + crypto.randomBytes(6).toString('hex'),
+            createdAt: new Date().toISOString(),
+        };
+        if (!this.schedules.has(repoId)) {
+            this.schedules.set(repoId, new Map());
+        }
+        this.schedules.get(repoId).set(schedule.id, schedule);
+        this.persist(repoId);
+        if (schedule.status === 'active') {
+            this.scheduleNextRun(repoId, schedule);
+        }
+        this.emit('change', {
+            type: 'schedule-added',
+            repoId,
+            scheduleId: schedule.id,
+            schedule,
+        });
+        return schedule;
+    }
+    /**
+     * Update an existing schedule.
+     * For repo-sourced schedules, only the status (active/paused) may be changed.
+     */
+    updateSchedule(repoId, scheduleId, updates) {
+        // Check repo schedules first
+        const repoSchedule = this.repoSchedules.get(repoId)?.get(scheduleId);
+        if (repoSchedule) {
+            // Only allow status changes for repo schedules
+            if (updates.status && updates.status !== repoSchedule.status) {
+                repoSchedule.status = updates.status;
+                this.overrideStore?.setStatus(repoId, scheduleId, updates.status);
+                this.cancelTimer(scheduleId);
+                if (repoSchedule.status === 'active') {
+                    this.scheduleNextRun(repoId, repoSchedule);
+                }
+                this.emit('change', {
+                    type: 'schedule-updated',
+                    repoId,
+                    scheduleId,
+                    schedule: repoSchedule,
+                });
+            }
+            return repoSchedule;
+        }
+        const schedule = this.schedules.get(repoId)?.get(scheduleId);
+        if (!schedule)
+            return undefined;
+        if (updates.cron && updates.cron !== schedule.cron) {
+            (0, cron_utils_1.parseCron)(updates.cron);
+        }
+        const oldStatus = schedule.status;
+        Object.assign(schedule, updates);
+        // Reschedule timer if needed
+        this.cancelTimer(scheduleId);
+        if (schedule.status === 'active') {
+            this.scheduleNextRun(repoId, schedule);
+        }
+        this.persist(repoId);
+        this.emit('change', {
+            type: 'schedule-updated',
+            repoId,
+            scheduleId,
+            schedule,
+        });
+        return schedule;
+    }
+    /**
+     * Remove a schedule.
+     * Repo-sourced schedules cannot be removed via the API.
+     */
+    removeSchedule(repoId, scheduleId) {
+        // Block removal of repo schedules
+        if (this.repoSchedules.get(repoId)?.has(scheduleId))
+            return false;
+        const map = this.schedules.get(repoId);
+        if (!map || !map.has(scheduleId))
+            return false;
+        this.cancelTimer(scheduleId);
+        map.delete(scheduleId);
+        this.runHistory.delete(scheduleId);
+        if (map.size === 0) {
+            this.schedules.delete(repoId);
+            this.persistence.deleteRepo(repoId);
+        }
+        else {
+            this.persist(repoId);
+        }
+        this.emit('change', {
+            type: 'schedule-removed',
+            repoId,
+            scheduleId,
+        });
+        return true;
+    }
+    /**
+     * Trigger a schedule run immediately.
+     */
+    async triggerRun(repoId, scheduleId) {
+        const schedule = this.getSchedule(repoId, scheduleId);
+        if (!schedule)
+            throw new Error('Schedule not found');
+        return this.executeRun(repoId, schedule);
+    }
+    /**
+     * Get run history for a schedule.
+     */
+    getRunHistory(scheduleId) {
+        return this.runHistory.get(scheduleId) || [];
+    }
+    /**
+     * Check if a schedule is currently running.
+     */
+    isRunning(scheduleId) {
+        return this.runningSchedules.has(scheduleId);
+    }
+    /**
+     * Dispose all timers and clean up.
+     */
+    dispose() {
+        this.disposed = true;
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+        for (const timer of this.watchDebounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.watchDebounceTimers.clear();
+        for (const watcher of this.repoWatchers.values()) {
+            try {
+                watcher.close();
+            }
+            catch { /* non-fatal */ }
+        }
+        this.repoWatchers.clear();
+        this.removeAllListeners();
+    }
+    // ========================================================================
+    // Public — move schedule between user and repo sections
+    // ========================================================================
+    /**
+     * Expose the workspace root path for a given repoId.
+     */
+    getWorkspacePath(repoId) {
+        return this.workspacePaths.get(repoId);
+    }
+    /**
+     * Move a schedule between user and repo sections.
+     *
+     * user→repo: writes YAML to .github/schedules/<slug>.yaml, removes from user schedules.
+     * repo→user: creates a user schedule via addSchedule, deletes the YAML file.
+     */
+    async moveSchedule(repoId, scheduleId, destination) {
+        const rootPath = this.workspacePaths.get(repoId);
+        if (!rootPath) {
+            throw new Error('Workspace path not available for this repo');
+        }
+        const entry = this.getSchedule(repoId, scheduleId);
+        if (!entry) {
+            throw new Error('Schedule not found');
+        }
+        if (destination === 'repo') {
+            if (entry.source === 'repo') {
+                throw new Error('Schedule is already a repo schedule');
+            }
+            return this.moveUserToRepo(repoId, entry, rootPath);
+        }
+        else {
+            if (entry.source !== 'repo') {
+                throw new Error('Schedule is already a user schedule');
+            }
+            return this.moveRepoToUser(repoId, entry, rootPath);
+        }
+    }
+    moveUserToRepo(repoId, entry, rootPath) {
+        const slug = (0, cron_utils_1.slugifyName)(entry.name);
+        const scheduleDir = (0, repo_schedule_loader_1.getRepoScheduleDir)(rootPath);
+        fs.mkdirSync(scheduleDir, { recursive: true });
+        // De-duplicate filename if it already exists
+        let finalSlug = slug;
+        let counter = 1;
+        while (fs.existsSync(path.join(scheduleDir, `${finalSlug}.yaml`))) {
+            finalSlug = `${slug}-${counter}`;
+            counter++;
+        }
+        // Build YAML content (strip internal fields)
+        const yamlObj = {
+            name: entry.name,
+            cron: entry.cron,
+            target: entry.target,
+            params: entry.params,
+            onFailure: entry.onFailure,
+            status: entry.status,
+        };
+        if (entry.targetType && entry.targetType !== 'prompt')
+            yamlObj.targetType = entry.targetType;
+        if (entry.outputFolder)
+            yamlObj.outputFolder = entry.outputFolder;
+        if (entry.model)
+            yamlObj.model = entry.model;
+        if (entry.mode && entry.mode !== 'autopilot')
+            yamlObj.mode = entry.mode;
+        const yamlContent = yaml.dump(yamlObj, { lineWidth: 120 });
+        fs.writeFileSync(path.join(scheduleDir, `${finalSlug}.yaml`), yamlContent, 'utf-8');
+        // Remove from user schedules
+        this.cancelTimer(entry.id);
+        const map = this.schedules.get(repoId);
+        if (map) {
+            map.delete(entry.id);
+            if (map.size === 0) {
+                this.schedules.delete(repoId);
+                this.persistence.deleteRepo(repoId);
+            }
+            else {
+                this.persist(repoId);
+            }
+        }
+        // Reload repo schedules so the new file is picked up
+        this.reloadRepoSchedules(repoId);
+        const newEntry = this.repoSchedules.get(repoId)?.get(`repo:${finalSlug}`);
+        if (!newEntry) {
+            throw new Error('Failed to load moved schedule from repo');
+        }
+        this.emit('change', {
+            type: 'schedule-removed',
+            repoId,
+            scheduleId: entry.id,
+        });
+        this.emit('change', {
+            type: 'schedule-added',
+            repoId,
+            scheduleId: newEntry.id,
+            schedule: newEntry,
+        });
+        return newEntry;
+    }
+    moveRepoToUser(repoId, entry, rootPath) {
+        // Create a new user schedule (addSchedule strips source)
+        const newEntry = this.addSchedule(repoId, {
+            name: entry.name,
+            target: entry.target,
+            cron: entry.cron,
+            params: { ...entry.params },
+            onFailure: entry.onFailure,
+            status: entry.status,
+            targetType: entry.targetType,
+            outputFolder: entry.outputFolder,
+            model: entry.model,
+            mode: entry.mode,
+        });
+        // Delete the YAML file from .github/schedules/
+        const stem = entry.id.replace(/^repo:/, '');
+        const scheduleDir = (0, repo_schedule_loader_1.getRepoScheduleDir)(rootPath);
+        for (const ext of ['.yaml', '.yml']) {
+            const filePath = path.join(scheduleDir, `${stem}${ext}`);
+            try {
+                if (fs.existsSync(filePath)) {
+                    fs.unlinkSync(filePath);
+                }
+            }
+            catch { /* non-fatal */ }
+        }
+        // Cancel timer for old repo schedule and reload
+        this.cancelTimer(entry.id);
+        this.reloadRepoSchedules(repoId);
+        return newEntry;
+    }
+    // ========================================================================
+    // Private — timer management
+    // ========================================================================
+    scheduleNextRun(repoId, schedule) {
+        if (this.disposed)
+            return;
+        const next = (0, cron_utils_1.nextCronTime)(schedule.cron);
+        if (!next)
+            return;
+        const delayMs = next.getTime() - Date.now();
+        if (delayMs < 0)
+            return;
+        // Cap setTimeout to prevent 32-bit overflow (max ~24.8 days)
+        const MAX_TIMEOUT = 2147483647;
+        const actualDelay = Math.min(delayMs, MAX_TIMEOUT);
+        const timer = setTimeout(() => {
+            this.timers.delete(schedule.id);
+            if (this.disposed)
+                return;
+            const current = this.getSchedule(repoId, schedule.id);
+            if (!current || current.status !== 'active')
+                return;
+            // If delay was capped, just reschedule — we haven't reached the target time yet
+            if (actualDelay < delayMs) {
+                this.scheduleNextRun(repoId, current);
+                return;
+            }
+            // Skip if previous run still active
+            if (this.runningSchedules.has(schedule.id)) {
+                process.stderr.write(`[ScheduleManager] Skipped ${schedule.name}: previous run still active\n`);
+                this.scheduleNextRun(repoId, current);
+                return;
+            }
+            this.executeRun(repoId, current).then(() => {
+                // Schedule next run after completion
+                const latest = this.getSchedule(repoId, schedule.id);
+                if (latest && latest.status === 'active') {
+                    this.scheduleNextRun(repoId, latest);
+                }
+            }).catch(() => {
+                // Still schedule next even on error
+                const latest = this.getSchedule(repoId, schedule.id);
+                if (latest && latest.status === 'active') {
+                    this.scheduleNextRun(repoId, latest);
+                }
+            });
+        }, actualDelay);
+        this.timers.set(schedule.id, timer);
+    }
+    cancelTimer(scheduleId) {
+        const timer = this.timers.get(scheduleId);
+        if (timer) {
+            clearTimeout(timer);
+            this.timers.delete(scheduleId);
+        }
+    }
+    async executeRun(repoId, schedule) {
+        const run = {
+            id: 'run_' + crypto.randomBytes(6).toString('hex'),
+            scheduleId: schedule.id,
+            repoId,
+            startedAt: new Date().toISOString(),
+            status: 'running',
+        };
+        this.runningSchedules.add(schedule.id);
+        this.addRunRecord(schedule.id, run);
+        this.emit('change', {
+            type: 'schedule-triggered',
+            repoId,
+            scheduleId: schedule.id,
+            schedule,
+            run,
+        });
+        try {
+            // Enqueue a task if queueManager is available
+            if (this.queueManager) {
+                if (!schedule.targetType || schedule.targetType === 'prompt') {
+                    const outputPrefix = schedule.outputFolder
+                        ? `Output folder: ${schedule.outputFolder}\n\n`
+                        : '';
+                    const taskId = this.queueManager.enqueue({
+                        type: 'chat',
+                        priority: 'normal',
+                        payload: {
+                            kind: 'chat',
+                            mode: schedule.mode ?? 'autopilot',
+                            prompt: `${outputPrefix}Follow the instruction ${schedule.target}.`,
+                            context: {
+                                files: [schedule.target],
+                                scheduleId: schedule.id,
+                                scheduleParams: schedule.params,
+                            },
+                            workingDirectory: '',
+                        },
+                        config: { model: schedule.model || undefined },
+                        displayName: `[Schedule] ${schedule.name}`,
+                        repoId,
+                    });
+                    run.taskId = taskId;
+                    run.processId = `queue_${taskId}`;
+                }
+                else if (schedule.targetType === 'script') {
+                    const taskId = this.queueManager.enqueue({
+                        type: 'run-script',
+                        priority: 'normal',
+                        payload: {
+                            kind: 'run-script',
+                            script: schedule.target,
+                            workingDirectory: schedule.params?.workingDirectory ?? '',
+                            scheduleId: schedule.id,
+                        },
+                        config: {},
+                        displayName: `[Schedule:script] ${schedule.name}`,
+                        repoId,
+                    });
+                    run.taskId = taskId;
+                    run.processId = `queue_${taskId}`;
+                }
+            }
+            finaliseRun(run, 'completed');
+        }
+        catch (err) {
+            finaliseRun(run, 'failed', err);
+            if (schedule.onFailure === 'stop') {
+                schedule.status = 'stopped';
+                this.cancelTimer(schedule.id);
+                this.persist(repoId);
+            }
+        }
+        finally {
+            this.runningSchedules.delete(schedule.id);
+            this.updateRunRecord(schedule.id, run);
+        }
+        this.emit('change', {
+            type: 'schedule-run-complete',
+            repoId,
+            scheduleId: schedule.id,
+            schedule,
+            run,
+        });
+        return run;
+    }
+    addRunRecord(scheduleId, run) {
+        if (!this.runHistory.has(scheduleId)) {
+            this.runHistory.set(scheduleId, []);
+        }
+        const history = this.runHistory.get(scheduleId);
+        history.unshift(run);
+        if (history.length > MAX_HISTORY_PER_SCHEDULE) {
+            history.pop();
+        }
+        this.persistRunHistory(run.repoId);
+    }
+    updateRunRecord(scheduleId, run) {
+        const history = this.runHistory.get(scheduleId);
+        if (!history)
+            return;
+        const idx = history.findIndex(r => r.id === run.id);
+        if (idx >= 0) {
+            history[idx] = run;
+        }
+        this.persistRunHistory(run.repoId);
+    }
+    persistRunHistory(repoId) {
+        if (!this.runPersistence)
+            return;
+        const allRuns = this.getAllRunsForRepo(repoId);
+        this.runPersistence.save(repoId, allRuns);
+    }
+    getAllRunsForRepo(repoId) {
+        const result = [];
+        for (const runs of this.runHistory.values()) {
+            for (const run of runs) {
+                if (run.repoId === repoId) {
+                    result.push(run);
+                }
+            }
+        }
+        return result;
+    }
+    persist(repoId) {
+        // Only persist user-managed schedules (not repo-sourced ones)
+        const map = this.schedules.get(repoId);
+        const schedules = map ? Array.from(map.values()) : [];
+        this.persistence.saveRepo(repoId, schedules);
+    }
+    // ========================================================================
+    // Public — repo schedule management
+    // ========================================================================
+    /**
+     * Register a workspace root path for a repo and load repo-defined schedules
+     * from <rootPath>/.github/schedules/.  Sets up a file watcher for live reload.
+     * Safe to call multiple times (idempotent — re-registers path and refreshes).
+     */
+    registerWorkspacePath(repoId, rootPath) {
+        this.workspacePaths.set(repoId, rootPath);
+        this.reloadRepoSchedules(repoId);
+        this.watchRepoScheduleDir(repoId, rootPath);
+    }
+    /**
+     * Reload repo-defined schedules for a workspace from disk.
+     * Called automatically by the file watcher.
+     */
+    reloadRepoSchedules(repoId) {
+        const rootPath = this.workspacePaths.get(repoId);
+        if (!rootPath)
+            return;
+        const overrides = this.overrideStore?.load(repoId) ?? {};
+        const entries = (0, repo_schedule_loader_1.loadRepoSchedules)(rootPath, overrides);
+        const newMap = new Map();
+        for (const entry of entries) {
+            newMap.set(entry.id, entry);
+        }
+        // Cancel timers for schedules that were removed or are no longer active
+        const oldMap = this.repoSchedules.get(repoId);
+        if (oldMap) {
+            for (const [id, old] of oldMap) {
+                const updated = newMap.get(id);
+                if (!updated || updated.status !== 'active') {
+                    this.cancelTimer(id);
+                }
+                else if (updated.cron !== old.cron) {
+                    // Cron changed — reschedule
+                    this.cancelTimer(id);
+                }
+            }
+        }
+        if (newMap.size > 0) {
+            this.repoSchedules.set(repoId, newMap);
+        }
+        else {
+            this.repoSchedules.delete(repoId);
+        }
+        // Start timers for active repo schedules
+        for (const entry of newMap.values()) {
+            if (entry.status === 'active' && !this.timers.has(entry.id)) {
+                this.scheduleNextRun(repoId, entry);
+            }
+        }
+    }
+    watchRepoScheduleDir(repoId, rootPath) {
+        if (this.disposed)
+            return;
+        const scheduleDir = (0, repo_schedule_loader_1.getRepoScheduleDir)(rootPath);
+        try {
+            if (!fs.existsSync(scheduleDir))
+                return;
+        }
+        catch {
+            return;
+        }
+        // Close existing watcher if re-registering
+        const existing = this.repoWatchers.get(repoId);
+        if (existing) {
+            try {
+                existing.close();
+            }
+            catch { /* non-fatal */ }
+            this.repoWatchers.delete(repoId);
+        }
+        try {
+            const watcher = fs.watch(scheduleDir, () => {
+                const prevTimer = this.watchDebounceTimers.get(repoId);
+                if (prevTimer)
+                    clearTimeout(prevTimer);
+                const timer = setTimeout(() => {
+                    this.watchDebounceTimers.delete(repoId);
+                    this.reloadRepoSchedules(repoId);
+                }, 300);
+                this.watchDebounceTimers.set(repoId, timer);
+            });
+            this.repoWatchers.set(repoId, watcher);
+        }
+        catch {
+            // Non-fatal: file watching may not be available in all environments
+        }
+    }
+}
+exports.ScheduleManager = ScheduleManager;
+//# sourceMappingURL=schedule-manager.js.map