@jsonstudio/rcc 0.90.352 → 0.90.367

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

@@ -0,0 +1,595 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { ensureDir, readSessionDirEnv, resolveClockDir, resolveClockStateFile } from './paths.js';
+import { cleanExpiredTasks, normalizeClockSessionMeta, nowMs } from './state.js';
+import { readJsonFile, writeJsonFileAtomic } from './io.js';
+import { loadClockSessionState } from './session-store.js';
+import { computeNextRecurringDueAtMs, normalizeRecurrence, recurrenceHasRemainingRuns, recurrenceRemainingRuns, shiftOutOfQuietHours } from './recurrence.js';
+const TMUX_SCOPE_PREFIX = 'tmux:';
+function safeJson(value) {
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+function isNonEmptyJsonObjectString(value) {
+    const normalized = value.trim();
+    return normalized !== '{}' && normalized !== '[]' && normalized.length > 0;
+}
+function resolveLocalTimeZoneLabel() {
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (timeZone === 'Asia/Shanghai' || timeZone === 'Asia/Chongqing' || timeZone === 'Asia/Harbin' || timeZone === 'Asia/Urumqi') {
+        return 'CST';
+    }
+    return '';
+}
+function formatLocalClockTimestamp(ms) {
+    const date = new Date(ms);
+    if (!Number.isFinite(date.getTime())) {
+        return new Date(0).toISOString();
+    }
+    const formatter = new Intl.DateTimeFormat('sv-SE', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+        timeZoneName: 'short'
+    });
+    const parts = formatter.formatToParts(date);
+    const readPart = (type) => parts.find((part) => part.type === type)?.value ?? '';
+    const base = `${readPart('year')}-${readPart('month')}-${readPart('day')} ${readPart('hour')}:${readPart('minute')}:${readPart('second')}`;
+    const label = resolveLocalTimeZoneLabel() || readPart('timeZoneName') || 'local';
+    return `${base} ${label}`.trim();
+}
+function buildClockMdTemplateHint() {
+    return [
+        'clock.md 模板:',
+        '## 背景',
+        '## 当前阻塞点',
+        '## 下次提醒要做的第一步',
+        '## 不能忘的检查项',
+        '## 建议内容示例',
+        '- 背景：正在准备 llms 包发布，已完成 build 和本地验证',
+        '- 当前阻塞点：等待 10 分钟后再检查 npm 包同步状态',
+        '- 下次提醒要做的第一步：运行 npm view 检查新版本是否可见',
+        '- 不能忘的检查项：确认 tag、版本号、release notes、install smoke test'
+    ].join(' | ');
+}
+export function formatClockReminderText(task) {
+    const lines = [
+        '[Clock Reminder]',
+        `任务: ${String(task.task || '').trim() || '未命名任务'}`,
+        `触发时间: ${formatLocalClockTimestamp(task.dueAtMs)}`,
+        `设置人: ${task.setBy === 'agent' ? 'agent' : 'user'}`,
+        `设置时间: ${formatLocalClockTimestamp(task.createdAtMs)}`,
+        '复杂任务: 先查看并更新当前工作目录下的 clock.md',
+        buildClockMdTemplateHint()
+    ];
+    if (task.tool) {
+        lines.push(`建议工具: ${task.tool}`);
+    }
+    const argsText = task.arguments ? safeJson(task.arguments) : '';
+    if (isNonEmptyJsonObjectString(argsText)) {
+        lines.push(`参数: ${argsText}`);
+    }
+    if (Array.isArray(task.urls) && task.urls.length) {
+        lines.push(`链接: ${task.urls.join(', ')}`);
+    }
+    if (Array.isArray(task.paths) && task.paths.length) {
+        lines.push(`路径: ${task.paths.join(', ')}`);
+    }
+    const recurrence = normalizeRecurrence(task.recurrence);
+    if (recurrence) {
+        const runCount = Math.max(0, Number(task.deliveryCount) || 0);
+        const maxRunsLabel = typeof recurrence.maxRuns === 'number' ? recurrence.maxRuns : 'infinite';
+        const recurrenceSummary = recurrence.kind === 'interval'
+            ? `interval(${recurrence.everyMinutes}m) ${runCount}/${maxRunsLabel}`
+            : `${recurrence.kind} ${runCount}/${maxRunsLabel}`;
+        lines.push(`重复: ${recurrenceSummary}`);
+        if (Array.isArray(recurrence.quietHours) && recurrence.quietHours.length) {
+            lines.push(`静默时段: ${recurrence.quietHours.map((window) => `${window.start}-${window.end}`).join(', ')}`);
+        }
+        if (recurrenceRemainingRuns(recurrence, task.deliveryCount) === null) {
+            lines.push('剩余次数: infinite');
+        }
+    }
+    return lines.join('\n');
+}
+function buildTaskId() {
+    try {
+        return crypto.randomUUID();
+    }
+    catch {
+        return `task_${Math.random().toString(16).slice(2)}_${Date.now()}`;
+    }
+}
+function extractTmuxSessionIdFromScope(sessionId) {
+    const normalized = typeof sessionId === 'string' ? sessionId.trim() : '';
+    if (!normalized.startsWith(TMUX_SCOPE_PREFIX)) {
+        return undefined;
+    }
+    const tmuxSessionId = normalized.slice(TMUX_SCOPE_PREFIX.length).trim();
+    return tmuxSessionId || undefined;
+}
+function normalizeTaskSetter(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (value === 'agent') {
+        return 'agent';
+    }
+    return 'user';
+}
+function nextClockTaskRevision(meta) {
+    return {
+        ...meta,
+        taskRevision: Math.max(0, meta.taskRevision) + 1
+    };
+}
+function hasMeaningfulClockMeta(meta) {
+    return meta.taskRevision > 0 || meta.listedRevision >= 0 || Number.isFinite(meta.lastListAtMs);
+}
+async function persistClockSessionState(filePath, state) {
+    if (!state.tasks.length && !hasMeaningfulClockMeta(normalizeClockSessionMeta(state.meta))) {
+        await fs.rm(filePath, { force: true });
+        return;
+    }
+    await writeJsonFileAtomic(filePath, state);
+}
+export function hasObservedClockList(state) {
+    const meta = normalizeClockSessionMeta(state.meta);
+    return meta.listedRevision >= 0 && meta.listedRevision === meta.taskRevision;
+}
+export async function markClockListObserved(sessionId, 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 meta = normalizeClockSessionMeta(state.meta);
+    const next = {
+        version: 1,
+        sessionId,
+        ...(state.tmuxSessionId ? { tmuxSessionId: state.tmuxSessionId } : {}),
+        tasks: state.tasks.slice(),
+        updatedAtMs: at,
+        meta: {
+            ...meta,
+            listedRevision: meta.taskRevision,
+            lastListAtMs: at
+        }
+    };
+    await persistClockSessionState(filePath, next);
+    return next;
+}
+export function findNearbyClockTasks(tasks, anchorTask, toleranceMs) {
+    const windowMs = Math.max(0, Math.floor(toleranceMs));
+    if (!Number.isFinite(anchorTask?.dueAtMs) || windowMs <= 0) {
+        return [];
+    }
+    return tasks
+        .filter((task) => task && task.taskId !== anchorTask.taskId)
+        .filter((task) => Number.isFinite(task.dueAtMs))
+        .filter((task) => Math.abs(task.dueAtMs - anchorTask.dueAtMs) <= windowMs)
+        .sort((a, b) => a.dueAtMs - b.dueAtMs);
+}
+export function parseDueAtMs(value) {
+    if (typeof value !== 'string')
+        return null;
+    const t = value.trim();
+    if (!t)
+        return null;
+    const ms = Date.parse(t);
+    if (!Number.isFinite(ms))
+        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 = await Promise.all(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(async (entry) => {
+        const fallbackSessionId = entry.name.slice(0, -'.json'.length).trim();
+        try {
+            const raw = await readJsonFile(path.join(clockDir, entry.name));
+            const sessionId = raw && typeof raw === 'object' && typeof raw.sessionId === 'string'
+                ? String(raw.sessionId).trim()
+                : '';
+            return sessionId || fallbackSessionId;
+        }
+        catch {
+            return fallbackSessionId;
+        }
+    }));
+    return Array.from(new Set(sessionIds.filter(Boolean))).sort((a, b) => a.localeCompare(b));
+}
+export async function listClockTasks(sessionId, config) {
+    const state = await loadClockSessionState(sessionId, config);
+    return state.tasks.slice();
+}
+export async function scheduleClockTasks(sessionId, items, 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 existing = await loadClockSessionState(sessionId, config);
+    const cleaned = cleanExpiredTasks(existing.tasks, config, at);
+    const existingMeta = normalizeClockSessionMeta(existing.meta);
+    const scheduled = [];
+    for (const item of items) {
+        const text = typeof item.prompt === 'string' && item.prompt.trim()
+            ? item.prompt.trim()
+            : typeof item.task === 'string'
+                ? item.task.trim()
+                : '';
+        const dueAtMs = item.dueAtMs;
+        if (!text || !Number.isFinite(dueAtMs)) {
+            continue;
+        }
+        const recurrence = normalizeRecurrence(item.recurrence);
+        if (item.recurrence && !recurrence) {
+            continue;
+        }
+        const effectiveDueAtMs = recurrence ? shiftOutOfQuietHours(dueAtMs, recurrence.quietHours) : dueAtMs;
+        const setBy = normalizeTaskSetter(item.setBy);
+        const taskId = buildTaskId();
+        scheduled.push({
+            taskId,
+            sessionId,
+            dueAtMs: Math.floor(effectiveDueAtMs),
+            createdAtMs: at,
+            updatedAtMs: at,
+            setBy,
+            prompt: text,
+            task: text,
+            ...(item.tool ? { tool: item.tool } : {}),
+            ...(item.arguments ? { arguments: item.arguments } : {}),
+            ...(Array.isArray(item.urls) && item.urls.length ? { urls: item.urls } : {}),
+            ...(Array.isArray(item.paths) && item.paths.length ? { paths: item.paths } : {}),
+            ...(item.notBeforeRequestId ? { notBeforeRequestId: item.notBeforeRequestId } : {}),
+            ...(recurrence ? { recurrence } : {}),
+            deliveryCount: 0
+        });
+    }
+    const nextTasks = cleanExpiredTasks([...cleaned, ...scheduled], config, at);
+    const next = {
+        version: 1,
+        sessionId,
+        ...(extractTmuxSessionIdFromScope(sessionId) ? { tmuxSessionId: extractTmuxSessionIdFromScope(sessionId) } : {}),
+        tasks: nextTasks,
+        updatedAtMs: at,
+        meta: scheduled.length ? nextClockTaskRevision(existingMeta) : existingMeta
+    };
+    await persistClockSessionState(filePath, next);
+    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 stateMeta = normalizeClockSessionMeta(state.meta);
+    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);
+        const existingRecurrence = normalizeRecurrence(nextTask.recurrence);
+        if (existingRecurrence) {
+            nextTask.dueAtMs = shiftOutOfQuietHours(nextTask.dueAtMs, existingRecurrence.quietHours);
+        }
+        delete nextTask.deliveredAtMs;
+    }
+    if (typeof patch.task === 'string' && patch.task.trim()) {
+        nextTask.prompt = 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.urls === null) {
+        delete nextTask.urls;
+    }
+    else if (Array.isArray(patch.urls)) {
+        nextTask.urls = patch.urls
+            .filter((entry) => typeof entry === 'string' && entry.trim())
+            .map((entry) => String(entry).trim());
+    }
+    if (patch.paths === null) {
+        delete nextTask.paths;
+    }
+    else if (Array.isArray(patch.paths)) {
+        nextTask.paths = patch.paths
+            .filter((entry) => typeof entry === 'string' && entry.trim())
+            .map((entry) => String(entry).trim());
+    }
+    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;
+        nextTask.dueAtMs = shiftOutOfQuietHours(nextTask.dueAtMs, recurrence.quietHours);
+        delete nextTask.deliveredAtMs;
+    }
+    if (patch.resetDelivery) {
+        nextTask.deliveryCount = 0;
+        delete nextTask.deliveredAtMs;
+    }
+    cleaned[index] = nextTask;
+    const next = {
+        version: 1,
+        sessionId,
+        ...(state.tmuxSessionId ? { tmuxSessionId: state.tmuxSessionId } : {}),
+        tasks: cleaned,
+        updatedAtMs: at,
+        meta: nextClockTaskRevision(stateMeta)
+    };
+    await persistClockSessionState(filePath, next);
+    return nextTask;
+}
+export async function cancelClockTask(sessionId, taskId, 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 stateMeta = normalizeClockSessionMeta(state.meta);
+    const nextTasks = cleaned.filter((t) => t.taskId !== taskId);
+    const removed = nextTasks.length !== cleaned.length;
+    const next = {
+        version: 1,
+        sessionId,
+        ...(state.tmuxSessionId ? { tmuxSessionId: state.tmuxSessionId } : {}),
+        tasks: nextTasks,
+        updatedAtMs: at,
+        meta: removed ? nextClockTaskRevision(stateMeta) : stateMeta
+    };
+    await persistClockSessionState(filePath, next);
+    return removed;
+}
+export async function clearClockTasks(sessionId, 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 removedCount = state.tasks.length;
+    const meta = normalizeClockSessionMeta(state.meta);
+    const next = {
+        version: 1,
+        sessionId,
+        ...(state.tmuxSessionId ? { tmuxSessionId: state.tmuxSessionId } : {}),
+        tasks: [],
+        updatedAtMs: at,
+        meta: removedCount > 0 ? nextClockTaskRevision(meta) : meta
+    };
+    await persistClockSessionState(filePath, next);
+    return removedCount;
+}
+export function selectDueUndeliveredTasks(tasks, config, atMs) {
+    const due = [];
+    for (const task of tasks) {
+        if (!task || typeof task !== 'object')
+            continue;
+        const recurrence = normalizeRecurrence(task.recurrence);
+        const recurringPending = recurrence ? recurrenceHasRemainingRuns(recurrence, task.deliveryCount) : false;
+        if (!recurringPending && task.deliveredAtMs !== undefined)
+            continue;
+        if (typeof task.notBeforeRequestId === 'string' && task.notBeforeRequestId.trim().length) {
+            // notBeforeRequestId is evaluated by reserveDueTasksForRequest, which passes requestId.
+            // Keep legacy callers working by ignoring this guard here (default behavior).
+        }
+        if (!Number.isFinite(task.dueAtMs))
+            continue;
+        const effectiveDueAtMs = recurrence ? shiftOutOfQuietHours(task.dueAtMs, recurrence.quietHours) : task.dueAtMs;
+        if (atMs < effectiveDueAtMs - config.dueWindowMs)
+            continue;
+        if (!recurringPending && atMs > effectiveDueAtMs + config.retentionMs)
+            continue;
+        due.push(effectiveDueAtMs === task.dueAtMs ? task : { ...task, dueAtMs: effectiveDueAtMs, recurrence });
+    }
+    due.sort((a, b) => a.dueAtMs - b.dueAtMs);
+    return due;
+}
+export function findNextUndeliveredDueAtMs(tasks, atMs) {
+    let next = null;
+    for (const task of tasks) {
+        if (!task || typeof task !== 'object')
+            continue;
+        const recurrence = normalizeRecurrence(task.recurrence);
+        const recurringPending = recurrence ? recurrenceHasRemainingRuns(recurrence, task.deliveryCount) : false;
+        if (!recurringPending && task.deliveredAtMs !== undefined)
+            continue;
+        if (!Number.isFinite(task.dueAtMs))
+            continue;
+        const effectiveDueAtMs = recurrence ? shiftOutOfQuietHours(task.dueAtMs, recurrence.quietHours) : task.dueAtMs;
+        if (effectiveDueAtMs < atMs) {
+            // keep past due tasks as "next" too (will be due immediately)
+        }
+        if (next === null || effectiveDueAtMs < next) {
+            next = effectiveDueAtMs;
+        }
+    }
+    return next;
+}
+export async function reserveDueTasksForRequest(args) {
+    const state = await loadClockSessionState(args.sessionId, args.config);
+    const at = nowMs();
+    const dueAll = selectDueUndeliveredTasks(state.tasks, args.config, at);
+    const requestId = typeof args.requestId === 'string' && args.requestId.trim().length ? args.requestId.trim() : '';
+    const isSameRequestChain = (guardedRequestId, currentRequestId) => {
+        const guarded = guardedRequestId.trim();
+        if (!guarded)
+            return false;
+        return currentRequestId === guarded || currentRequestId.startsWith(`${guarded}:`);
+    };
+    const due = requestId
+        ? dueAll.filter((t) => {
+            const guarded = typeof t.notBeforeRequestId === 'string' ? String(t.notBeforeRequestId).trim() : '';
+            if (!guarded) {
+                return true;
+            }
+            return !isSameRequestChain(guarded, requestId);
+        })
+        : dueAll;
+    if (!due.length) {
+        return { reservation: null };
+    }
+    const taskIds = due.map((t) => t.taskId);
+    const reservation = {
+        reservationId: args.reservationId,
+        sessionId: args.sessionId,
+        taskIds,
+        reservedAtMs: at
+    };
+    const injectText = due
+        .map((t) => formatClockReminderText(t))
+        .join('\n');
+    return { reservation, injectText };
+}
+export async function commitClockReservation(reservation, config) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return;
+    }
+    const filePath = resolveClockStateFile(sessionDir, reservation.sessionId);
+    if (!filePath) {
+        return;
+    }
+    const at = nowMs();
+    const state = await loadClockSessionState(reservation.sessionId, config);
+    const cleaned = cleanExpiredTasks(state.tasks, config, at);
+    const reservedSet = new Set(reservation.taskIds);
+    let touched = false;
+    const nextTasks = [];
+    for (const task of cleaned) {
+        if (!reservedSet.has(task.taskId)) {
+            nextTasks.push(task);
+            continue;
+        }
+        touched = true;
+        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 (!recurrenceHasRemainingRuns(recurrence, nextCount)) {
+                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: nextCount,
+            updatedAtMs: at
+        });
+    }
+    if (!touched) {
+        return;
+    }
+    const next = {
+        version: 1,
+        sessionId: reservation.sessionId,
+        ...(state.tmuxSessionId
+            ? { tmuxSessionId: state.tmuxSessionId }
+            : extractTmuxSessionIdFromScope(reservation.sessionId)
+                ? { tmuxSessionId: extractTmuxSessionIdFromScope(reservation.sessionId) }
+                : {}),
+        tasks: nextTasks,
+        updatedAtMs: at
+    };
+    await ensureDir(path.dirname(filePath));
+    if (!next.tasks.length) {
+        await fs.rm(filePath, { force: true });
+    }
+    else {
+        await writeJsonFileAtomic(filePath, next);
+    }
+}

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

