alvin-bot 4.4.1

package/dist/services/cron.js

@@ -0,0 +1,462 @@
+/**
+ * Cron Service — Persistent scheduled tasks.
+ *
+ * Supports:
+ * - Interval-based jobs (every 5m, 1h, etc.)
+ * - Cron expressions (0 9 * * 1 = every Monday 9am)
+ * - One-shot scheduled tasks (run once at a specific time)
+ * - Job types: reminder, shell, ai-query, http
+ * - Management via /cron command + Web UI
+ * - Persisted to docs/cron-jobs.json (survives restarts)
+ */
+import fs from "fs";
+import { execSync } from "child_process";
+import { dirname } from "path";
+import { getRegistry } from "../engine.js";
+import { CRON_FILE, BOT_ROOT } from "../paths.js";
+// ── Storage ─────────────────────────────────────────────
+function loadJobs() {
+    try {
+        return JSON.parse(fs.readFileSync(CRON_FILE, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveJobs(jobs) {
+    const dir = dirname(CRON_FILE);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CRON_FILE, JSON.stringify(jobs, null, 2));
+}
+// ── Cron Parsing ────────────────────────────────────────
+/**
+ * Parse an interval string (5m, 1h, 30s, 2d) to milliseconds.
+ */
+function parseInterval(input) {
+    const match = input.match(/^(\d+(?:\.\d+)?)\s*(s|sec|m|min|h|hr|d|day)s?$/i);
+    if (!match)
+        return null;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    const mult = { s: 1000, sec: 1000, m: 60_000, min: 60_000, h: 3_600_000, hr: 3_600_000, d: 86_400_000, day: 86_400_000 };
+    return value * (mult[unit] || 60_000);
+}
+/**
+ * Parse a cron expression and find the next run time.
+ * Supports: minute hour day month weekday
+ * Simple implementation — covers common cases.
+ */
+function nextCronRun(expression, after = new Date()) {
+    const parts = expression.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const [minExpr, hourExpr, dayExpr, monthExpr, weekdayExpr] = parts;
+    function parseField(expr, min, max) {
+        if (expr === "*")
+            return Array.from({ length: max - min + 1 }, (_, i) => i + min);
+        if (expr.includes("/")) {
+            const [, step] = expr.split("/");
+            const s = parseInt(step);
+            return Array.from({ length: max - min + 1 }, (_, i) => i + min).filter(v => v % s === 0);
+        }
+        if (expr.includes(","))
+            return expr.split(",").map(Number);
+        if (expr.includes("-")) {
+            const [a, b] = expr.split("-").map(Number);
+            return Array.from({ length: b - a + 1 }, (_, i) => i + a);
+        }
+        return [parseInt(expr)];
+    }
+    const minutes = parseField(minExpr, 0, 59);
+    const hours = parseField(hourExpr, 0, 23);
+    const days = parseField(dayExpr, 1, 31);
+    const months = parseField(monthExpr, 1, 12);
+    const weekdays = parseField(weekdayExpr, 0, 6); // 0=Sun
+    // Search forward up to 366 days
+    const candidate = new Date(after);
+    candidate.setSeconds(0, 0);
+    candidate.setMinutes(candidate.getMinutes() + 1);
+    for (let i = 0; i < 366 * 24 * 60; i++) {
+        const m = candidate.getMinutes();
+        const h = candidate.getHours();
+        const d = candidate.getDate();
+        const mo = candidate.getMonth() + 1;
+        const wd = candidate.getDay();
+        if (minutes.includes(m) && hours.includes(h) && days.includes(d) && months.includes(mo) && weekdays.includes(wd)) {
+            return candidate;
+        }
+        candidate.setMinutes(candidate.getMinutes() + 1);
+    }
+    return null;
+}
+/**
+ * Calculate next run time for a job.
+ */
+function calculateNextRun(job) {
+    if (!job.enabled)
+        return null;
+    // Interval-based
+    const intervalMs = parseInterval(job.schedule);
+    if (intervalMs) {
+        const base = job.lastRunAt || job.createdAt;
+        return base + intervalMs;
+    }
+    // Cron expression
+    const next = nextCronRun(job.schedule);
+    return next ? next.getTime() : null;
+}
+let notifyCallback = null;
+export function setNotifyCallback(fn) {
+    notifyCallback = fn;
+}
+async function executeJob(job) {
+    try {
+        switch (job.type) {
+            case "reminder":
+            case "message": {
+                const text = job.payload.text || "(no message)";
+                if (notifyCallback) {
+                    await notifyCallback(job.target, `⏰ ${job.name}\n\n${text}`);
+                }
+                return { output: `Sent: ${text.slice(0, 100)}` };
+            }
+            case "shell": {
+                const cmd = job.payload.command || "echo 'no command'";
+                const output = execSync(cmd, {
+                    timeout: 60_000,
+                    stdio: "pipe",
+                    env: { ...process.env, PATH: process.env.PATH + ":/opt/homebrew/bin:/usr/local/bin" },
+                }).toString().trim();
+                // Notify with output
+                if (notifyCallback && output) {
+                    await notifyCallback(job.target, `🔧 ${job.name}\n\`\`\`\n${output.slice(0, 3000)}\n\`\`\``);
+                }
+                return { output: output.slice(0, 5000) };
+            }
+            case "http": {
+                const url = job.payload.url || "";
+                const method = job.payload.method || "GET";
+                const headers = job.payload.headers || {};
+                const fetchOpts = { method, headers };
+                if (job.payload.body && method !== "GET") {
+                    fetchOpts.body = job.payload.body;
+                }
+                const res = await fetch(url, fetchOpts);
+                const text = await res.text();
+                const output = `HTTP ${res.status}: ${text.slice(0, 2000)}`;
+                if (notifyCallback) {
+                    await notifyCallback(job.target, `🌐 ${job.name}\n${output.slice(0, 500)}`);
+                }
+                return { output };
+            }
+            case "ai-query": {
+                // AI queries run through the actual AI engine (Claude SDK)
+                const prompt = job.payload.prompt || "";
+                try {
+                    const registry = getRegistry();
+                    const queryOpts = {
+                        prompt,
+                        systemPrompt: `You are Alvin Bot, an autonomous AI assistant. You are currently executing a scheduled cron job ("${job.name}"). Reply concisely. Use Telegram-compatible Markdown. You have access to tools (Bash, files, etc.) — use them if needed.`,
+                        effort: "high",
+                        workingDir: BOT_ROOT,
+                    };
+                    let fullResponse = "";
+                    for await (const chunk of registry.queryWithFallback(queryOpts)) {
+                        if (chunk.type === "text" && chunk.text) {
+                            fullResponse = chunk.text;
+                        }
+                        if (chunk.type === "error") {
+                            throw new Error(chunk.error || "AI query failed");
+                        }
+                        if (chunk.type === "done") {
+                            break;
+                        }
+                    }
+                    // Send AI response to target
+                    if (notifyCallback && fullResponse.trim()) {
+                        // Split long responses into chunks (Telegram limit ~4096 chars)
+                        const maxLen = 3900;
+                        if (fullResponse.length <= maxLen) {
+                            await notifyCallback(job.target, fullResponse);
+                        }
+                        else {
+                            const parts = [];
+                            for (let i = 0; i < fullResponse.length; i += maxLen) {
+                                parts.push(fullResponse.slice(i, i + maxLen));
+                            }
+                            for (const part of parts) {
+                                await notifyCallback(job.target, part);
+                            }
+                        }
+                    }
+                    return { output: fullResponse.slice(0, 500) };
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err.message : String(err);
+                    if (notifyCallback) {
+                        await notifyCallback(job.target, `❌ AI-Query Error (${job.name}): ${error}`);
+                    }
+                    throw err;
+                }
+            }
+            default:
+                return { output: "", error: `Unknown job type: ${job.type}` };
+        }
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        if (notifyCallback) {
+            await notifyCallback(job.target, `❌ Cron Error (${job.name}): ${error}`);
+        }
+        return { output: "", error };
+    }
+}
+// ── Scheduler Loop ──────────────────────────────────────
+let schedulerTimer = null;
+const runningJobs = new Set(); // Guard against overlapping executions
+export function startScheduler() {
+    if (schedulerTimer)
+        return;
+    // Check every 30 seconds for due jobs
+    schedulerTimer = setInterval(async () => {
+        const jobs = loadJobs();
+        const now = Date.now();
+        let changed = false;
+        for (const job of jobs) {
+            if (!job.enabled)
+                continue;
+            // Skip if this job is already running
+            if (runningJobs.has(job.id))
+                continue;
+            // Calculate next run if not set
+            if (!job.nextRunAt) {
+                job.nextRunAt = calculateNextRun(job);
+                changed = true;
+            }
+            if (job.nextRunAt && now >= job.nextRunAt) {
+                console.log(`Cron: Running job "${job.name}" (${job.id})`);
+                // Mark as running + clear nextRunAt BEFORE async execution to prevent re-trigger
+                runningJobs.add(job.id);
+                job.nextRunAt = null;
+                saveJobs(jobs);
+                try {
+                    const result = await executeJob(job);
+                    // Re-load jobs in case they were modified during execution
+                    const freshJobs = loadJobs();
+                    const freshJob = freshJobs.find(j => j.id === job.id);
+                    if (freshJob) {
+                        freshJob.lastRunAt = now;
+                        freshJob.lastResult = result.output.slice(0, 500);
+                        freshJob.lastError = result.error || null;
+                        freshJob.runCount++;
+                        if (freshJob.oneShot) {
+                            freshJob.enabled = false;
+                            freshJob.nextRunAt = null;
+                        }
+                        else {
+                            freshJob.nextRunAt = calculateNextRun(freshJob);
+                        }
+                        saveJobs(freshJobs);
+                    }
+                }
+                finally {
+                    runningJobs.delete(job.id);
+                }
+                continue; // Skip the outer changed/save since we save inside
+            }
+        }
+        if (changed)
+            saveJobs(jobs);
+    }, 30_000);
+    console.log("⏰ Cron scheduler started (30s interval)");
+}
+export function stopScheduler() {
+    if (schedulerTimer) {
+        clearInterval(schedulerTimer);
+        schedulerTimer = null;
+    }
+}
+// ── Public CRUD API ─────────────────────────────────────
+function generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+}
+export function createJob(input) {
+    const job = {
+        id: generateId(),
+        name: input.name,
+        type: input.type,
+        schedule: input.schedule,
+        oneShot: input.oneShot ?? false,
+        payload: input.payload,
+        target: input.target,
+        enabled: input.enabled ?? true,
+        createdAt: Date.now(),
+        lastRunAt: null,
+        lastResult: null,
+        lastError: null,
+        nextRunAt: null,
+        runCount: 0,
+        createdBy: input.createdBy || "unknown",
+    };
+    // Calculate first run
+    job.nextRunAt = calculateNextRun(job);
+    const jobs = loadJobs();
+    jobs.push(job);
+    saveJobs(jobs);
+    return job;
+}
+export function listJobs() {
+    return loadJobs();
+}
+export function getJob(id) {
+    return loadJobs().find(j => j.id === id);
+}
+export function updateJob(id, updates) {
+    const jobs = loadJobs();
+    const idx = jobs.findIndex(j => j.id === id);
+    if (idx < 0)
+        return null;
+    Object.assign(jobs[idx], updates);
+    if (updates.schedule || updates.enabled !== undefined) {
+        jobs[idx].nextRunAt = calculateNextRun(jobs[idx]);
+    }
+    saveJobs(jobs);
+    return jobs[idx];
+}
+export function deleteJob(id) {
+    const jobs = loadJobs();
+    const filtered = jobs.filter(j => j.id !== id);
+    if (filtered.length === jobs.length)
+        return false;
+    saveJobs(filtered);
+    return true;
+}
+export function toggleJob(id) {
+    const jobs = loadJobs();
+    const job = jobs.find(j => j.id === id);
+    if (!job)
+        return null;
+    job.enabled = !job.enabled;
+    job.nextRunAt = calculateNextRun(job);
+    saveJobs(jobs);
+    return job;
+}
+export function runJobNow(id) {
+    const job = getJob(id);
+    if (!job)
+        return null;
+    return executeJob(job);
+}
+/**
+ * Convert a cron expression or interval string to a human-readable German description.
+ */
+export function humanReadableSchedule(schedule) {
+    // Interval strings (5m, 1h, 30s, 2d)
+    const intervalMatch = schedule.match(/^(\d+(?:\.\d+)?)\s*(s|sec|m|min|h|hr|d|day)s?$/i);
+    if (intervalMatch) {
+        const value = parseFloat(intervalMatch[1]);
+        const unit = intervalMatch[2].toLowerCase();
+        const labels = {
+            s: ["second", "seconds"], sec: ["second", "seconds"],
+            m: ["minute", "minutes"], min: ["minute", "minutes"],
+            h: ["hour", "hours"], hr: ["hour", "hours"],
+            d: ["day", "days"], day: ["day", "days"],
+        };
+        const [sing, plur] = labels[unit] || ["?", "?"];
+        return `Every ${value} ${value === 1 ? sing : plur}`;
+    }
+    // Cron expression: MIN HOUR DAY MONTH WEEKDAY
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return schedule;
+    const [minExpr, hourExpr, dayExpr, monthExpr, weekdayExpr] = parts;
+    const weekdayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    const monthNames = ["", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    // Helper: format time from hour + minute expressions
+    function formatTime(h, m) {
+        if (h === "*" && m === "*")
+            return "";
+        const hh = h === "*" ? "*" : h.padStart(2, "0");
+        const mm = m === "*" ? "00" : m.padStart(2, "0");
+        return `${hh}:${mm}`;
+    }
+    // Helper: expand comma/range fields to readable list
+    function expandField(expr, names) {
+        if (expr === "*")
+            return "";
+        const vals = expr.split(",").map(v => {
+            if (v.includes("-")) {
+                const [a, b] = v.split("-");
+                if (names)
+                    return `${names[+a]}–${names[+b]}`;
+                return `${a}–${b}`;
+            }
+            return names ? (names[+v] || v) : v;
+        });
+        return vals.join(", ");
+    }
+    const time = formatTime(hourExpr, minExpr);
+    const hasStep = [minExpr, hourExpr].some(e => e.includes("/"));
+    // Every X minutes/hours
+    if (minExpr.includes("/") && hourExpr === "*" && dayExpr === "*" && monthExpr === "*" && weekdayExpr === "*") {
+        const step = minExpr.split("/")[1];
+        return `Every ${step} min`;
+    }
+    if (hourExpr.includes("/") && dayExpr === "*" && monthExpr === "*" && weekdayExpr === "*") {
+        const step = hourExpr.split("/")[1];
+        return `Every ${step}h`;
+    }
+    // Build description
+    const descParts = [];
+    // Weekday specific
+    if (weekdayExpr !== "*") {
+        const days = expandField(weekdayExpr, weekdayNames);
+        if (weekdayExpr === "1-5")
+            descParts.push("Weekdays");
+        else if (weekdayExpr === "0,6" || weekdayExpr === "6,0")
+            descParts.push("Weekends");
+        else
+            descParts.push(`Every ${days}`);
+    }
+    // Day of month specific
+    else if (dayExpr !== "*") {
+        const dayList = expandField(dayExpr);
+        if (monthExpr !== "*") {
+            const monthList = expandField(monthExpr, monthNames);
+            descParts.push(`On the ${dayList}. of ${monthList}`);
+        }
+        else {
+            descParts.push(`On the ${dayList}. of every month`);
+        }
+    }
+    // Month specific only
+    else if (monthExpr !== "*") {
+        const monthList = expandField(monthExpr, monthNames);
+        descParts.push(`In ${monthList}`);
+    }
+    // Daily (all wildcards except time)
+    else if (!hasStep) {
+        descParts.push("Daily");
+    }
+    if (time && !hasStep)
+        descParts.push(time);
+    return descParts.join(", ") || schedule;
+}
+/**
+ * Format next run time as human-readable.
+ */
+export function formatNextRun(nextRunAt) {
+    if (!nextRunAt)
+        return "—";
+    const diff = nextRunAt - Date.now();
+    if (diff < 0)
+        return "overdue";
+    if (diff < 60_000)
+        return `in ${Math.round(diff / 1000)}s`;
+    if (diff < 3_600_000)
+        return `in ${Math.round(diff / 60_000)} Min`;
+    if (diff < 86_400_000)
+        return `in ${(diff / 3_600_000).toFixed(1)}h`;
+    return `in ${(diff / 86_400_000).toFixed(1)} days`;
+}