loopengine 0.1.92 → 0.1.94

package/dist/core/scheduler.js

@@ -10,13 +10,21 @@
 // next tick.
 //
 // `every` is anchored: an hourly task created at 10:07 keeps firing at
-// :07, however long each run takes. A run missed while the server was
-// down fires once when it's back, then the schedule moves to the next
-// future slot (no burst of catch-up runs).
+// :07, however long each run takes. `start_at` sets the anchor instead,
+// for "daily at 9:00" ("1d" from a 9:00 start) or "Mondays at 9:00" ("7d"
+// from a Monday), or `at` ("09:00", plus a `weekday` for "7d") works the
+// start out in the workspace's time zone (core/time-zone.ts). Intervals
+// in days are calendar days in the time zone the task was made in, so a
+// daily 9:00 task stays at 9:00 when the clocks change; shorter ones are
+// exact durations. Timestamps without an offset are read in the
+// workspace's time zone too. A run missed while the server was down fires
+// once when it's back, then the schedule moves to the next future slot
+// (no burst of catch-up runs).
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { KeyedMutex } from './session-store.js';
+import { addCalendarDays, instantOf, nextTimeOfDay, parseTimeOfDay, parseTimestamp, wallTimeAt, workspaceTimeZone } from './time-zone.js';
 const HISTORY_LIMIT = 20;
 const EVERY_PATTERN = /^(\d+)\s*(s|m|h|d)$/;
 const EVERY_UNIT_MS = { s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 };
@@ -33,11 +41,38 @@ export function parseEvery(every) {
         throw new ScheduleError(`"${every}" is too short — the shortest interval is 30s`);
     return ms;
 }
