@jsonstudio/llms 0.6.1739 → 0.6.1890

package/dist/servertool/clock/tasks.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { ensureDir, readSessionDirEnv, resolveClockStateFile } from './paths.js';
+import { ensureDir, readSessionDirEnv, resolveClockDir, resolveClockStateFile } from './paths.js';
 import { cleanExpiredTasks, nowMs } from './state.js';
 import { writeJsonFileAtomic } from './io.js';
 import { clearClockSession, loadClockSessionState } from './session-store.js';
@@ -26,6 +26,64 @@ function buildTaskId() {
         return `task_${Math.random().toString(16).slice(2)}_${Date.now()}`;
     }
 }
+function normalizeRecurrence(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw;
+    const rawKind = typeof record.kind === 'string' ? record.kind.trim().toLowerCase() : '';
+    const kind = rawKind === 'daily' || rawKind === 'weekly' || rawKind === 'interval'
+        ? rawKind
+        : undefined;
+    const maxRunsRaw = Number(record.maxRuns);
+    const maxRuns = Number.isFinite(maxRunsRaw) ? Math.floor(maxRunsRaw) : NaN;
+    if (!kind || !Number.isFinite(maxRuns) || maxRuns <= 0) {
+        return undefined;
+    }
+    if (kind === 'interval') {
+        const everyRaw = Number(record.everyMinutes);
+        const everyMinutes = Number.isFinite(everyRaw) ? Math.floor(everyRaw) : NaN;
+        if (!Number.isFinite(everyMinutes) || everyMinutes <= 0) {
+            return undefined;
+        }
+        return { kind, maxRuns, everyMinutes };
+    }
+    return { kind, maxRuns };
+}
+function resolveRecurringStepMs(recurrence) {
+    if (recurrence.kind === 'daily') {
+        return 24 * 60 * 60_000;
+    }
+    if (recurrence.kind === 'weekly') {
+        return 7 * 24 * 60 * 60_000;
+    }
+    if (recurrence.kind === 'interval') {
+        const minutes = Number(recurrence.everyMinutes);
+        if (!Number.isFinite(minutes) || minutes <= 0) {
+            return null;
+        }
+        return Math.floor(minutes) * 60_000;
+    }
+    return null;
+}
+function computeNextRecurringDueAtMs(currentDueAtMs, recurrence, atMs) {
+    if (!Number.isFinite(currentDueAtMs)) {
+        return null;
+    }
+    const stepMs = resolveRecurringStepMs(recurrence);
+    if (!stepMs || stepMs <= 0) {
+        return null;
+    }
+    let next = Math.floor(currentDueAtMs) + stepMs;
+    const ceiling = Math.max(atMs, Math.floor(currentDueAtMs)) + stepMs * 100_000;
+    while (next <= atMs && next < ceiling) {
+        next += stepMs;
+    }
+    if (!Number.isFinite(next) || next <= atMs) {
+        return null;
+    }
+    return Math.floor(next);
+}
 export function parseDueAtMs(value) {
     if (typeof value !== 'string')
         return null;
@@ -37,6 +95,22 @@ export function parseDueAtMs(value) {
         return null;
     return ms;
 }
+export async function listClockSessionIds() {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return [];
+    }
+    const clockDir = resolveClockDir(sessionDir);
+    const entries = await fs.readdir(clockDir, { withFileTypes: true }).catch(() => []);
+    const sessionIds = entries
+        .filter((entry) => entry && typeof entry.name === 'string' && entry.name.endsWith('.json'))
+        .filter((entry) => entry.name !== 'ntp-state.json')
+        .filter((entry) => (typeof entry.isFile === 'function' ? entry.isFile() : true))
+        .map((entry) => entry.name.slice(0, -'.json'.length).trim())
+        .filter(Boolean)
+        .sort((a, b) => a.localeCompare(b));
+    return sessionIds;
+}
 export async function listClockTasks(sessionId, config) {
     const state = await loadClockSessionState(sessionId, config);
     return state.tasks.slice();
@@ -61,6 +135,10 @@ export async function scheduleClockTasks(sessionId, items, config) {
         if (!text || !Number.isFinite(dueAtMs)) {
             continue;
         }
+        const recurrence = normalizeRecurrence(item.recurrence);
+        if (item.recurrence && !recurrence) {
+            continue;
+        }
         const taskId = buildTaskId();
         scheduled.push({
             taskId,
@@ -72,6 +150,7 @@ export async function scheduleClockTasks(sessionId, items, config) {
             ...(item.tool ? { tool: item.tool } : {}),
             ...(item.arguments ? { arguments: item.arguments } : {}),
             ...(item.notBeforeRequestId ? { notBeforeRequestId: item.notBeforeRequestId } : {}),
+            ...(recurrence ? { recurrence } : {}),
             deliveryCount: 0
         });
     }
@@ -90,6 +169,78 @@ export async function scheduleClockTasks(sessionId, items, config) {
     }
     return scheduled;
 }
+export async function updateClockTask(sessionId, taskId, patch, config) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        throw new Error('clock: missing ROUTECODEX_SESSION_DIR');
+    }
+    const filePath = resolveClockStateFile(sessionDir, sessionId);
+    if (!filePath) {
+        throw new Error('clock: invalid sessionId');
+    }
+    await ensureDir(path.dirname(filePath));
+    const at = nowMs();
+    const state = await loadClockSessionState(sessionId, config);
+    const cleaned = cleanExpiredTasks(state.tasks, config, at);
+    const index = cleaned.findIndex((item) => item.taskId === taskId);
+    if (index < 0) {
+        return null;
+    }
+    const current = cleaned[index];
+    const nextTask = {
+        ...current,
+        updatedAtMs: at
+    };
+    if (typeof patch.dueAtMs === 'number' && Number.isFinite(patch.dueAtMs)) {
+        nextTask.dueAtMs = Math.floor(patch.dueAtMs);
+        delete nextTask.deliveredAtMs;
+    }
+    if (typeof patch.task === 'string' && patch.task.trim()) {
+        nextTask.task = patch.task.trim();
+    }
+    if (patch.tool === null) {
+        delete nextTask.tool;
+    }
+    else if (typeof patch.tool === 'string' && patch.tool.trim()) {
+        nextTask.tool = patch.tool.trim();
+    }
+    if (patch.arguments === null) {
+        delete nextTask.arguments;
+    }
+    else if (patch.arguments && typeof patch.arguments === 'object' && !Array.isArray(patch.arguments)) {
+        nextTask.arguments = patch.arguments;
+    }
+    if (patch.notBeforeRequestId === null) {
+        delete nextTask.notBeforeRequestId;
+    }
+    else if (typeof patch.notBeforeRequestId === 'string' && patch.notBeforeRequestId.trim()) {
+        nextTask.notBeforeRequestId = patch.notBeforeRequestId.trim();
+    }
+    if (patch.recurrence === null) {
+        delete nextTask.recurrence;
+    }
+    else if (patch.recurrence) {
+        const recurrence = normalizeRecurrence(patch.recurrence);
+        if (!recurrence) {
+            return null;
+        }
+        nextTask.recurrence = recurrence;
+        delete nextTask.deliveredAtMs;
+    }
+    if (patch.resetDelivery) {
+        nextTask.deliveryCount = 0;
+        delete nextTask.deliveredAtMs;
+    }
+    cleaned[index] = nextTask;
+    const next = { version: 1, sessionId, tasks: cleaned, updatedAtMs: at };
+    if (!next.tasks.length) {
+        await fs.rm(filePath, { force: true });
+    }
+    else {
+        await writeJsonFileAtomic(filePath, next);
+    }
+    return nextTask;
+}
 export async function cancelClockTask(sessionId, taskId, config) {
     const sessionDir = readSessionDirEnv();
     if (!sessionDir) {
@@ -119,12 +270,23 @@ export async function clearClockTasks(sessionId, config) {
     await clearClockSession(sessionId);
     return items.length;
 }
+function isRecurringTaskPending(task) {
+    const recurrence = normalizeRecurrence(task.recurrence);
+    if (!recurrence) {
+        return false;
+    }
+    const deliveryCount = typeof task.deliveryCount === 'number' && Number.isFinite(task.deliveryCount)
+        ? Math.max(0, Math.floor(task.deliveryCount))
+        : 0;
+    return deliveryCount < recurrence.maxRuns;
+}
 export function selectDueUndeliveredTasks(tasks, config, atMs) {
     const due = [];
     for (const task of tasks) {
         if (!task || typeof task !== 'object')
             continue;
-        if (task.deliveredAtMs !== undefined)
+        const recurringPending = isRecurringTaskPending(task);
+        if (!recurringPending && task.deliveredAtMs !== undefined)
             continue;
         if (typeof task.notBeforeRequestId === 'string' && task.notBeforeRequestId.trim().length) {
             // notBeforeRequestId is evaluated by reserveDueTasksForRequest, which passes requestId.
@@ -134,7 +296,7 @@ export function selectDueUndeliveredTasks(tasks, config, atMs) {
             continue;
         if (atMs < task.dueAtMs - config.dueWindowMs)
             continue;
-        if (atMs > task.dueAtMs + config.retentionMs)
+        if (!recurringPending && atMs > task.dueAtMs + config.retentionMs)
             continue;
         due.push(task);
     }
@@ -146,7 +308,8 @@ export function findNextUndeliveredDueAtMs(tasks, atMs) {
     for (const task of tasks) {
         if (!task || typeof task !== 'object')
             continue;
-        if (task.deliveredAtMs !== undefined)
+        const recurringPending = isRecurringTaskPending(task);
+        if (!recurringPending && task.deliveredAtMs !== undefined)
             continue;
         if (!Number.isFinite(task.dueAtMs))
             continue;
@@ -176,8 +339,6 @@ export async function reserveDueTasksForRequest(args) {
             if (!guarded) {
                 return true;
             }
-            // Avoid same-request triggers, including internal followups that suffix the requestId
-            // (e.g. ":clock_followup"), to prevent request-local dead loops.
             return !isSameRequestChain(guarded, requestId);
         })
         : dueAll;
@@ -196,7 +357,11 @@ export async function reserveDueTasksForRequest(args) {
         const dueAtIso = new Date(t.dueAtMs).toISOString();
         const toolLabel = t.tool ? ` tool=${t.tool}` : '';
         const argsLabel = t.arguments ? ` args=${safeJson(t.arguments)}` : '';
-        return `[scheduled task:${safeQuoted(t.task)}${toolLabel}${argsLabel} dueAt=${dueAtIso}]`;
+        const recurrence = normalizeRecurrence(t.recurrence);
+        const recurrenceLabel = recurrence
+            ? ` recurrence=${recurrence.kind}${recurrence.kind === 'interval' ? `(${recurrence.everyMinutes}m)` : ''} maxRuns=${recurrence.maxRuns} run=${Math.max(0, t.deliveryCount)}/${recurrence.maxRuns}`
+            : '';
+        return `[scheduled task:${safeQuoted(t.task)}${toolLabel}${argsLabel}${recurrenceLabel} dueAt=${dueAtIso}]`;
     })
         .join('\n');
     return { reservation, injectText };
@@ -215,21 +380,47 @@ export async function commitClockReservation(reservation, config) {
     const cleaned = cleanExpiredTasks(state.tasks, config, at);
     const reservedSet = new Set(reservation.taskIds);
     let touched = false;
-    const nextTasks = cleaned.map((t) => {
-        if (!reservedSet.has(t.taskId)) {
-            return t;
-        }
-        if (t.deliveredAtMs !== undefined) {
-            return t;
+    const nextTasks = [];
+    for (const task of cleaned) {
+        if (!reservedSet.has(task.taskId)) {
+            nextTasks.push(task);
+            continue;
         }
         touched = true;
-        return {
-            ...t,
+        const currentCount = typeof task.deliveryCount === 'number' && Number.isFinite(task.deliveryCount)
+            ? Math.max(0, Math.floor(task.deliveryCount))
+            : 0;
+        const nextCount = currentCount + 1;
+        const recurrence = normalizeRecurrence(task.recurrence);
+        if (recurrence) {
+            if (nextCount >= recurrence.maxRuns) {
+                continue;
+            }
+            const nextDueAtMs = computeNextRecurringDueAtMs(task.dueAtMs, recurrence, at);
+            if (!Number.isFinite(nextDueAtMs)) {
+                continue;
+            }
+            nextTasks.push({
+                ...task,
+                dueAtMs: nextDueAtMs,
+                deliveryCount: nextCount,
+                updatedAtMs: at,
+                recurrence,
+                deliveredAtMs: undefined
+            });
+            continue;
+        }
+        if (task.deliveredAtMs !== undefined) {
+            nextTasks.push(task);
+            continue;
+        }
+        nextTasks.push({
+            ...task,
             deliveredAtMs: at,
-            deliveryCount: (typeof t.deliveryCount === 'number' ? t.deliveryCount : 0) + 1,
+            deliveryCount: nextCount,
             updatedAtMs: at
-        };
-    });
+        });
+    }
     if (!touched) {
         return;
     }

package/dist/servertool/clock/types.d.ts

@@ -1,3 +1,9 @@
+export type ClockRecurrenceKind = 'daily' | 'weekly' | 'interval';
+export type ClockTaskRecurrence = {
+    kind: ClockRecurrenceKind;
+    maxRuns: number;
+    everyMinutes?: number;
+};
 export type ClockTask = {
     taskId: string;
     sessionId: string;
@@ -10,6 +16,7 @@ export type ClockTask = {
     deliveredAtMs?: number;
     deliveryCount: number;
     notBeforeRequestId?: string;
+    recurrence?: ClockTaskRecurrence;
 };
 export type ClockSessionState = {
     version: 1;
@@ -45,6 +52,16 @@ export type ClockScheduleItem = {
     tool?: string;
     arguments?: Record<string, unknown>;
     notBeforeRequestId?: string;
+    recurrence?: ClockTaskRecurrence;
+};
+export type ClockTaskUpdatePatch = {
+    dueAtMs?: number;
+    task?: string;
+    tool?: string | null;
+    arguments?: Record<string, unknown> | null;
+    notBeforeRequestId?: string | null;
+    recurrence?: ClockTaskRecurrence | null;
+    resetDelivery?: boolean;
 };
 export type ClockNtpState = {
     version: 1;

package/dist/servertool/continue-execution/log.d.ts

@@ -0,0 +1,3 @@
+export declare const CONTINUE_EXECUTION_LOG_GOLD = "\u001B[38;5;220m";
+export declare const CONTINUE_EXECUTION_LOG_RESET = "\u001B[0m";
+export declare function logContinueExecution(message: string, extra?: Record<string, unknown>): void;

package/dist/servertool/continue-execution/log.js

@@ -0,0 +1,13 @@
+export const CONTINUE_EXECUTION_LOG_GOLD = '\x1b[38;5;220m';
+export const CONTINUE_EXECUTION_LOG_RESET = '\x1b[0m';
+export function logContinueExecution(message, extra) {
+    try {
+        // eslint-disable-next-line no-console
+        console.log(`${CONTINUE_EXECUTION_LOG_GOLD}[servertool][continue_execution] ${message}` +
+            (extra ? ` ${JSON.stringify(extra)}` : '') +
+            CONTINUE_EXECUTION_LOG_RESET);
+    }
+    catch {
+        // best-effort logging
+    }
+}