fluxy-bot 0.8.9 → 0.9.0

package/supervisor/scheduler.ts

@@ -15,24 +15,24 @@ const PULSE_FILE = path.join(WORKSPACE_DIR, 'PULSE.json');
 const CRONS_FILE = path.join(WORKSPACE_DIR, 'CRONS.json');
 
 interface PulseConfig {
-    enabled: boolean;
-    intervalMinutes: number;
-    quietHours: { start: string; end: string };
+  enabled: boolean;
+  intervalMinutes: number;
+  quietHours: { start: string; end: string };
 }
 
 interface CronConfig {
-    id: string;
-    schedule: string;
-    task: string;
-    enabled: boolean;
-    oneShot?: boolean;
+  id: string;
+  schedule: string;
+  task: string;
+  enabled: boolean;
+  oneShot?: boolean;
 }
 
 interface SchedulerOpts {
-    broadcastFluxy: (type: string, data: any) => void;
-    workerApi: (path: string, method?: string, body?: any) => Promise<any>;
-    restartBackend: () => void;
-    getModel: () => string;
+  broadcastFluxy: (type: string, data: any) => void;
+  workerApi: (path: string, method?: string, body?: any) => Promise<any>;
+  restartBackend: () => void;
+  getModel: () => string;
 }
 
 // State