-/** The first anchored slot strictly after `nowMs`. */
-function nextAnchoredSlot(anchorMs, intervalMs, nowMs) {
+/** Whole days in an interval ("2d" → 2), or undefined for one in s/m/h. */
+function everyDays(every) {
+    const match = EVERY_PATTERN.exec(every.trim());
+    return match && match[2] === 'd' ? Number(match[1]) : undefined;
+}
+/** The first anchored slot strictly after `nowMs`: exact steps of
+ * `intervalMs`, or with `days` and `timeZone`, steps of that many
+ * calendar days there. */
+function nextAnchoredSlot(anchorMs, intervalMs, nowMs, calendar) {
     if (nowMs < anchorMs)
         return anchorMs;
-    return anchorMs + (Math.floor((nowMs - anchorMs) / intervalMs) + 1) * intervalMs;
+    let k = Math.floor((nowMs - anchorMs) / intervalMs) + 1;
+    if (!calendar)
+        return anchorMs + k * intervalMs;
+    // A day is 23 to 25 hours, so the estimate can be one step off.
+    const slot = (n) => addCalendarDays(anchorMs, n * calendar.days, calendar.timeZone);
+    while (k > 1 && slot(k - 1) > nowMs)
+        k--;
+    while (slot(k) <= nowMs)
+        k++;
+    return slot(k);
+}
+const WEEKDAY_NAMES = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+function parseWeekday(value) {
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 6)
+        return value;
+    if (typeof value === 'string') {
+        const i = WEEKDAY_NAMES.findIndex((d) => d.startsWith(value.trim().toLowerCase()) && value.trim().length >= 3);
+        if (i >= 0)
+            return i;
+    }
+    throw new ScheduleError(`weekday "${String(value)}" isn't a day: use monday to sunday, or 0 (Sunday) to 6`);
 }
 /** Human-readable schedule, for lists and messages. */
 export function describeSchedule(schedule) {
@@ -110,20 +145,53 @@ export async function createScheduledTask(input, nowMs = Date.now()) {
         throw new ScheduleError('message is required');
     let schedule;
     let nextRunMs;
+    const timeZone = workspaceTimeZone();
     if (typeof input.schedule?.run_at === 'string' && input.schedule.run_at) {
-        const runAtMs = Date.parse(input.schedule.run_at);
+        const runAtMs = parseTimestamp(input.schedule.run_at, timeZone);
         if (Number.isNaN(runAtMs))
             throw new ScheduleError(`"${input.schedule.run_at}" is not a valid ISO 8601 timestamp`);
         schedule = { run_at: new Date(runAtMs).toISOString() };
         nextRunMs = runAtMs;
     }
     else if (typeof input.schedule?.every === 'string' && input.schedule.every) {
-        const intervalMs = parseEvery(input.schedule.every);
-        nextRunMs = nowMs + intervalMs;
-        schedule = { every: input.schedule.every.trim(), anchor: new Date(nextRunMs).toISOString() };
+        const every = input.schedule.every.trim();
+        const intervalMs = parseEvery(every);
+        const days = everyDays(every);
+        const calendar = days ? { days, timeZone } : undefined;
+        const { start_at: startAt, at, weekday } = input.schedule;
+        const given = (v) => v !== undefined && v !== null && v !== '';
+        let startMs;
+        if (given(at)) {
+            if (given(startAt))
+                throw new ScheduleError('give either start_at or at, not both');
+            const time = typeof at === 'string' ? parseTimeOfDay(at) : undefined;
+            if (!time)
+                throw new ScheduleError(`at "${String(at)}" isn't a time of day: use 24-hour "HH:MM", e.g. "09:00"`);
+            startMs = nextTimeOfDay(time, nowMs, timeZone, given(weekday) ? parseWeekday(weekday) : undefined);
+        }
+        else if (given(weekday)) {
+            throw new ScheduleError('weekday goes with at, e.g. { "every": "7d", "at": "09:00", "weekday": "monday" }');
+        }
+        else if (given(startAt)) {
+            startMs = typeof startAt === 'string' ? parseTimestamp(startAt, timeZone) : Number.NaN;
+            if (Number.isNaN(startMs))
+                throw new ScheduleError(`start_at "${String(startAt)}" is not a valid ISO 8601 timestamp`);
+        }
+        if (startMs !== undefined) {
+            // The anchor is the start itself, so every run lands on its time of
+            // day (or weekday, for "7d").
+            nextRunMs = nextAnchoredSlot(startMs, intervalMs, nowMs, calendar);
+            schedule = { every, anchor: new Date(startMs).toISOString(), ...(calendar ? { time_zone: timeZone } : {}) };
+        }
+        else {
+            nextRunMs = calendar ? addCalendarDays(nowMs, calendar.days, timeZone) : nowMs + intervalMs;
+            schedule = { every, anchor: new Date(nextRunMs).toISOString(), ...(calendar ? { time_zone: timeZone } : {}) };
+        }
     }
     else {
-        throw new ScheduleError('schedule must be { "run_at": "<ISO timestamp>" } or { "every": "<interval, e.g. 1h>" }');
+        if (input.schedule?.start_at || input.schedule?.at)
+            throw new ScheduleError('start_at and at go with "every" (a repeating task); a one-off task uses run_at');
+        throw new ScheduleError('schedule must be { "run_at": "<ISO timestamp>" } or { "every": "<interval, e.g. 1h>", "start_at"?: "<ISO timestamp>" } or { "every": "1d", "at": "09:00" }');
     }
     const task = {
         task_id: randomUUID(),
@@ -179,6 +247,36 @@ export async function runScheduledTaskNow(taskId, nowMs = Date.now()) {
 export async function deleteScheduledTask(taskId) {
     await getSchedulerStore().remove(taskId);
 }
+/** Moves every daily and weekly (whole-day) task to `toTimeZone`,
+ * keeping its time of day: a 9:00 task made while the workspace was on
+ * UTC runs at 9:00 in the new zone. A task from before tasks kept their
+ * zone is taken to be in `fromTimeZone`. One-off and shorter repeating
+ * tasks are left alone: they're a moment, not a time of day. Returns
+ * how many moved. */
+export async function moveScheduledTasksToTimeZone(fromTimeZone, toTimeZone, nowMs = Date.now()) {
+    let moved = 0;
+    for (const listed of await getSchedulerStore().list()) {
+        if (listed.status === 'done' || listed.status === 'cancelled' || !('every' in listed.schedule) || !everyDays(listed.schedule.every))
+            continue;
+        await getSchedulerStore().update(listed.task_id, (t) => {
+            if (!t || !('every' in t.schedule) || !t.schedule.anchor)
+                return t;
+            const days = everyDays(t.schedule.every);
+            const from = t.schedule.time_zone ?? fromTimeZone;
+            if (!days || from === toTimeZone)
+                return t;
+            const anchorMs = instantOf(wallTimeAt(Date.parse(t.schedule.anchor), from), toTimeZone);
+            const schedule = { ...t.schedule, anchor: new Date(anchorMs).toISOString(), time_zone: toTimeZone };
+            moved++;
+            // A run that's due or under way keeps its slot; the next one moves.
+            if (t.status !== 'scheduled' || !t.next_run_at || Date.parse(t.next_run_at) <= nowMs)
+                return { ...t, schedule };
+            const next = nextAnchoredSlot(anchorMs, parseEvery(t.schedule.every), nowMs, { days, timeZone: toTimeZone });
+            return { ...t, schedule, next_run_at: new Date(next).toISOString() };
+        });
+    }
+    return moved;
+}
 /** When the next task is due — for a host that stops idle servers and
  * needs to wake this one in time (GET /internal/activity). */
 export async function nextScheduledWakeAt() {
@@ -190,7 +288,8 @@ function nextRunAfter(task, nowMs) {
         return undefined;
     const intervalMs = parseEvery(task.schedule.every);
     const anchorMs = task.schedule.anchor ? Date.parse(task.schedule.anchor) : Date.parse(task.created_at) + intervalMs;
-    return nextAnchoredSlot(anchorMs, intervalMs, nowMs);
+    const days = everyDays(task.schedule.every);
+    return nextAnchoredSlot(anchorMs, intervalMs, nowMs, days && task.schedule.time_zone ? { days, timeZone: task.schedule.time_zone } : undefined);
 }
 /** Moves the old lp-task-scheduler's task files (`<dir>/.tasks/*.json`)
  * into this store once, renaming each to `.json.migrated`. Returns how

package/dist/core/system-agents/templates.d.ts

@@ -1,10 +1,53 @@
 import type { AgentCandidate } from './interviewer.js';
+export interface TemplateRule {
+    name: string;
+    tool: string;
+    decision: 'allow' | 'ask' | 'deny';
+}
+export interface TemplateSkill {
+    /** Folder name under agents/<name>/skills/: lowercase-hyphenated. */
+    id: string;
+    description: string;
+    body: string;
+}
+export interface TemplateSchedule {
+    /** How often, in the scheduler's terms: "10m", "1h", "7d". */
+    every: string;
+    /** Optional first run, as a time of day in the workspace's time zone
+     * ("09:00"), and for weekly schedules a weekday (1 = Monday). Without
+     * it, the first run is one interval after the schedule is turned on. */
+    at?: string;
+    weekday?: number;
+    name: string;
+    /** What the agent receives on each run. */
+    message: string;
+}
+export interface TemplateSetup {
+    /** npm names of the abilities to install. */
+    abilities: string[];
+    /** Keys the agent needs before it can work, from its abilities' declared
+     * settings: a name, or a list where any one of them will do. */
+    keys: (string | string[])[];
+    /** Non-secret settings filled in for this agent. */
+    env?: Record<string, string>;
+    skills?: TemplateSkill[];
+    rules: TemplateRule[];
+    schedule?: TemplateSchedule;
+    /** Whether a person must be reachable for approvals (the Messaging tab). */
+    needsApprovals: boolean;
+    /** Extra setup steps, in plain words, for the checklist. */
+    notes?: string[];
+}
 export interface StarterTemplate {
     /** Stable id, used in URLs: lowercase-hyphenated. */
     id: string;
     /** Groups templates on the page: "Customer service", "Operations"… */
     category: string;
     candidate: AgentCandidate;
+    setup: TemplateSetup;
 }
 export declare const STARTER_TEMPLATES: readonly StarterTemplate[];
 export declare function starterTemplate(id: string): StarterTemplate | undefined;
+/** The first run of a template's schedule: its time of day (and weekday)
+ * next, in the workspace's time zone; undefined when it has none. */
+export declare function templateScheduleStart(schedule: TemplateSchedule, nowMs?: number, timeZone?: string): string | undefined;