@pasko70/pibo 1.1.0 → 1.3.0

package/dist/cron/schedule.js

@@ -0,0 +1,214 @@
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+export function validateSchedule(schedule) {
+    switch (schedule.kind) {
+        case "at": {
+            const date = new Date(schedule.at);
+            if (Number.isNaN(date.getTime()))
+                throw new Error("schedule.at must be a valid date");
+            return;
+        }
+        case "every":
+            if (!Number.isFinite(schedule.everyMs) || schedule.everyMs < MINUTE_MS)
+                throw new Error("schedule.everyMs must be at least one minute");
+            if (schedule.anchorMs !== undefined && !Number.isFinite(schedule.anchorMs))
+                throw new Error("schedule.anchorMs must be finite");
+            return;
+        case "cron":
+            parseCron(schedule.expr);
+            if (schedule.tz)
+                validateTimeZone(schedule.tz);
+            return;
+    }
+}
+export function computeNextRunAt(schedule, now = new Date()) {
+    validateSchedule(schedule);
+    switch (schedule.kind) {
+        case "at": {
+            const at = new Date(schedule.at);
+            return at.getTime() > now.getTime() ? at : undefined;
+        }
+        case "every": {
+            const anchor = schedule.anchorMs ?? 0;
+            const elapsed = now.getTime() - anchor;
+            const steps = Math.floor(elapsed / schedule.everyMs) + 1;
+            return new Date(anchor + Math.max(1, steps) * schedule.everyMs);
+        }
+        case "cron":
+            return computeNextCronRunAt(schedule.expr, now, schedule.tz);
+    }
+}
+export function parseFriendlySchedule(input, now = new Date()) {
+    switch (input.kind) {
+        case "in": {
+            const everyMs = parseDurationMs(input.value);
+            const unit = uiUnit(everyMs);
+            const schedule = { kind: "at", at: new Date(now.getTime() + everyMs).toISOString() };
+            return { schedule, scheduleUi: { preset: "in", amount: amountForUnit(everyMs, unit), unit } };
+        }
+        case "at":
+            return { schedule: { kind: "at", at: new Date(input.value).toISOString() }, scheduleUi: { preset: "at", localDateTime: input.value, tz: input.tz } };
+        case "every": {
+            const everyMs = parseDurationMs(input.value);
+            const unit = uiUnit(everyMs);
+            return { schedule: { kind: "every", everyMs, anchorMs: now.getTime() }, scheduleUi: { preset: "every", amount: amountForUnit(everyMs, unit), unit } };
+        }
+        case "daily": {
+            const { hour, minute } = parseTime(input.time);
+            return { schedule: { kind: "cron", expr: `${minute} ${hour} * * *`, tz: input.tz }, scheduleUi: { preset: "daily", time: input.time, tz: input.tz } };
+        }
+        case "weekly": {
+            const { hour, minute } = parseTime(input.time);
+            const weekdays = Array.isArray(input.weekdays) ? input.weekdays : parseWeekdays(input.weekdays);
+            return { schedule: { kind: "cron", expr: `${minute} ${hour} * * ${weekdays.join(",")}`, tz: input.tz }, scheduleUi: { preset: "weekly", weekdays, time: input.time, tz: input.tz } };
+        }
+        case "monthly": {
+            const { hour, minute } = parseTime(input.time);
+            if (!Number.isInteger(input.dayOfMonth) || input.dayOfMonth < 1 || input.dayOfMonth > 31)
+                throw new Error("monthly day must be between 1 and 31");
+            return { schedule: { kind: "cron", expr: `${minute} ${hour} ${input.dayOfMonth} * *`, tz: input.tz }, scheduleUi: { preset: "monthly", dayOfMonth: input.dayOfMonth, time: input.time, tz: input.tz } };
+        }
+        case "cron":
+            return { schedule: { kind: "cron", expr: input.expr, tz: input.tz }, scheduleUi: { preset: "advanced", expr: input.expr, tz: input.tz } };
+    }
+}
+export function formatSchedule(schedule, scheduleUi) {
+    if (scheduleUi) {
+        switch (scheduleUi.preset) {
+            case "in": return `in ${scheduleUi.amount} ${scheduleUi.unit}`;
+            case "at": return `at ${scheduleUi.localDateTime}`;
+            case "every": return `every ${scheduleUi.amount} ${scheduleUi.unit}`;
+            case "daily": return `daily at ${scheduleUi.time}`;
+            case "weekly": return `weekly ${scheduleUi.weekdays.join(",")} at ${scheduleUi.time}`;
+            case "monthly": return `monthly on day ${scheduleUi.dayOfMonth} at ${scheduleUi.time}`;
+            case "advanced": return `cron ${scheduleUi.expr}`;
+        }
+    }
+    if (schedule.kind === "at")
+        return `at ${schedule.at}`;
+    if (schedule.kind === "every")
+        return `every ${formatDuration(schedule.everyMs)}`;
+    return `cron ${schedule.expr}${schedule.tz ? ` (${schedule.tz})` : ""}`;
+}
+export function parseDurationMs(value) {
+    const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(m|min|minute|minutes|h|hr|hour|hours|d|day|days)$/i);
+    if (!match)
+        throw new Error("Duration must look like 20m, 2h, or 1d");
+    const amount = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const ms = unit.startsWith("m") ? amount * MINUTE_MS : unit.startsWith("h") ? amount * HOUR_MS : amount * DAY_MS;
+    if (!Number.isFinite(ms) || ms < MINUTE_MS)
+        throw new Error("Duration must be at least one minute");
+    return Math.round(ms);
+}
+function formatDuration(ms) {
+    if (ms % DAY_MS === 0)
+        return `${ms / DAY_MS}d`;
+    if (ms % HOUR_MS === 0)
+        return `${ms / HOUR_MS}h`;
+    return `${Math.round(ms / MINUTE_MS)}m`;
+}
+function uiUnit(ms) {
+    if (ms % DAY_MS === 0)
+        return "days";
+    if (ms % HOUR_MS === 0)
+        return "hours";
+    return "minutes";
+}
+function amountForUnit(ms, unit) {
+    return unit === "days" ? ms / DAY_MS : unit === "hours" ? ms / HOUR_MS : ms / MINUTE_MS;
+}
+function parseTime(value) {
+    const match = value.trim().match(/^(\d{1,2}):(\d{2})$/);
+    if (!match)
+        throw new Error("Time must use HH:MM");
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+        throw new Error("Time is out of range");
+    return { hour, minute };
+}
+function parseWeekdays(value) {
+    const names = new Map([["sun", 0], ["mon", 1], ["tue", 2], ["wed", 3], ["thu", 4], ["fri", 5], ["sat", 6]]);
+    const days = value.split(",").map((part) => {
+        const text = part.trim().toLowerCase();
+        const numeric = Number(text);
+        const day = Number.isInteger(numeric) ? numeric : names.get(text.slice(0, 3));
+        if (day === undefined || day < 0 || day > 6)
+            throw new Error(`Invalid weekday: ${part}`);
+        return day;
+    });
+    if (days.length === 0)
+        throw new Error("At least one weekday is required");
+    return [...new Set(days)].sort();
+}
+function parseCron(expr) {
+    const fields = expr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        throw new Error("Cron expression must have 5 fields: minute hour day month weekday");
+    return {
+        minutes: parseCronField(fields[0], 0, 59, "minute"),
+        hours: parseCronField(fields[1], 0, 23, "hour"),
+        days: parseCronField(fields[2], 1, 31, "day"),
+        months: parseCronField(fields[3], 1, 12, "month"),
+        weekdays: parseCronField(fields[4], 0, 7, "weekday", (value) => value === 7 ? 0 : value),
+    };
+}
+function parseCronField(field, min, max, label, mapValue = (value) => value) {
+    const values = new Set();
+    for (const part of field.split(",")) {
+        const [rangePart, stepPart] = part.split("/");
+        const step = stepPart === undefined ? 1 : Number(stepPart);
+        if (!Number.isInteger(step) || step < 1)
+            throw new Error(`Invalid ${label} step`);
+        let start;
+        let end;
+        if (rangePart === "*") {
+            start = min;
+            end = max;
+        }
+        else if (rangePart.includes("-")) {
+            const [left, right] = rangePart.split("-").map(Number);
+            start = left;
+            end = right;
+        }
+        else {
+            start = Number(rangePart);
+            end = start;
+        }
+        if (!Number.isInteger(start) || !Number.isInteger(end) || start < min || end > max || start > end)
+            throw new Error(`Invalid ${label} field`);
+        for (let value = start; value <= end; value += step)
+            values.add(mapValue(value));
+    }
+    return values;
+}
+function computeNextCronRunAt(expr, now, tz) {
+    const spec = parseCron(expr);
+    const start = new Date(Math.floor(now.getTime() / MINUTE_MS) * MINUTE_MS + MINUTE_MS);
+    const max = start.getTime() + 5 * 366 * DAY_MS;
+    for (let time = start.getTime(); time <= max; time += MINUTE_MS) {
+        const date = new Date(time);
+        const parts = cronDateParts(date, tz);
+        if (spec.minutes.has(parts.minute) && spec.hours.has(parts.hour) && spec.days.has(parts.day) && spec.months.has(parts.month) && spec.weekdays.has(parts.weekday))
+            return date;
+    }
+    return undefined;
+}
+function cronDateParts(date, tz) {
+    if (!tz)
+        return { minute: date.getMinutes(), hour: date.getHours(), day: date.getDate(), month: date.getMonth() + 1, weekday: date.getDay() };
+    const parts = new Intl.DateTimeFormat("en-US", { timeZone: tz, minute: "numeric", hour: "numeric", day: "numeric", month: "numeric", weekday: "short", hour12: false }).formatToParts(date);
+    const get = (type) => Number(parts.find((part) => part.type === type)?.value);
+    const weekdays = new Map([["Sun", 0], ["Mon", 1], ["Tue", 2], ["Wed", 3], ["Thu", 4], ["Fri", 5], ["Sat", 6]]);
+    return { minute: get("minute"), hour: get("hour") % 24, day: get("day"), month: get("month"), weekday: weekdays.get(parts.find((part) => part.type === "weekday")?.value ?? "") ?? 0 };
+}
+function validateTimeZone(tz) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: tz }).format(new Date());
+    }
+    catch {
+        throw new Error(`Invalid timezone: ${tz}`);
+    }
+}

