@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/servertool/clock/session-store.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, readSessionDirEnv, resolveClockStateFile } from './paths.js';
+import { buildEmptyState, cleanExpiredTasks, coerceState, normalizeClockSessionMeta, nowMs } from './state.js';
+import { readJsonFile, writeJsonFileAtomic } from './io.js';
+function shouldPersistClockState(state) {
+    if (state.tasks.length > 0) {
+        return true;
+    }
+    const meta = normalizeClockSessionMeta(state.meta);
+    return meta.taskRevision > 0 || meta.listedRevision >= 0 || Number.isFinite(meta.lastListAtMs);
+}
+export async function loadClockSessionState(sessionId, config) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return buildEmptyState(sessionId);
+    }
+    const filePath = resolveClockStateFile(sessionDir, sessionId);
+    if (!filePath) {
+        return buildEmptyState(sessionId);
+    }
+    try {
+        const raw = await readJsonFile(filePath);
+        const state = coerceState(raw, sessionId);
+        const at = nowMs();
+        const cleaned = cleanExpiredTasks(state.tasks, config, at);
+        if (cleaned.length !== state.tasks.length) {
+            const next = { ...state, tasks: cleaned, updatedAtMs: at };
+            if (!shouldPersistClockState(next)) {
+                await fs.rm(filePath, { force: true });
+            }
+            else {
+                await ensureDir(path.dirname(filePath));
+                await writeJsonFileAtomic(filePath, next);
+            }
+            return next;
+        }
+        return state;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error ?? 'unknown');
+        if (message.includes('ENOENT')) {
+            return buildEmptyState(sessionId);
+        }
+        return buildEmptyState(sessionId);
+    }
+}
+export async function clearClockSession(sessionId) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return;
+    }
+    const filePath = resolveClockStateFile(sessionDir, sessionId);
+    if (!filePath) {
+        return;
+    }
+    try {
+        await fs.rm(filePath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+}

package/vendor/llmswitch-core/dist/servertool/clock/state.d.ts

@@ -0,0 +1,9 @@
+import type { ClockConfigSnapshot, ClockSessionMeta, ClockSessionState, ClockTask } from './types.js';
+export declare function setClockOffsetMs(value: number): void;
+export declare function getClockOffsetMs(): number;
+export declare function nowMs(): number;
+export declare function buildDefaultClockSessionMeta(): ClockSessionMeta;
+export declare function normalizeClockSessionMeta(raw: unknown): ClockSessionMeta;
+export declare function buildEmptyState(sessionId: string): ClockSessionState;
+export declare function coerceState(raw: unknown, sessionId: string): ClockSessionState;
+export declare function cleanExpiredTasks(tasks: ClockTask[], config: ClockConfigSnapshot, atMs: number): ClockTask[];

package/vendor/llmswitch-core/dist/servertool/clock/state.js

@@ -0,0 +1,135 @@
+import { normalizeRecurrence, recurrenceHasRemainingRuns } from './recurrence.js';
+let clockOffsetMs = 0;
+const CLOCK_OVERDUE_AUTO_REMOVE_MS = 60_000;
+function normalizeTaskSetter(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (value === 'agent') {
+        return 'agent';
+    }
+    return 'user';
+}
+export function setClockOffsetMs(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return;
+    clockOffsetMs = Math.max(-24 * 60 * 60_000, Math.min(24 * 60 * 60_000, Math.floor(value)));
+}
+export function getClockOffsetMs() {
+    return clockOffsetMs;
+}
+export function nowMs() {
+    return Date.now() + clockOffsetMs;
+}
+export function buildDefaultClockSessionMeta() {
+    return {
+        taskRevision: 0,
+        listedRevision: -1
+    };
+}
+export function normalizeClockSessionMeta(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return buildDefaultClockSessionMeta();
+    }
+    const record = raw;
+    const taskRevisionRaw = Number(record.taskRevision);
+    const listedRevisionRaw = Number(record.listedRevision);
+    const lastListAtMsRaw = Number(record.lastListAtMs);
+    return {
+        taskRevision: Number.isFinite(taskRevisionRaw) && taskRevisionRaw >= 0
+            ? Math.floor(taskRevisionRaw)
+            : 0,
+        listedRevision: Number.isFinite(listedRevisionRaw)
+            ? Math.floor(listedRevisionRaw)
+            : -1,
+        ...(Number.isFinite(lastListAtMsRaw) ? { lastListAtMs: Math.floor(lastListAtMsRaw) } : {})
+    };
+}
+export function buildEmptyState(sessionId) {
+    const t = nowMs();
+    return { version: 1, sessionId, tasks: [], updatedAtMs: t, meta: buildDefaultClockSessionMeta() };
+}
+export function coerceState(raw, sessionId) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return buildEmptyState(sessionId);
+    }
+    const record = raw;
+    const tasksRaw = Array.isArray(record.tasks) ? record.tasks : [];
+    const tasks = [];
+    for (const entry of tasksRaw) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const e = entry;
+        const taskId = typeof e.taskId === 'string' ? e.taskId.trim() : '';
+        const dueAtMs = typeof e.dueAtMs === 'number' && Number.isFinite(e.dueAtMs) ? Math.floor(e.dueAtMs) : NaN;
+        const createdAtMs = typeof e.createdAtMs === 'number' && Number.isFinite(e.createdAtMs) ? Math.floor(e.createdAtMs) : NaN;
+        const updatedAtMs = typeof e.updatedAtMs === 'number' && Number.isFinite(e.updatedAtMs) ? Math.floor(e.updatedAtMs) : NaN;
+        const task = typeof e.task === 'string' ? e.task.trim() : '';
+        const prompt = typeof e.prompt === 'string' && e.prompt.trim() ? e.prompt.trim() : task;
+        if (!taskId || !task || !Number.isFinite(dueAtMs) || !Number.isFinite(createdAtMs) || !Number.isFinite(updatedAtMs)) {
+            continue;
+        }
+        const tool = typeof e.tool === 'string' && e.tool.trim() ? e.tool.trim() : undefined;
+        const args = e.arguments && typeof e.arguments === 'object' && !Array.isArray(e.arguments)
+            ? e.arguments
+            : undefined;
+        const deliveredAtMs = typeof e.deliveredAtMs === 'number' && Number.isFinite(e.deliveredAtMs) ? Math.floor(e.deliveredAtMs) : undefined;
+        const notBeforeRequestId = typeof e.notBeforeRequestId === 'string' && e.notBeforeRequestId.trim().length
+            ? e.notBeforeRequestId.trim()
+            : undefined;
+        const deliveryCount = typeof e.deliveryCount === 'number' && Number.isFinite(e.deliveryCount) ? Math.max(0, Math.floor(e.deliveryCount)) : 0;
+        const urls = Array.isArray(e.urls)
+            ? e.urls.filter((entry) => typeof entry === 'string' && entry.trim()).map((entry) => String(entry).trim())
+            : undefined;
+        const paths = Array.isArray(e.paths)
+            ? e.paths.filter((entry) => typeof entry === 'string' && entry.trim()).map((entry) => String(entry).trim())
+            : undefined;
+        const recurrence = normalizeRecurrence(e.recurrence);
+        const setBy = normalizeTaskSetter(e.setBy);
+        tasks.push({
+            taskId,
+            sessionId,
+            dueAtMs,
+            createdAtMs,
+            updatedAtMs,
+            setBy,
+            ...(prompt ? { prompt } : {}),
+            task,
+            ...(tool ? { tool } : {}),
+            ...(args ? { arguments: args } : {}),
+            ...(urls && urls.length ? { urls } : {}),
+            ...(paths && paths.length ? { paths } : {}),
+            ...(deliveredAtMs !== undefined ? { deliveredAtMs } : {}),
+            deliveryCount,
+            ...(notBeforeRequestId ? { notBeforeRequestId } : {}),
+            ...(recurrence ? { recurrence } : {})
+        });
+    }
+    const tmuxSessionId = typeof record.tmuxSessionId === 'string' && record.tmuxSessionId.trim()
+        ? record.tmuxSessionId.trim()
+        : undefined;
+    const updatedAtMs = typeof record.updatedAtMs === 'number' && Number.isFinite(record.updatedAtMs) ? Math.floor(record.updatedAtMs) : nowMs();
+    const meta = normalizeClockSessionMeta(record.meta);
+    return { version: 1, sessionId, ...(tmuxSessionId ? { tmuxSessionId } : {}), tasks, updatedAtMs, meta };
+}
+export function cleanExpiredTasks(tasks, config, atMs) {
+    const out = [];
+    for (const task of tasks) {
+        if (!task || typeof task !== 'object')
+            continue;
+        if (!Number.isFinite(task.dueAtMs))
+            continue;
+        const recurrence = normalizeRecurrence(task.recurrence);
+        if (recurrence) {
+            if (!recurrenceHasRemainingRuns(recurrence, task.deliveryCount)) {
+                continue;
+            }
+            out.push({ ...task, recurrence });
+            continue;
+        }
+        const oneShotRetentionMs = Math.max(0, Math.min(config.retentionMs, CLOCK_OVERDUE_AUTO_REMOVE_MS));
+        if (atMs > task.dueAtMs + oneShotRetentionMs) {
+            continue;
+        }
+        out.push(task);
+    }
+    return out;
+}

