@minionry/minion 0.7.36

package/dist/server/services/schedule/quality-schedule-store.js

@@ -0,0 +1,211 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { writeFileAtomic } from '../../utils/file-store.js';
+import { spacePath } from '../space-layout.js';
+import { isValidDailyTiming, nextDailyFireAt, normalizeDailyTiming } from './daily-timing.js';
+import { computeNextFireAt, MAX_SCHEDULE_HISTORY, SCHEDULE_MIN_INTERVAL_MS, } from './schedule-store.js';
+export { MAX_SCHEDULE_HISTORY, SCHEDULE_MIN_INTERVAL_MS };
+export function isValidQualityScheduleTiming(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    const t = raw;
+    if (t.kind === 'interval')
+        return typeof t.everyMs === 'number' && Number.isFinite(t.everyMs) && t.everyMs > 0;
+    return isValidDailyTiming(raw);
+}
+export function qualityScheduleStorePath(workingDir) {
+    return spacePath(workingDir, 'quality', 'schedules.json');
+}
+function generateQualityScheduleId() {
+    return `qsched-${randomUUID().replace(/-/g, '').slice(0, 8)}`;
+}
+function clampTiming(timing) {
+    if (timing.kind === 'interval') {
+        return { kind: 'interval', everyMs: Math.max(timing.everyMs, SCHEDULE_MIN_INTERVAL_MS) };
+    }
+    return normalizeDailyTiming(timing) ?? timing;
+}
+export function computeQualityNextFireAt(timing, from) {
+    if (timing.kind === 'daily')
+        return nextDailyFireAt(timing, from);
+    return computeNextFireAt(timing, from) ?? new Date(from.getTime() + Math.max(timing.everyMs, SCHEDULE_MIN_INTERVAL_MS)).toISOString();
+}
+function isScheduleFireStatus(value) {
+    return (value === 'started' ||
+        value === 'completed' ||
+        value === 'failed' ||
+        value === 'skipped-overlap' ||
+        value === 'missed');
+}
+function normalizeTiming(raw) {
+    if (!isValidQualityScheduleTiming(raw))
+        return null;
+    return clampTiming(raw);
+}
+function normalizeInitiator(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const i = raw;
+    if (typeof i.appId !== 'string' || !i.appId || typeof i.origin !== 'string' || !i.origin)
+        return undefined;
+    return { appId: i.appId, origin: i.origin };
+}
+function normalizeHistoryEntry(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const e = raw;
+    if (typeof e.at !== 'string')
+        return null;
+    if (!isScheduleFireStatus(e.status))
+        return null;
+    const entry = { at: e.at, status: e.status };
+    if (typeof e.error === 'string')
+        entry.error = e.error;
+    return entry;
+}
+function normalizeLastFire(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const l = raw;
+    if (typeof l.at !== 'string')
+        return undefined;
+    if (!isScheduleFireStatus(l.status))
+        return undefined;
+    return { at: l.at, status: l.status };
+}
+function normalizeQualityScheduleRecord(raw, now) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    if (typeof r.id !== 'string' || !r.id)
+        return null;
+    if (typeof r.path !== 'string' || !r.path)
+        return null;
+    const timing = normalizeTiming(r.timing);
+    if (!timing)
+        return null;
+    const enabled = typeof r.enabled === 'boolean' ? r.enabled : true;
+    const history = Array.isArray(r.history)
+        ? r.history.map(normalizeHistoryEntry).filter((e) => e !== null)
+        : [];
+    const storedNext = typeof r.nextFireAt === 'string' && Number.isFinite(Date.parse(r.nextFireAt)) ? r.nextFireAt : null;
+    return {
+        ...r,
+        id: r.id,
+        createdAt: typeof r.createdAt === 'string' ? r.createdAt : now.toISOString(),
+        name: typeof r.name === 'string' ? r.name : undefined,
+        path: r.path,
+        timing,
+        enabled,
+        nextFireAt: enabled ? (storedNext ?? computeQualityNextFireAt(timing, now)) : null,
+        lastFire: normalizeLastFire(r.lastFire),
+        history,
+        initiator: normalizeInitiator(r.initiator),
+    };
+}
+export class QualityScheduleStore {
+    schedulesPath;
+    data;
+    constructor(workingDir) {
+        this.schedulesPath = qualityScheduleStorePath(workingDir);
+        this.data = this.load();
+    }
+    load() {
+        try {
+            if (existsSync(this.schedulesPath)) {
+                const raw = JSON.parse(readFileSync(this.schedulesPath, 'utf-8'));
+                const rawSchedules = Array.isArray(raw?.schedules) ? raw.schedules : [];
+                const now = new Date();
+                const schedules = rawSchedules
+                    .map((s) => normalizeQualityScheduleRecord(s, now))
+                    .filter((s) => s !== null);
+                return { version: 1, schedules };
+            }
+        }
+        catch (error) {
+            console.error('[QualityScheduleStore] Error loading schedules:', error);
+        }
+        return { version: 1, schedules: [] };
+    }
+    save() {
+        try {
+            writeFileAtomic(this.schedulesPath, JSON.stringify(this.data, null, 2));
+        }
+        catch (error) {
+            console.error('[QualityScheduleStore] Error saving schedules:', error);
+        }
+    }
+    list() {
+        return this.data.schedules.map((s) => ({ ...s }));
+    }
+    get(id) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        return record ? { ...record } : undefined;
+    }
+    create(fields) {
+        const now = new Date();
+        const timing = clampTiming(fields.timing);
+        const enabled = fields.enabled ?? true;
+        const record = {
+            id: generateQualityScheduleId(),
+            createdAt: now.toISOString(),
+            name: fields.name,
+            path: fields.path,
+            timing,
+            enabled,
+            nextFireAt: enabled ? computeQualityNextFireAt(timing, now) : null,
+            history: [],
+            initiator: fields.initiator,
+        };
+        this.data.schedules.push(record);
+        this.save();
+        return { ...record };
+    }
+    update(id, patch) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        const now = new Date();
+        if (patch.name !== undefined)
+            record.name = patch.name;
+        let replan = false;
+        if (patch.timing !== undefined) {
+            record.timing = clampTiming(patch.timing);
+            replan = true;
+        }
+        if (patch.enabled !== undefined && patch.enabled !== record.enabled) {
+            record.enabled = patch.enabled;
+            replan = true;
+        }
+        if (replan)
+            record.nextFireAt = record.enabled ? computeQualityNextFireAt(record.timing, now) : null;
+        this.save();
+        return { ...record };
+    }
+    delete(id) {
+        const index = this.data.schedules.findIndex((s) => s.id === id);
+        if (index === -1)
+            return false;
+        this.data.schedules.splice(index, 1);
+        this.save();
+        return true;
+    }
+    setEnabled(id, enabled) {
+        return this.update(id, { enabled });
+    }
+    recordFire(id, entry, nextFireAt) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        record.history.push(entry);
+        if (record.history.length > MAX_SCHEDULE_HISTORY) {
+            record.history.splice(0, record.history.length - MAX_SCHEDULE_HISTORY);
+        }
+        record.lastFire = { at: entry.at, status: entry.status };
+        record.nextFireAt = nextFireAt;
+        this.save();
+        return { ...record };
+    }
+}