package/dist/cron/service.js

@@ -0,0 +1,177 @@
+import { randomUUID } from "node:crypto";
+import { getDefaultPiboWorkspace } from "../core/workspace.js";
+import { PiboDataStore } from "../data/pibo-store.js";
+import { ChatRoomService } from "../apps/chat/data/room-service.js";
+import { isPiboRoomArchived } from "../apps/chat/types/rooms.js";
+import { formatSchedule } from "./schedule.js";
+import { createDefaultPiboCronStore } from "./store.js";
+const CHAT_WEB_CHANNEL = "pibo.chat-web";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function buildCronPrompt(job) {
+    return [
+        "You are running a scheduled Pibo job.",
+        `Job: ${job.name}`,
+        `Schedule: ${formatSchedule(job.schedule, job.scheduleUi)}`,
+        `Target: ${job.target.kind}`,
+        "",
+        "Complete the scheduled task below. Return the result in this session. Do not create another cron job unless the original task explicitly asks for it.",
+        "",
+        "Task:",
+        job.prompt,
+    ].join("\n");
+}
+export class PiboCronService {
+    options;
+    store;
+    dataStore;
+    roomService;
+    intervalMs;
+    maxConcurrentRuns;
+    runTimeoutMs;
+    timer;
+    activeRuns = 0;
+    stopped = true;
+    constructor(options) {
+        this.options = options;
+        this.store = options.store ?? createDefaultPiboCronStore();
+        this.dataStore = new PiboDataStore(options.dataStorePath, { payloadRootDir: options.dataPayloadRootDir });
+        this.roomService = new ChatRoomService(this.dataStore);
+        this.intervalMs = options.intervalMs ?? 60_000;
+        this.maxConcurrentRuns = Math.max(1, options.maxConcurrentRuns ?? 2);
+        this.runTimeoutMs = options.runTimeoutMs ?? 30 * 60_000;
+    }
+    start() {
+        if (!this.stopped)
+            return;
+        this.stopped = false;
+        this.store.recoverInterruptedRuns();
+        this.arm(1000);
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        this.dataStore.close();
+        this.store.close();
+    }
+    status() {
+        return { enabled: !this.stopped, ...this.store.status() };
+    }
+    async runJobNow(id) {
+        const reserved = this.store.reserveManualRun(id);
+        if (!reserved)
+            throw new Error("Cron job not found");
+        void this.executeReserved(reserved.job, reserved.run).finally(() => this.armSoon());
+        return reserved.run;
+    }
+    arm(delayMs) {
+        if (this.stopped)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        const status = this.store.status();
+        const nextDelay = status.nextRunAt ? Math.max(1000, new Date(status.nextRunAt).getTime() - Date.now()) : this.intervalMs;
+        this.timer = setTimeout(() => void this.tick(), Math.min(delayMs ?? nextDelay, this.intervalMs));
+    }
+    armSoon() {
+        this.arm(1000);
+    }
+    async tick() {
+        if (this.stopped)
+            return;
+        try {
+            const capacity = this.maxConcurrentRuns - this.activeRuns;
+            if (capacity > 0) {
+                const due = this.store.reserveDueRuns(capacity);
+                for (const { job, run } of due)
+                    void this.executeReserved(job, run).finally(() => this.armSoon());
+            }
+        }
+        catch (error) {
+            console.error("[cron] scheduler tick failed", error);
+        }
+        finally {
+            this.arm();
+        }
+    }
+    async executeReserved(job, run) {
+        this.activeRuns += 1;
+        try {
+            const piboSessionId = await this.executeJob(job, run);
+            this.store.completeRun({ jobId: job.id, runId: run.id, status: "ok", piboSessionId });
+        }
+        catch (error) {
+            this.store.completeRun({ jobId: job.id, runId: run.id, status: "error", error: errorMessage(error) });
+            console.error(`[cron] job ${job.id} failed`, error);
+        }
+        finally {
+            this.activeRuns -= 1;
+        }
+    }
+    async executeJob(job, run) {
+        const target = this.resolveTarget(job);
+        const session = this.options.context.createSession({
+            channel: CHAT_WEB_CHANNEL,
+            kind: "cron",
+            profile: job.profile,
+            workspace: target.workspace ?? getDefaultPiboWorkspace(),
+            title: job.name,
+            metadata: {
+                ...(target.metadata ?? {}),
+                chatRoomId: target.roomId,
+                cronJobId: job.id,
+                cronRunId: run.id,
+                cronTargetKind: job.target.kind,
+            },
+        });
+        await this.emitMessageAndWait(session.id, buildCronPrompt(job));
+        return session.id;
+    }
+    resolveTarget(job) {
+        if (job.target.kind === "room") {
+            const room = this.roomService.getRoom(job.target.roomId);
+            if (!room)
+                throw new Error("Target room no longer exists");
+            if (isPiboRoomArchived(room))
+                throw new Error("Target room is archived");
+            return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() };
+        }
+        const room = this.roomService.ensureDefaultRoom({ name: "Shared Chat" });
+        return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() };
+    }
+    async emitMessageAndWait(piboSessionId, text) {
+        const eventId = `cron_msg_${randomUUID()}`;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let unsubscribe;
+            const timeout = setTimeout(() => {
+                finish(new Error("Cron run timed out"));
+            }, this.runTimeoutMs);
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                unsubscribe?.();
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            unsubscribe = this.options.context.subscribe((event) => {
+                if (event.piboSessionId !== piboSessionId)
+                    return;
+                if ("eventId" in event && event.eventId !== eventId)
+                    return;
+                if (event.type === "message_finished")
+                    finish();
+                if (event.type === "session_error")
+                    finish(new Error(event.error));
+            });
+            this.options.context.emit({ type: "message", piboSessionId, id: eventId, source: "service", text }).catch((error) => finish(error instanceof Error ? error : new Error(String(error))));
+        });
+    }
+}