package/vendor/llmswitch-core/dist/servertool/clock/task-store.d.ts

@@ -0,0 +1,5 @@
+export type { ClockConfigSnapshot, ClockQuietHoursWindow, ClockReservation, ClockScheduleItem, ClockSessionState, ClockTask, ClockTaskRecurrence, ClockTaskUpdatePatch, } from "./types.js";
+export { normalizeClockConfig, resolveClockConfig } from "./config.js";
+export { startClockDaemonIfNeeded, stopClockDaemonForTests, setClockRuntimeHooks, resetClockRuntimeHooksForTests, runClockDaemonTickForTests, } from "./daemon.js";
+export { loadClockSessionState, clearClockSession } from "./session-store.js";
+export { cancelClockTask, clearClockTasks, commitClockReservation, findNearbyClockTasks, findNextUndeliveredDueAtMs, hasObservedClockList, listClockSessionIds, listClockTasks, markClockListObserved, parseDueAtMs, reserveDueTasksForRequest, scheduleClockTasks, selectDueUndeliveredTasks, updateClockTask, } from "./tasks.js";

package/vendor/llmswitch-core/dist/servertool/clock/task-store.js

@@ -0,0 +1,4 @@
+export { normalizeClockConfig, resolveClockConfig } from "./config.js";
+export { startClockDaemonIfNeeded, stopClockDaemonForTests, setClockRuntimeHooks, resetClockRuntimeHooksForTests, runClockDaemonTickForTests, } from "./daemon.js";
+export { loadClockSessionState, clearClockSession } from "./session-store.js";
+export { cancelClockTask, clearClockTasks, commitClockReservation, findNearbyClockTasks, findNextUndeliveredDueAtMs, hasObservedClockList, listClockSessionIds, listClockTasks, markClockListObserved, parseDueAtMs, reserveDueTasksForRequest, scheduleClockTasks, selectDueUndeliveredTasks, updateClockTask, } from "./tasks.js";

