minimal-agent 0.8.2 → 0.10.0

package/plugins/cron-runner/src/cronTime.js

@@ -0,0 +1,148 @@
+const FIELD_RANGES = [
+    { min: 0, max: 59 },
+    { min: 0, max: 23 },
+    { min: 1, max: 31 },
+    { min: 1, max: 12 },
+    { min: 0, max: 6 },
+];
+function expandField(field, min, max) {
+    const out = new Set();
+    for (const raw of field.split(',')) {
+        const part = raw.trim();
+        const stepMatch = part.match(/^\*(?:\/(\d+))?$/);
+        if (stepMatch) {
+            const step = stepMatch[1] ? Number.parseInt(stepMatch[1], 10) : 1;
+            if (step < 1)
+                return null;
+            for (let i = min; i <= max; i += step)
+                out.add(i);
+            continue;
+        }
+        const rangeMatch = part.match(/^(\d+)-(\d+)(?:\/(\d+))?$/);
+        if (rangeMatch) {
+            const lo = Number.parseInt(rangeMatch[1], 10);
+            const hi = Number.parseInt(rangeMatch[2], 10);
+            const step = rangeMatch[3] ? Number.parseInt(rangeMatch[3], 10) : 1;
+            const isDow = min === 0 && max === 6;
+            const effMax = isDow ? 7 : max;
+            if (lo > hi || step < 1 || lo < min || hi > effMax)
+                return null;
+            for (let i = lo; i <= hi; i += step)
+                out.add(isDow && i === 7 ? 0 : i);
+            continue;
+        }
+        if (/^\d+$/.test(part)) {
+            let n = Number.parseInt(part, 10);
+            if (min === 0 && max === 6 && n === 7)
+                n = 0;
+            if (n < min || n > max)
+                return null;
+            out.add(n);
+            continue;
+        }
+        return null;
+    }
+    return out.size > 0 ? Array.from(out).sort((a, b) => a - b) : null;
+}
+export function parseCronExpression(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const expanded = parts.map((p, i) => expandField(p, FIELD_RANGES[i].min, FIELD_RANGES[i].max));
+    if (expanded.some((v) => v === null))
+        return null;
+    return {
+        minute: expanded[0],
+        hour: expanded[1],
+        dayOfMonth: expanded[2],
+        month: expanded[3],
+        dayOfWeek: expanded[4],
+    };
+}
+export function nextCronRunMs(cron, fromMs = Date.now()) {
+    const fields = parseCronExpression(cron);
+    if (!fields)
+        return null;
+    const next = computeNextCronRun(fields, new Date(fromMs));
+    return next ? next.getTime() : null;
+}
+export function computeNextCronRun(fields, from) {
+    const t = new Date(from.getTime());
+    t.setSeconds(0, 0);
+    t.setMinutes(t.getMinutes() + 1);
+    for (let i = 0; i < 366 * 24 * 60; i++) {
+        if (cronFieldsMatchDate(fields, t)) {
+            return new Date(t.getTime());
+        }
+        t.setMinutes(t.getMinutes() + 1);
+    }
+    return null;
+}
+export function cronFieldsMatchDate(fields, date) {
+    const domMatches = fields.dayOfMonth.includes(date.getDate());
+    const dowMatches = fields.dayOfWeek.includes(date.getDay());
+    const domWild = fields.dayOfMonth.length === 31;
+    const dowWild = fields.dayOfWeek.length === 7;
+    const dayMatches = domWild && dowWild
+        ? true
+        : domWild
+            ? dowMatches
+            : dowWild
+                ? domMatches
+                : domMatches || dowMatches;
+    return (fields.month.includes(date.getMonth() + 1) &&
+        dayMatches &&
+        fields.hour.includes(date.getHours()) &&
+        fields.minute.includes(date.getMinutes()));
+}
+export function cronToHuman(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return cron;
+    const [minute, hour, dom, month, dow] = parts;
+    if (minute === '*' && hour === '*' && dom === '*' && month === '*' && dow === '*') {
+        return '每分钟'; // 全通配 = 每分钟一次（否则会掉进下面「每天 * *」的无意义分支）
+    }
+    const time = /^\d+$/.test(minute) && /^\d+$/.test(hour)
+        ? `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`
+        : `${minute} ${hour}`;
+    if (/^\d+$/.test(minute) && hour === '*')
+        return `每小时 ${minute.padStart(2, '0')} 分`;
+    const hourStep = hour.match(/^\*\/(\d+)$/);
+    if (/^\d+$/.test(minute) && hourStep && dom === '*' && month === '*' && dow === '*') {
+        return `每 ${hourStep[1]} 小时 ${minute.padStart(2, '0')} 分`;
+    }
+    const minuteStep = minute.match(/^\*\/(\d+)$/);
+    if (minuteStep && hour === '*' && dom === '*' && month === '*' && dow === '*') {
+        return `每 ${minuteStep[1]} 分钟`;
+    }
+    if (dom === '*' && month === '*' && dow === '*')
+        return `每天 ${time}`;
+    if (dom === '*' && month === '*' && dow === '1-5')
+        return `工作日 ${time}`;
+    if (dom === '*' && month === '*' && dow)
+        return `每周 ${formatDow(dow)} ${time}`;
+    return cron;
+}
+export function formatDateTime(msOrIso) {
+    if (msOrIso === undefined)
+        return '-';
+    const d = typeof msOrIso === 'number' ? new Date(msOrIso) : new Date(msOrIso);
+    if (Number.isNaN(d.getTime()))
+        return '-';
+    return d.toLocaleString('zh-CN', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        weekday: 'short',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+function formatDow(dow) {
+    const names = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
+    const fields = parseCronExpression(`0 0 * * ${dow}`)?.dayOfWeek;
+    if (!fields)
+        return dow;
+    return fields.map((d) => names[d]).join('、');
+}

package/plugins/cron-runner/src/lock.js

@@ -0,0 +1,68 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export function schedulerLockFile(root) {
+    return join(root, 'scheduler.lock');
+}
+export async function tryAcquireSchedulerLock(file, owner) {
+    await mkdir(dirname(file), { recursive: true });
+    const lock = {
+        owner,
+        pid: process.pid,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+    if (await tryCreateExclusive(file, lock))
+        return true;
+    const existing = await readLock(file);
+    if (!existing)
+        return await tryCreateExclusive(file, lock);
+    if (existing.owner === owner) {
+        await writeFile(file, JSON.stringify({ ...existing, pid: process.pid, updatedAt: lock.updatedAt }, null, 2), 'utf8');
+        return true;
+    }
+    if (isPidAlive(existing.pid))
+        return false;
+    await rm(file, { force: true });
+    return await tryCreateExclusive(file, lock);
+}
+export async function releaseSchedulerLock(file, owner) {
+    const existing = await readLock(file);
+    if (!existing || existing.owner !== owner)
+        return;
+    await rm(file, { force: true });
+}
+async function tryCreateExclusive(file, lock) {
+    try {
+        await writeFile(file, JSON.stringify(lock, null, 2), { encoding: 'utf8', flag: 'wx' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readLock(file) {
+    try {
+        const parsed = JSON.parse(await readFile(file, 'utf8'));
+        if (typeof parsed.owner !== 'string' ||
+            typeof parsed.pid !== 'number' ||
+            typeof parsed.createdAt !== 'string' ||
+            typeof parsed.updatedAt !== 'string') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/plugins/cron-runner/src/runs.js

@@ -0,0 +1,89 @@
+import { existsSync } from 'node:fs';
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export async function appendRun(runsDir, record) {
+    await mkdir(runsDir, { recursive: true });
+    await appendFile(join(runsDir, `${record.taskId}.jsonl`), `${JSON.stringify(record)}\n`, 'utf8');
+}
+export async function recentRuns(runsDir, taskId, limit = 5) {
+    const file = join(runsDir, `${taskId}.jsonl`);
+    if (!existsSync(file))
+        return [];
+    try {
+        const raw = await readFile(file, 'utf8');
+        const byId = new Map();
+        for (const line of raw.trim().split('\n').filter(Boolean)) {
+            const record = JSON.parse(line);
+            byId.set(record.id, { ...(byId.get(record.id) ?? {}), ...record });
+        }
+        return Array.from(byId.values())
+            .sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt))
+            .slice(0, limit);
+    }
+    catch {
+        return [];
+    }
+}
+export async function markRunsRead(runsDir, taskId) {
+    if (!existsSync(runsDir))
+        return;
+    const now = new Date().toISOString();
+    const taskIds = taskId ? [taskId] : await listRunTaskIds(runsDir);
+    for (const id of taskIds) {
+        for (const run of await recentRuns(runsDir, id, Number.MAX_SAFE_INTEGER)) {
+            if (!run.readAt)
+                await appendRun(runsDir, { ...run, readAt: now });
+        }
+    }
+}
+async function listRunTaskIds(runsDir) {
+    const { readdir } = await import('node:fs/promises');
+    try {
+        return (await readdir(runsDir))
+            .filter((name) => name.endsWith('.jsonl'))
+            .map((name) => name.slice(0, -6));
+    }
+    catch {
+        return [];
+    }
+}
+export async function appendMissed(file, record) {
+    await mkdir(dirname(file), { recursive: true });
+    await appendFile(file, `${JSON.stringify(record)}\n`, 'utf8');
+}
+export async function listMissed(file, limit = 20) {
+    if (!existsSync(file))
+        return [];
+    try {
+        const raw = await readFile(file, 'utf8');
+        const bySlot = new Map();
+        for (const line of raw.trim().split('\n').filter(Boolean)) {
+            const parsed = JSON.parse(line);
+            const record = {
+                ...parsed,
+                reason: parsed.reason === 'overlap' || parsed.reason === 'binding_unavailable'
+                    ? parsed.reason
+                    : 'offline',
+                missedCount: typeof parsed.missedCount === 'number' && parsed.missedCount > 0
+                    ? parsed.missedCount
+                    : 1,
+            };
+            bySlot.set(`${record.taskId}:${record.scheduledFor}`, record);
+        }
+        return Array.from(bySlot.values())
+            .sort((a, b) => Date.parse(b.detectedAt) - Date.parse(a.detectedAt))
+            .slice(0, limit);
+    }
+    catch {
+        return [];
+    }
+}
+export async function markMissedRead(file, taskId) {
+    const records = await listMissed(file, Number.MAX_SAFE_INTEGER);
+    const now = new Date().toISOString();
+    for (const record of records) {
+        if (!record.readAt && (!taskId || record.taskId === taskId)) {
+            await appendMissed(file, { ...record, readAt: now });
+        }
+    }
+}

package/plugins/cron-runner/src/scheduleEngine.js

@@ -0,0 +1,72 @@
+import { cronFieldsMatchDate, nextCronRunMs, parseCronExpression } from './cronTime.js';
+export const MIN_INTERVAL_MS = 60_000;
+export function intervalToHuman(intervalMs) {
+    const units = [
+        { ms: 7 * 24 * 60 * 60_000, label: '周' },
+        { ms: 24 * 60 * 60_000, label: '天' },
+        { ms: 60 * 60_000, label: '小时' },
+        { ms: 60_000, label: '分钟' },
+    ];
+    for (const unit of units) {
+        if (intervalMs % unit.ms === 0)
+            return `每 ${intervalMs / unit.ms} ${unit.label}`;
+    }
+    return `每 ${Math.round(intervalMs / 60_000)} 分钟`;
+}
+/** Return the first wall-clock slot strictly after `fromMs`. */
+export function nextScheduleRunMs(schedule, fromMs) {
+    if (schedule.type === 'cron')
+        return nextCronRunMs(schedule.cron, fromMs);
+    const anchor = Date.parse(schedule.anchorAt);
+    if (!Number.isFinite(anchor) || schedule.intervalMs < MIN_INTERVAL_MS)
+        return null;
+    if (fromMs < anchor)
+        return anchor;
+    return anchor + (Math.floor((fromMs - anchor) / schedule.intervalMs) + 1) * schedule.intervalMs;
+}
+/** Return the latest slot at or before `atMs`. */
+export function latestScheduleRunMs(schedule, atMs) {
+    if (schedule.type === 'interval') {
+        const anchor = Date.parse(schedule.anchorAt);
+        if (!Number.isFinite(anchor) || atMs < anchor || schedule.intervalMs < MIN_INTERVAL_MS) {
+            return null;
+        }
+        return anchor + Math.floor((atMs - anchor) / schedule.intervalMs) * schedule.intervalMs;
+    }
+    const fields = parseCronExpression(schedule.cron);
+    if (!fields)
+        return null;
+    const cursor = new Date(atMs);
+    cursor.setSeconds(0, 0);
+    for (let i = 0; i < 366 * 24 * 60; i++) {
+        if (cronFieldsMatchDate(fields, cursor))
+            return cursor.getTime();
+        cursor.setMinutes(cursor.getMinutes() - 1);
+    }
+    return null;
+}
+export function countScheduleSlots(schedule, afterExclusiveMs, throughInclusiveMs) {
+    if (throughInclusiveMs <= afterExclusiveMs)
+        return 0;
+    if (schedule.type === 'interval') {
+        const first = nextScheduleRunMs(schedule, afterExclusiveMs);
+        if (!first || first > throughInclusiveMs)
+            return 0;
+        return Math.floor((throughInclusiveMs - first) / schedule.intervalMs) + 1;
+    }
+    let count = 0;
+    let cursor = afterExclusiveMs;
+    while (count < 10_000) {
+        const next = nextScheduleRunMs(schedule, cursor);
+        if (!next || next > throughInclusiveMs)
+            break;
+        count++;
+        cursor = next;
+    }
+    return count;
+}
+export function scheduleAnchorMs(schedule, createdAt) {
+    const value = schedule.type === 'interval' ? schedule.anchorAt : createdAt;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : Date.now();
+}