@@ -0,0 +1,98 @@
+export type ClockRecurrenceKind = 'daily' | 'weekly' | 'interval';
+export type ClockQuietHoursWindow = {
+    start: string;
+    end: string;
+};
+export type ClockTaskRecurrence = {
+    kind: ClockRecurrenceKind;
+    maxRuns?: number;
+    everyMinutes?: number;
+    quietHours?: ClockQuietHoursWindow[];
+};
+export type ClockTaskSetter = 'user' | 'agent';
+export type ClockTask = {
+    taskId: string;
+    sessionId: string;
+    dueAtMs: number;
+    createdAtMs: number;
+    updatedAtMs: number;
+    setBy: ClockTaskSetter;
+    prompt?: string;
+    task: string;
+    tool?: string;
+    arguments?: Record<string, unknown>;
+    urls?: string[];
+    paths?: string[];
+    deliveredAtMs?: number;
+    deliveryCount: number;
+    notBeforeRequestId?: string;
+    recurrence?: ClockTaskRecurrence;
+};
+export type ClockSessionMeta = {
+    taskRevision: number;
+    listedRevision: number;
+    lastListAtMs?: number;
+};
+export type ClockSessionState = {
+    version: 1;
+    sessionId: string;
+    tmuxSessionId?: string;
+    tasks: ClockTask[];
+    updatedAtMs: number;
+    meta?: ClockSessionMeta;
+};
+export type ClockReservation = {
+    reservationId: string;
+    sessionId: string;
+    taskIds: string[];
+    reservedAtMs: number;
+};
+export type ClockConfigSnapshot = {
+    enabled: boolean;
+    retentionMs: number;
+    dueWindowMs: number;
+    tickMs: number;
+    /**
+     * Whether clock_hold_flow is allowed for non-streaming (JSON) clients.
+     * Default: true (best-effort long-poll hold; clients can abort the connection).
+     */
+    holdNonStreaming: boolean;
+    /**
+     * Maximum time (ms) a single request is allowed to hold before followup.
+     * Default: 60s. Larger values increase resource usage and risk client/proxy timeouts.
+     */
+    holdMaxMs: number;
+};
+export type ClockScheduleItem = {
+    dueAtMs: number;
+    prompt?: string;
+    task: string;
+    setBy?: ClockTaskSetter;
+    tool?: string;
+    arguments?: Record<string, unknown>;
+    urls?: string[];
+    paths?: string[];
+    notBeforeRequestId?: string;
+    recurrence?: ClockTaskRecurrence;
+};
+export type ClockTaskUpdatePatch = {
+    dueAtMs?: number;
+    prompt?: string;
+    task?: string;
+    tool?: string | null;
+    arguments?: Record<string, unknown> | null;
+    urls?: string[] | null;
+    paths?: string[] | null;
+    notBeforeRequestId?: string | null;
+    recurrence?: ClockTaskRecurrence | null;
+    resetDelivery?: boolean;
+};
+export type ClockNtpState = {
+    version: 1;
+    offsetMs: number;
+    updatedAtMs: number;
+    source?: string;
+    rttMs?: number;
+    status: 'synced' | 'stale' | 'error' | 'disabled';
+    lastError?: string;
+};

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

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/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;