package/vendor/llmswitch-core/dist/servertool/clock/tasks.d.ts

@@ -0,0 +1,24 @@
+import type { ClockConfigSnapshot, ClockReservation, ClockScheduleItem, ClockSessionState, ClockTask, ClockTaskUpdatePatch } from './types.js';
+export declare function formatClockReminderText(task: Pick<ClockTask, 'task' | 'dueAtMs' | 'createdAtMs' | 'setBy' | 'tool' | 'arguments' | 'urls' | 'paths' | 'deliveryCount' | 'recurrence'>): string;
+export declare function hasObservedClockList(state: ClockSessionState): boolean;
+export declare function markClockListObserved(sessionId: string, config: ClockConfigSnapshot): Promise<ClockSessionState>;
+export declare function findNearbyClockTasks(tasks: ClockTask[], anchorTask: ClockTask, toleranceMs: number): ClockTask[];
+export declare function parseDueAtMs(value: unknown): number | null;
+export declare function listClockSessionIds(): Promise<string[]>;
+export declare function listClockTasks(sessionId: string, config: ClockConfigSnapshot): Promise<ClockTask[]>;
+export declare function scheduleClockTasks(sessionId: string, items: ClockScheduleItem[], config: ClockConfigSnapshot): Promise<ClockTask[]>;
+export declare function updateClockTask(sessionId: string, taskId: string, patch: ClockTaskUpdatePatch, config: ClockConfigSnapshot): Promise<ClockTask | null>;
+export declare function cancelClockTask(sessionId: string, taskId: string, config: ClockConfigSnapshot): Promise<boolean>;
+export declare function clearClockTasks(sessionId: string, config: ClockConfigSnapshot): Promise<number>;
+export declare function selectDueUndeliveredTasks(tasks: ClockTask[], config: ClockConfigSnapshot, atMs: number): ClockTask[];
+export declare function findNextUndeliveredDueAtMs(tasks: ClockTask[], atMs: number): number | null;
+export declare function reserveDueTasksForRequest(args: {
+    reservationId: string;
+    sessionId: string;
+    config: ClockConfigSnapshot;
+    requestId?: string;
+}): Promise<{
+    reservation: ClockReservation | null;
+    injectText?: string;
+}>;
+export declare function commitClockReservation(reservation: ClockReservation, config: ClockConfigSnapshot): Promise<void>;