package/dist/server/services/schedule/quality-scheduler.js

@@ -0,0 +1,215 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { isQualityPathBusy, launchScheduledQualityRun, } from './quality-schedule-launch.js';
+import { computeQualityNextFireAt, QualityScheduleStore } from './quality-schedule-store.js';
+export const QUALITY_SCHEDULER_TICK_MS = 30_000;
+export class QualityScheduledRunRegistry {
+    runs = new Map();
+    get(scheduleId) {
+        return this.runs.get(scheduleId);
+    }
+    has(scheduleId) {
+        return this.runs.has(scheduleId);
+    }
+    set(scheduleId, run) {
+        this.runs.set(scheduleId, run);
+    }
+    delete(scheduleId) {
+        this.runs.delete(scheduleId);
+    }
+    activeIds() {
+        return Array.from(this.runs.keys());
+    }
+    snapshotValues() {
+        return Array.from(this.runs.values());
+    }
+    reset() {
+        for (const run of this.runs.values())
+            run.settled = true;
+        this.runs.clear();
+    }
+}
+let moduleDefaults = {};
+export function setQualitySchedulerDefaults(deps) {
+    moduleDefaults = { ...moduleDefaults, ...deps };
+}
+export function resetQualitySchedulerDefaults() {
+    moduleDefaults = {};
+}
+export class QualitySchedulerEngine {
+    workingDir;
+    runs = new QualityScheduledRunRegistry();
+    deps;
+    tickIntervalMs;
+    timer = null;
+    store = null;
+    constructor(workingDir, deps = {}) {
+        this.workingDir = workingDir;
+        this.deps = deps;
+        this.tickIntervalMs = deps.tickIntervalMs ?? QUALITY_SCHEDULER_TICK_MS;
+    }
+    getStore() {
+        return this.store;
+    }
+    isRunning() {
+        return this.timer !== null;
+    }
+    start() {
+        if (this.timer)
+            return;
+        if (!this.workingDir)
+            return;
+        this.store = new QualityScheduleStore(this.workingDir);
+        this.tick();
+        this.timer = setInterval(() => this.tick(), this.tickIntervalMs);
+        if (typeof this.timer.unref === 'function')
+            this.timer.unref();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.runs.reset();
+        this.store = null;
+    }
+    tick() {
+        const store = this.store;
+        if (!store)
+            return;
+        this.reapFinishedRuns();
+        const now = Date.now();
+        for (const record of store.list()) {
+            if (!record.enabled)
+                continue;
+            if (!this.isDue(record, now))
+                continue;
+            if (this.runs.has(record.id) || this.isPathBusy(record.path)) {
+                this.recordSkippedOverlap(record, now);
+                continue;
+            }
+            this.fire(record, now);
+        }
+    }
+    isDue(record, now) {
+        if (!record.nextFireAt)
+            return record.timing.kind === 'interval';
+        const at = Date.parse(record.nextFireAt);
+        return Number.isFinite(at) && at <= now;
+    }
+    isPathBusy(path) {
+        return (this.deps.isPathBusy ?? isQualityPathBusy)(this.workingDir, path);
+    }
+    reapFinishedRuns() {
+        for (const run of this.runs.snapshotValues()) {
+            if (run.settled)
+                continue;
+            if (run.handle.isActive())
+                continue;
+            this.settle(run);
+        }
+    }
+    fire(record, now) {
+        const store = this.store;
+        if (!store)
+            return;
+        const firedAt = new Date(now).toISOString();
+        let handle;
+        try {
+            handle = (this.deps.launch ?? launchScheduledQualityRun)(this.workingDir, {
+                id: record.id,
+                path: record.path,
+                ...(record.initiator ? { initiator: record.initiator } : {}),
+            });
+        }
+        catch (error) {
+            this.recordFailedFire(record, firedAt, errorMessage(error));
+            return;
+        }
+        store.recordFire(record.id, { at: firedAt, status: 'started' }, this.nextFireAtAfter(record, now));
+        const run = { scheduleId: record.id, handle, startedAt: now, lastError: null, settled: false };
+        this.runs.set(record.id, run);
+        this.notify();
+        handle.onSettle((error) => {
+            run.lastError = error;
+            this.settle(run);
+        });
+    }
+    settle(run) {
+        if (run.settled)
+            return;
+        run.settled = true;
+        this.runs.delete(run.scheduleId);
+        const store = this.store;
+        const record = store?.get(run.scheduleId);
+        if (!store || !record)
+            return;
+        const now = Date.now();
+        store.recordFire(run.scheduleId, {
+            at: new Date(now).toISOString(),
+            status: run.lastError ? 'failed' : 'completed',
+            ...(run.lastError ? { error: run.lastError } : {}),
+        }, 
+        record.nextFireAt ?? this.nextFireAtAfter(record, now));
+        this.notify();
+    }
+    recordFailedFire(record, firedAt, error) {
+        const store = this.store;
+        if (!store)
+            return;
+        store.recordFire(record.id, { at: firedAt, status: 'failed', error }, this.nextFireAtAfter(record, Date.parse(firedAt)));
+        this.notify();
+    }
+    recordSkippedOverlap(record, now) {
+        const store = this.store;
+        if (!store)
+            return;
+        store.recordFire(record.id, {
+            at: new Date(now).toISOString(),
+            status: 'skipped-overlap',
+            error: 'a quality operation for this directory is already in progress',
+        }, this.nextFireAtAfter(record, now));
+        this.notify();
+    }
+    nextFireAtAfter(record, now) {
+        return computeQualityNextFireAt(record.timing, new Date(now));
+    }
+    notify() {
+        const store = this.store;
+        if (!store)
+            return;
+        const onChanged = this.deps.onChanged ?? moduleDefaults.onChanged;
+        if (!onChanged)
+            return;
+        try {
+            onChanged(this.workingDir, store.list());
+        }
+        catch (error) {
+            console.error('[QualityScheduler] onChanged listener failed:', error);
+        }
+    }
+}
+export const qualitySchedulerCache = new Map();
+function errorMessage(error) {
+    if (typeof error === 'string')
+        return error;
+    return error instanceof Error ? error.message : String(error);
+}
+export function getQualityScheduler(workingDir, deps) {
+    let engine = qualitySchedulerCache.get(workingDir);
+    if (!engine) {
+        engine = new QualitySchedulerEngine(workingDir, deps);
+        qualitySchedulerCache.set(workingDir, engine);
+    }
+    return engine;
+}
+export function stopAllQualitySchedulers() {
+    for (const engine of qualitySchedulerCache.values()) {
+        try {
+            engine.stop();
+        }
+        catch {
+        }
+    }
+    qualitySchedulerCache.clear();
+}