@@ -42,330 +42,268 @@ let intervalHandle: ReturnType<typeof setInterval> | null = null;
 let schedulerOpts: SchedulerOpts | null = null;
 
 function readPulseConfig(): PulseConfig {
-    try {
-        const raw = fs.readFileSync(PULSE_FILE, 'utf-8');
-        const parsed = JSON.parse(raw);
-        return {
-            enabled: !!parsed.enabled,
-            intervalMinutes: parsed.intervalMinutes || 30,
-            quietHours: parsed.quietHours || { start: '23:00', end: '07:00' }
-        };
-    } catch {
-        return {
-            enabled: false,
-            intervalMinutes: 30,
-            quietHours: { start: '23:00', end: '07:00' }
-        };
-    }
+  try {
+    const raw = fs.readFileSync(PULSE_FILE, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return {
+      enabled: !!parsed.enabled,
+      intervalMinutes: parsed.intervalMinutes || 30,
+      quietHours: parsed.quietHours || { start: '23:00', end: '07:00' },
+    };
+  } catch {
+    return { enabled: false, intervalMinutes: 30, quietHours: { start: '23:00', end: '07:00' } };
+  }
 }
 
 function readCronsConfig(): CronConfig[] {
-    try {
-        const raw = fs.readFileSync(CRONS_FILE, 'utf-8');
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) ? parsed : [];
-    } catch {
-        return [];
-    }
+  try {
+    const raw = fs.readFileSync(CRONS_FILE, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
 }
 
 /** Write crons back to disk (for oneShot cleanup) */
 function writeCronsConfig(crons: CronConfig[]) {
-    try {
-        fs.writeFileSync(
-            CRONS_FILE,
-            JSON.stringify(crons, null, 2) + '\n',
-            'utf-8'
-        );
-    } catch (err: any) {
-        log.warn(`[scheduler] Failed to write CRONS.json: ${err.message}`);
-    }
+  try {
+    fs.writeFileSync(CRONS_FILE, JSON.stringify(crons, null, 2) + '\n', 'utf-8');
+  } catch (err: any) {
+    log.warn(`[scheduler] Failed to write CRONS.json: ${err.message}`);
+  }
 }
 
 function isInQuietHours(quietHours: { start: string; end: string }): boolean {
-    const now = new Date();
-    const [startH, startM] = quietHours.start.split(':').map(Number);
-    const [endH, endM] = quietHours.end.split(':').map(Number);
-    const currentMinutes = now.getHours() * 60 + now.getMinutes();
-    const startMinutes = startH * 60 + startM;
-    const endMinutes = endH * 60 + endM;
-
-    if (startMinutes <= endMinutes) {
-        return currentMinutes >= startMinutes && currentMinutes < endMinutes;
-    } else {
-        return currentMinutes >= startMinutes || currentMinutes < endMinutes;
-    }
+  const now = new Date();
+  const [startH, startM] = quietHours.start.split(':').map(Number);
+  const [endH, endM] = quietHours.end.split(':').map(Number);
+  const currentMinutes = now.getHours() * 60 + now.getMinutes();
+  const startMinutes = startH * 60 + startM;
+  const endMinutes = endH * 60 + endM;
+
+  if (startMinutes <= endMinutes) {
+    return currentMinutes >= startMinutes && currentMinutes < endMinutes;
+  } else {
+    return currentMinutes >= startMinutes || currentMinutes < endMinutes;
+  }
 }
 
 /** Check if a cron schedule has no future occurrences (expired one-shot) */
 function cronIsExpired(schedule: string): boolean {
-    try {
-        const interval = CronExpressionParser.parse(schedule);
-        interval.next(); // throws if no future occurrence
-        return false;
-    } catch {
-        return true;
-    }
+  try {
+    const interval = CronExpressionParser.parse(schedule);
+    interval.next(); // throws if no future occurrence
+    return false;
+  } catch {
+    return true;
+  }
 }
 
 function cronMatchesNow(schedule: string): boolean {
-    try {
-        const interval = CronExpressionParser.parse(schedule);
-        const prev = interval.prev().toDate();
-        const now = new Date();
-        return (
-            prev.getFullYear() === now.getFullYear() &&
-            prev.getMonth() === now.getMonth() &&
-            prev.getDate() === now.getDate() &&
-            prev.getHours() === now.getHours() &&
-            prev.getMinutes() === now.getMinutes()
-        );
-    } catch {
-        return false;
-    }
+  try {
+    const interval = CronExpressionParser.parse(schedule);
+    const prev = interval.prev().toDate();
+    const now = new Date();
+    return (
+      prev.getFullYear() === now.getFullYear() &&
+      prev.getMonth() === now.getMonth() &&
+      prev.getDate() === now.getDate() &&
+      prev.getHours() === now.getHours() &&
+      prev.getMinutes() === now.getMinutes()
+    );
+  } catch {
+    return false;
+  }
 }
 
 function triggerAgent(prompt: string, label: string, onComplete?: () => void) {
-    if (!schedulerOpts) return;
-    const { broadcastFluxy, workerApi, restartBackend, getModel } =
-        schedulerOpts;
-    const timestamp = Date.now();
-    const convId = label.startsWith('pulse')
-        ? `pulse-${timestamp}`
-        : `cron-${label}-${timestamp}`;
-    const model = getModel();
-
-    log.info(`[scheduler] ${label} triggered — starting agent query`);
-
-    (async () => {
-        // Use the user's current conversation (or create one)
-        let dbConvId: string | undefined;
-        try {
-            const ctx = await workerApi('/api/context/current');
-            if (ctx.conversationId) {
-                dbConvId = ctx.conversationId;
-            } else {
-                const conv = await workerApi('/api/conversations', 'POST', {
-                    title: `Chat`,
-                    model
-                });
-                dbConvId = conv.id;
-                await workerApi('/api/context/set', 'POST', {
-                    conversationId: dbConvId
-                });
-            }
-        } catch (err: any) {
-            log.warn(
-                `[scheduler] Failed to get/create conversation for ${label}: ${err.message}`
-            );
-        }
+  if (!schedulerOpts) return;
+  const { broadcastFluxy, workerApi, restartBackend, getModel } = schedulerOpts;
+  const timestamp = Date.now();
+  const convId = label.startsWith('pulse') ? `pulse-${timestamp}` : `cron-${label}-${timestamp}`;
+  const model = getModel();
 
-        // Fetch bot name for push notification title
-        let botName = 'Fluxy';
-        try {
-            const status = await workerApi('/api/onboard/status');
-            if (status.agentName) botName = status.agentName;
-        } catch {}
+  log.info(`[scheduler] ${label} triggered — starting agent query`);
 
-        let fullResponse = '';
+  (async () => {
+    // Use the user's current conversation (or create one)
+    let dbConvId: string | undefined;
+    try {
+      const ctx = await workerApi('/api/context/current');
+      if (ctx.conversationId) {
+        dbConvId = ctx.conversationId;
+      } else {
+        const conv = await workerApi('/api/conversations', 'POST', {
+          title: `Chat`,
+          model,
+        });
+        dbConvId = conv.id;
+        await workerApi('/api/context/set', 'POST', { conversationId: dbConvId });
+      }
+    } catch (err: any) {
+      log.warn(`[scheduler] Failed to get/create conversation for ${label}: ${err.message}`);
+    }
 
-        startFluxyAgentQuery(convId, prompt, model, (type, eventData) => {
-            if (type === 'bot:response') {
-                fullResponse = eventData.content || '';
+    // Fetch bot name for push notification title
+    let botName = 'Fluxy';
+    try {
+      const status = await workerApi('/api/onboard/status');
+      if (status.agentName) botName = status.agentName;
+    } catch {}
+
+    let fullResponse = '';
+
+    startFluxyAgentQuery(convId, prompt, model, (type, eventData) => {
+      if (type === 'bot:response') {
+        fullResponse = eventData.content || '';
+      }
+
+      if (type === 'bot:done') {
+        // Extract <Message> blocks after agent turn completes
+        if (fullResponse) {
+          const messageRegex = /<Message(?:\s+([^>]*))?>(([\s\S]*?))<\/Message>/g;
+          let match;
+          while ((match = messageRegex.exec(fullResponse)) !== null) {
+            const attrs = match[1] || '';
+            const messageContent = match[2].trim();
+            const titleMatch = attrs.match(/title="([^"]*)"/);
+
+            log.info(`[scheduler] Agent message: ${messageContent.slice(0, 80)}...`);
+
+            const msgTimestamp = new Date().toISOString();
+
+            // Save to the user's conversation in DB
+            if (dbConvId) {
+              workerApi(`/api/conversations/${dbConvId}/messages`, 'POST', {
+                role: 'assistant',
+                content: messageContent,
+                meta: { model },
+              }).catch((err: any) => {
+                log.warn(`[scheduler] DB persist error: ${err.message}`);
+              });
             }
 
-            if (type === 'bot:done') {
-                // Extract <Message> blocks after agent turn completes
-                if (fullResponse) {
-                    const messageRegex =
-                        /<Message(?:\s+([^>]*))?>(([\s\S]*?))<\/Message>/g;
-                    let match;
-                    while ((match = messageRegex.exec(fullResponse)) !== null) {
-                        const attrs = match[1] || '';
-                        const messageContent = match[2].trim();
-                        const titleMatch = attrs.match(/title="([^"]*)"/);
-
-                        log.info(
-                            `[scheduler] Agent message: ${messageContent.slice(0, 80)}...`
-                        );
-
-                        const msgTimestamp = new Date().toISOString();
-
-                        // Save to the user's conversation in DB
-                        if (dbConvId) {
-                            workerApi(
-                                `/api/conversations/${dbConvId}/messages`,
-                                'POST',
-                                {
-                                    role: 'assistant',
-                                    content: messageContent,
-                                    meta: { model }
-                                }
-                            ).catch((err: any) => {
-                                log.warn(
-                                    `[scheduler] DB persist error: ${err.message}`
-                                );
-                            });
-                        }
-
-                        // Broadcast as a regular message to all connected clients
-                        broadcastFluxy('chat:sync', {
-                            conversationId: dbConvId,
-                            message: {
-                                role: 'assistant',
-                                content: messageContent,
-                                timestamp: msgTimestamp
-                            }
-                        });
-
-                        // Send push notification for closed tabs / locked devices
-                        workerApi('/api/push/send', 'POST', {
-                            title: titleMatch?.[1] || botName,
-                            body: messageContent.slice(0, 200),
-                            tag: `fluxy-${label}`,
-                            url: '/'
-                        })
-                            .then((r: any) => {
-                                log.info(
-                                    `[scheduler] Push sent: ${r.sent}/${r.total}`
-                                );
-                            })
-                            .catch((err: any) => {
-                                log.warn(
-                                    `[scheduler] Push send failed: ${err.message}`
-                                );
-                            });
-                    }
-                }
-
-                log.info(`[scheduler] ${label} agent query complete`);
-                if (eventData.usedFileTools) {
-                    log.info(
-                        `[scheduler] File tools used — restarting backend`
-                    );
-                    restartBackend();
-                }
-                onComplete?.();
-            }
+            // Broadcast as a regular message to all connected clients
+            broadcastFluxy('chat:sync', {
+              conversationId: dbConvId,
+              message: { role: 'assistant', content: messageContent, timestamp: msgTimestamp },
+            });
+
+            // Send push notification for closed tabs / locked devices
+            workerApi('/api/push/send', 'POST', {
+              title: titleMatch?.[1] || botName,
+              body: messageContent.slice(0, 200),
+              tag: `fluxy-${label}`,
+              url: '/',
+            }).then((r: any) => {
+              log.info(`[scheduler] Push sent: ${r.sent}/${r.total}`);
+            }).catch((err: any) => {
+              log.warn(`[scheduler] Push send failed: ${err.message}`);
+            });
+          }
+        }
 
-            if (type === 'bot:error') {
-                log.warn(
-                    `[scheduler] ${label} agent error: ${eventData.error}`
-                );
-            }
-        });
-    })();
+        log.info(`[scheduler] ${label} agent query complete`);
+        if (eventData.usedFileTools) {
+          log.info(`[scheduler] File tools used — restarting backend`);
+          restartBackend();
+        }
+        onComplete?.();
+      }
+
+      if (type === 'bot:error') {
+        log.warn(`[scheduler] ${label} agent error: ${eventData.error}`);
+      }
+    });
+  })();
 }
 
 function tick() {
-    const now = Date.now();
-
-    // ── Pulse check ──
-    const pulse = readPulseConfig();
-    if (pulse.enabled && !isInQuietHours(pulse.quietHours)) {
-        const elapsed = now - lastPulseTime;
-        const intervalMs = pulse.intervalMinutes * 60 * 1000;
-        if (elapsed >= intervalMs) {
-            lastPulseTime = now;
-            triggerAgent('<PULSE/>', 'pulse');
-        }
+  const now = Date.now();
+
+  // ── Pulse check ──
+  const pulse = readPulseConfig();
+  if (pulse.enabled && !isInQuietHours(pulse.quietHours)) {
+    const elapsed = now - lastPulseTime;
+    const intervalMs = pulse.intervalMinutes * 60 * 1000;
+    if (elapsed >= intervalMs) {
+      lastPulseTime = now;
+      triggerAgent('<PULSE/>', 'pulse');
     }
-
-    // ── Cron check ──
-    const crons = readCronsConfig();
-
-    for (const cron of crons) {
-        if (!cron.enabled || !cron.id || !cron.schedule) continue;
-
-        const matches = cronMatchesNow(cron.schedule);
-        const nowDate = new Date();
-        log.info(
-            `[scheduler] Cron "${cron.id}" schedule="${cron.schedule}" matches=${matches} now=${nowDate.getHours()}:${String(nowDate.getMinutes()).padStart(2, '0')}`
-        );
-
-        if (matches) {
-            const lastRun = lastCronRuns.get(cron.id) || 0;
-            const oneMinuteAgo = now - 60_000;
-            if (lastRun < oneMinuteAgo) {
-                lastCronRuns.set(cron.id, now);
-                // One-shots: defer removal until agent completes (so agent can still read CRONS.json)
-                const onComplete = cron.oneShot
-                    ? () => {
-                          log.info(
-                              `[scheduler] Removing fired one-shot cron: ${cron.id}`
-                          );
-                          const fresh = readCronsConfig().filter(
-                              c => c.id !== cron.id
-                          );
-                          writeCronsConfig(fresh);
-                          // Also remove the task file if it exists
-                          try {
-                              fs.unlinkSync(
-                                  path.join(
-                                      WORKSPACE_DIR,
-                                      'tasks',
-                                      `${cron.id}.md`
-                                  )
-                              );
-                          } catch {}
-                      }
-                    : undefined;
-                // Inject task file content if tasks/{id}.md exists
-                let cronPrompt = `<CRON>${cron.id}</CRON>`;
-                try {
-                    const taskFile = path.join(
-                        WORKSPACE_DIR,
-                        'tasks',
-                        `${cron.id}.md`
-                    );
-                    const taskContent = fs
-                        .readFileSync(taskFile, 'utf-8')
-                        .trim();
-                    if (taskContent) {
-                        cronPrompt += `\n<CRON_TASK_DETAIL>\n${taskContent}\n</CRON_TASK_DETAIL>`;
-                    }
-                } catch {}
-                triggerAgent(cronPrompt, cron.id, onComplete);
-            }
-        }
+  }
+
+  // ── Cron check ──
+  const crons = readCronsConfig();
+
+  for (const cron of crons) {
+    if (!cron.enabled || !cron.id || !cron.schedule) continue;
+
+    const matches = cronMatchesNow(cron.schedule);
+    const nowDate = new Date();
+    log.info(`[scheduler] Cron "${cron.id}" schedule="${cron.schedule}" matches=${matches} now=${nowDate.getHours()}:${String(nowDate.getMinutes()).padStart(2,'0')}`);
+
+    if (matches) {
+      const lastRun = lastCronRuns.get(cron.id) || 0;
+      const oneMinuteAgo = now - 60_000;
+      if (lastRun < oneMinuteAgo) {
+        lastCronRuns.set(cron.id, now);
+        // One-shots: defer removal until agent completes (so agent can still read CRONS.json)
+        const onComplete = cron.oneShot ? () => {
+          log.info(`[scheduler] Removing fired one-shot cron: ${cron.id}`);
+          const fresh = readCronsConfig().filter((c) => c.id !== cron.id);
+          writeCronsConfig(fresh);
+          // Also remove the task file if it exists
+          try {
+            fs.unlinkSync(path.join(WORKSPACE_DIR, 'tasks', `${cron.id}.md`));
+          } catch {}
+        } : undefined;
+        // Inject task file content if tasks/{id}.md exists
+        let cronPrompt = `<CRON>${cron.id}</CRON>`;
+        try {
+          const taskFile = path.join(WORKSPACE_DIR, 'tasks', `${cron.id}.md`);
+          const taskContent = fs.readFileSync(taskFile, 'utf-8').trim();
+          if (taskContent) {
+            cronPrompt += `\n<CRON_TASK_DETAIL>\n${taskContent}\n</CRON_TASK_DETAIL>`;
+          }
+        } catch {}
+        triggerAgent(cronPrompt, cron.id, onComplete);
+      }
     }
+  }
+
+  // ── Cleanup: remove expired one-shots (schedule in the past, never gonna fire) ──
+  if (crons.length > 0) {
+    const cleaned = crons.filter((c) => {
+      if (c.oneShot && cronIsExpired(c.schedule)) {
+        log.info(`[scheduler] cronIsExpired=true for "${c.id}" schedule="${c.schedule}"`);
+        log.info(`[scheduler] Removing expired one-shot cron: ${c.id}`);
+        try {
+          fs.unlinkSync(path.join(WORKSPACE_DIR, 'tasks', `${c.id}.md`));
+        } catch {}
+        return false;
+      }
+      return true;
+    });
 
-    // ── Cleanup: remove expired one-shots (schedule in the past, never gonna fire) ──
-    if (crons.length > 0) {
-        const cleaned = crons.filter(c => {
-            if (c.oneShot && cronIsExpired(c.schedule)) {
-                log.info(
-                    `[scheduler] cronIsExpired=true for "${c.id}" schedule="${c.schedule}"`
-                );
-                log.info(`[scheduler] Removing expired one-shot cron: ${c.id}`);
-                try {
-                    fs.unlinkSync(
-                        path.join(WORKSPACE_DIR, 'tasks', `${c.id}.md`)
-                    );
-                } catch {}
-                return false;
-            }
-            return true;
-        });
-
-        if (cleaned.length !== crons.length) {
-            writeCronsConfig(cleaned);
-        }
+    if (cleaned.length !== crons.length) {
+      writeCronsConfig(cleaned);
     }
+  }
 }
 
 export function startScheduler(opts: SchedulerOpts) {
-    schedulerOpts = opts;
-    lastPulseTime = Date.now();
-    intervalHandle = setInterval(tick, 60_000);
-    log.info('[scheduler] Started — checking every 60s');
+  schedulerOpts = opts;
+  lastPulseTime = Date.now();
+  intervalHandle = setInterval(tick, 60_000);
+  log.info('[scheduler] Started — checking every 60s');
 }
 
 export function stopScheduler() {
-    if (intervalHandle) {
-        clearInterval(intervalHandle);
-        intervalHandle = null;
-    }
-    schedulerOpts = null;
-    log.info('[scheduler] Stopped');
+  if (intervalHandle) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+  }
+  schedulerOpts = null;
+  log.info('[scheduler] Stopped');
 }