@jsonstudio/rcc 0.90.364 → 0.90.429

package/vendor/@jsonstudio/llms/dist/servertool/clock/ntp.js

@@ -1,318 +0,0 @@
-import dgram from 'node:dgram';
-import crypto from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { ensureDir, readSessionDirEnv, resolveClockNtpStateFile } from './paths.js';
-import { readJsonFile, writeJsonFileAtomic } from './io.js';
-import { getClockOffsetMs, setClockOffsetMs, nowMs as correctedNowMs } from './state.js';
-const DEFAULT_NTP_SERVERS = ['time.google.com', 'time.cloudflare.com', 'pool.ntp.org'];
-function isNtpDisabledByEnv() {
-    const raw = String(process.env.ROUTECODEX_CLOCK_NTP || '').trim().toLowerCase();
-    if (!raw)
-        return false;
-    return raw === '0' || raw === 'false' || raw === 'off' || raw === 'disable' || raw === 'disabled';
-}
-function clampNumber(value, min, max) {
-    if (!Number.isFinite(value))
-        return min;
-    return Math.max(min, Math.min(max, value));
-}
-function safeErrorMessage(err) {
-    try {
-        if (err instanceof Error)
-            return err.message || err.name;
-        return String(err ?? 'unknown');
-    }
-    catch {
-        return 'unknown';
-    }
-}
-function pad2(n) {
-    return n < 10 ? `0${n}` : String(n);
-}
-function pad3(n) {
-    if (n < 10)
-        return `00${n}`;
-    if (n < 100)
-        return `0${n}`;
-    return String(n);
-}
-function formatOffset(minutesEast) {
-    const sign = minutesEast >= 0 ? '+' : '-';
-    const abs = Math.abs(minutesEast);
-    const hh = Math.floor(abs / 60);
-    const mm = abs % 60;
-    return `${sign}${pad2(hh)}:${pad2(mm)}`;
-}
-export function resolveServerTimezone() {
-    try {
-        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        return typeof tz === 'string' && tz.trim().length ? tz.trim() : 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-export function formatLocalTime(ms) {
-    const d = new Date(ms);
-    const y = d.getFullYear();
-    const mo = pad2(d.getMonth() + 1);
-    const da = pad2(d.getDate());
-    const hh = pad2(d.getHours());
-    const mi = pad2(d.getMinutes());
-    const ss = pad2(d.getSeconds());
-    const mmm = pad3(d.getMilliseconds());
-    const minutesEast = -d.getTimezoneOffset();
-    return `${y}-${mo}-${da} ${hh}:${mi}:${ss}.${mmm} ${formatOffset(minutesEast)}`;
-}
-export function buildTimeTagLine(snapshot) {
-    // Markdown inline code blocks to reduce the chance of models "roleplaying" XML-like tags.
-    return `[Time/Date]: utc=\`${snapshot.utc}\` local=\`${snapshot.local}\` tz=\`${snapshot.timezone}\` nowMs=\`${snapshot.nowMs}\` ntpOffsetMs=\`${snapshot.ntp.offsetMs}\``;
-}
-const EMPTY_NTP_STATE = {
-    version: 1,
-    offsetMs: 0,
-    updatedAtMs: 0,
-    status: 'stale'
-};
-let loaded = false;
-let state = { ...EMPTY_NTP_STATE };
-let syncing = null;
-function coerceNtpState(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return { ...EMPTY_NTP_STATE };
-    }
-    const r = raw;
-    const offsetMs = typeof r.offsetMs === 'number' && Number.isFinite(r.offsetMs) ? Math.floor(r.offsetMs) : 0;
-    const updatedAtMs = typeof r.updatedAtMs === 'number' && Number.isFinite(r.updatedAtMs) ? Math.floor(r.updatedAtMs) : 0;
-    const statusRaw = typeof r.status === 'string' ? r.status.trim() : '';
-    const status = statusRaw === 'synced' || statusRaw === 'stale' || statusRaw === 'error' || statusRaw === 'disabled'
-        ? statusRaw
-        : updatedAtMs > 0
-            ? 'stale'
-            : 'stale';
-    const source = typeof r.source === 'string' && r.source.trim().length ? r.source.trim() : undefined;
-    const rttMs = typeof r.rttMs === 'number' && Number.isFinite(r.rttMs) ? Math.max(0, Math.floor(r.rttMs)) : undefined;
-    const lastError = typeof r.lastError === 'string' && r.lastError.trim().length ? r.lastError.trim() : undefined;
-    return { version: 1, offsetMs, updatedAtMs, status, ...(source ? { source } : {}), ...(rttMs !== undefined ? { rttMs } : {}), ...(lastError ? { lastError } : {}) };
-}
-async function loadStateOnce() {
-    if (loaded)
-        return;
-    loaded = true;
-    if (isNtpDisabledByEnv()) {
-        state = { ...EMPTY_NTP_STATE, status: 'disabled' };
-        setClockOffsetMs(0);
-        return;
-    }
-    const sessionDir = readSessionDirEnv();
-    if (!sessionDir) {
-        state = { ...EMPTY_NTP_STATE, status: 'stale' };
-        setClockOffsetMs(0);
-        return;
-    }
-    const filePath = resolveClockNtpStateFile(sessionDir);
-    try {
-        const raw = await readJsonFile(filePath);
-        state = coerceNtpState(raw);
-        setClockOffsetMs(state.offsetMs);
-    }
-    catch {
-        // missing/unreadable file: keep defaults
-        state = { ...EMPTY_NTP_STATE, status: 'stale' };
-        setClockOffsetMs(0);
-    }
-}
-async function persistState(next) {
-    const sessionDir = readSessionDirEnv();
-    if (!sessionDir)
-        return;
-    const filePath = resolveClockNtpStateFile(sessionDir);
-    await ensureDir(path.dirname(filePath));
-    try {
-        await fs.chmod(path.dirname(filePath), 0o700);
-    }
-    catch {
-        // best-effort
-    }
-    await writeJsonFileAtomic(filePath, next);
-}
-const NTP_EPOCH_OFFSET_SECONDS = 2208988800; // 1900-01-01 to 1970-01-01
-function msToNtpTimestamp(ms) {
-    const seconds = Math.floor(ms / 1000) + NTP_EPOCH_OFFSET_SECONDS;
-    const msRemainder = ms % 1000;
-    const fraction = Math.floor((msRemainder / 1000) * 2 ** 32);
-    return { seconds, fraction };
-}
-function ntpTimestampToMs(seconds, fraction) {
-    const unixSeconds = seconds - NTP_EPOCH_OFFSET_SECONDS;
-    const fracMs = Math.round((fraction / 2 ** 32) * 1000);
-    return unixSeconds * 1000 + fracMs;
-}
-async function querySntpOnce(server, timeoutMs) {
-    const socket = dgram.createSocket('udp4');
-    const req = Buffer.alloc(48);
-    req[0] = 0x23; // LI=0, VN=4, Mode=3 (client)
-    const t1SystemMs = Date.now();
-    const t1 = msToNtpTimestamp(t1SystemMs);
-    req.writeUInt32BE(t1.seconds >>> 0, 40);
-    req.writeUInt32BE(t1.fraction >>> 0, 44);
-    const res = await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            reject(new Error('ntp timeout'));
-        }, timeoutMs);
-        socket.once('error', (err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-        socket.once('message', (msg) => {
-            clearTimeout(timer);
-            resolve(msg);
-        });
-        socket.send(req, 123, server, (err) => {
-            if (err) {
-                clearTimeout(timer);
-                reject(err);
-            }
-        });
-    }).finally(() => {
-        try {
-            socket.close();
-        }
-        catch {
-            // ignore
-        }
-    });
-    if (!Buffer.isBuffer(res) || res.length < 48) {
-        throw new Error('invalid ntp response');
-    }
-    const t4SystemMs = Date.now();
-    const t2Seconds = res.readUInt32BE(32);
-    const t2Fraction = res.readUInt32BE(36);
-    const t3Seconds = res.readUInt32BE(40);
-    const t3Fraction = res.readUInt32BE(44);
-    const t2Ms = ntpTimestampToMs(t2Seconds, t2Fraction);
-    const t3Ms = ntpTimestampToMs(t3Seconds, t3Fraction);
-    const offsetMs = ((t2Ms - t1SystemMs) + (t3Ms - t4SystemMs)) / 2;
-    const rttMs = (t4SystemMs - t1SystemMs) - (t3Ms - t2Ms);
-    return {
-        offsetMs: Math.floor(clampNumber(offsetMs, -24 * 60 * 60_000, 24 * 60 * 60_000)),
-        rttMs: Math.max(0, Math.floor(rttMs))
-    };
-}
-function resolveNtpServers() {
-    const raw = String(process.env.ROUTECODEX_CLOCK_NTP_SERVERS || '').trim();
-    if (!raw)
-        return [...DEFAULT_NTP_SERVERS];
-    const list = raw.split(',').map((s) => s.trim()).filter(Boolean);
-    return list.length ? list : [...DEFAULT_NTP_SERVERS];
-}
-export async function syncClockWithNtpOnce() {
-    await loadStateOnce();
-    if (isNtpDisabledByEnv()) {
-        state = { ...state, status: 'disabled', offsetMs: 0 };
-        setClockOffsetMs(0);
-        return;
-    }
-    const servers = resolveNtpServers();
-    const timeoutMs = (() => {
-        const raw = Number(process.env.ROUTECODEX_CLOCK_NTP_TIMEOUT_MS ?? 800);
-        return Number.isFinite(raw) ? Math.max(100, Math.floor(raw)) : 800;
-    })();
-    let lastErr;
-    for (const server of servers.slice(0, 5)) {
-        try {
-            const result = await querySntpOnce(server, timeoutMs);
-            const updatedAtMs = Date.now();
-            const next = {
-                version: 1,
-                offsetMs: result.offsetMs,
-                updatedAtMs,
-                source: server,
-                rttMs: result.rttMs,
-                status: 'synced'
-            };
-            state = next;
-            setClockOffsetMs(result.offsetMs);
-            await persistState(next);
-            return;
-        }
-        catch (err) {
-            lastErr = safeErrorMessage(err);
-        }
-    }
-    state = {
-        ...state,
-        status: 'error',
-        lastError: lastErr || 'ntp failed',
-        updatedAtMs: state.updatedAtMs || Date.now()
-    };
-}
-export async function startClockNtpSyncIfNeeded(_config) {
-    await loadStateOnce();
-    if (isNtpDisabledByEnv())
-        return;
-    if (syncing)
-        return syncing;
-    // Best-effort background sync; do not block the request pipeline.
-    syncing = (async () => {
-        try {
-            await syncClockWithNtpOnce();
-        }
-        catch {
-            // best-effort
-        }
-        finally {
-            syncing = null;
-        }
-    })();
-    return syncing;
-}
-export async function getClockNtpState() {
-    await loadStateOnce();
-    const now = Date.now();
-    const staleAfterMs = (() => {
-        const raw = Number(process.env.ROUTECODEX_CLOCK_NTP_STALE_AFTER_MS ?? 6 * 60 * 60_000);
-        return Number.isFinite(raw) ? Math.max(60_000, Math.floor(raw)) : 6 * 60 * 60_000;
-    })();
-    const age = state.updatedAtMs > 0 ? Math.max(0, now - state.updatedAtMs) : Number.POSITIVE_INFINITY;
-    if (state.status === 'synced' && age > staleAfterMs) {
-        return { ...state, status: 'stale' };
-    }
-    return { ...state };
-}
-export async function getClockTimeSnapshot() {
-    await loadStateOnce();
-    const now = correctedNowMs();
-    const d = new Date(now);
-    const utc = (() => {
-        try {
-            return d.toISOString();
-        }
-        catch {
-            return new Date(0).toISOString();
-        }
-    })();
-    const timezone = resolveServerTimezone();
-    const local = formatLocalTime(now);
-    const ntp = await getClockNtpState();
-    return {
-        active: true,
-        nowMs: now,
-        utc,
-        local,
-        timezone,
-        ntp
-    };
-}
-export function getCurrentClockOffsetMs() {
-    return getClockOffsetMs();
-}
-export function buildStableToolCallId(prefix = 'call_clock') {
-    try {
-        return `${prefix}_${crypto.randomUUID()}`;
-    }
-    catch {
-        return `${prefix}_${Date.now()}_${Math.random().toString(16).slice(2)}`;
-    }
-}

package/vendor/@jsonstudio/llms/dist/servertool/clock/paths.d.ts

@@ -1,5 +0,0 @@
-export declare function readSessionDirEnv(): string;
-export declare function resolveClockDir(sessionDir: string): string;
-export declare function resolveClockNtpStateFile(sessionDir: string): string;
-export declare function resolveClockStateFile(sessionDir: string, sessionId: string): string | null;
-export declare function ensureDir(dir: string): Promise<void>;

package/vendor/@jsonstudio/llms/dist/servertool/clock/paths.js

@@ -1,28 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-export function readSessionDirEnv() {
-    return String(process.env.ROUTECODEX_SESSION_DIR || '').trim();
-}
-function sanitizeSegment(value) {
-    return String(value || '')
-        .trim()
-        .replace(/[^a-zA-Z0-9_.-]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_+|_+$/g, '');
-}
-export function resolveClockDir(sessionDir) {
-    return path.join(sessionDir, 'clock');
-}
-export function resolveClockNtpStateFile(sessionDir) {
-    return path.join(resolveClockDir(sessionDir), 'ntp-state.json');
-}
-export function resolveClockStateFile(sessionDir, sessionId) {
-    const safe = sanitizeSegment(sessionId);
-    if (!safe) {
-        return null;
-    }
-    return path.join(resolveClockDir(sessionDir), `${safe}.json`);
-}
-export async function ensureDir(dir) {
-    await fs.mkdir(dir, { recursive: true });
-}

package/vendor/@jsonstudio/llms/dist/servertool/clock/recurrence.d.ts

@@ -1,7 +0,0 @@
-import type { ClockTaskRecurrence, ClockQuietHoursWindow } from './types.js';
-export declare function normalizeQuietHours(raw: unknown): ClockQuietHoursWindow[] | undefined;
-export declare function normalizeRecurrence(raw: unknown): ClockTaskRecurrence | undefined;
-export declare function recurrenceHasRemainingRuns(recurrence: ClockTaskRecurrence, deliveryCountRaw: unknown): boolean;
-export declare function recurrenceRemainingRuns(recurrence: ClockTaskRecurrence, deliveryCountRaw: unknown): number | null;
-export declare function shiftOutOfQuietHours(ms: number, quietHours: ClockQuietHoursWindow[] | undefined): number;
-export declare function computeNextRecurringDueAtMs(currentDueAtMs: number, recurrence: ClockTaskRecurrence, atMs: number): number | null;

package/vendor/@jsonstudio/llms/dist/servertool/clock/recurrence.js

@@ -1,248 +0,0 @@
-const MAX_ITERATIONS = 100_000;
-function parseClockTimeToken(raw) {
-    const value = raw.trim().toLowerCase();
-    const match = value.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i);
-    if (!match) {
-        return null;
-    }
-    let hour = Number.parseInt(match[1] || '', 10);
-    const minute = Number.parseInt(match[2] || '0', 10);
-    const suffix = (match[3] || '').toLowerCase();
-    if (!Number.isFinite(hour) || !Number.isFinite(minute) || minute < 0 || minute > 59) {
-        return null;
-    }
-    if (suffix) {
-        if (hour < 1 || hour > 12) {
-            return null;
-        }
-        if (suffix === 'am') {
-            hour = hour % 12;
-        }
-        else {
-            hour = (hour % 12) + 12;
-        }
-    }
-    else if (hour < 0 || hour > 23) {
-        return null;
-    }
-    return hour * 60 + minute;
-}
-function normalizeClockTimeString(raw) {
-    if (typeof raw !== 'string') {
-        return undefined;
-    }
-    const minutes = parseClockTimeToken(raw);
-    if (!Number.isFinite(minutes)) {
-        return undefined;
-    }
-    const safeMinutes = Math.max(0, Math.min(23 * 60 + 59, Math.floor(minutes)));
-    const hour = Math.floor(safeMinutes / 60).toString().padStart(2, '0');
-    const minute = Math.floor(safeMinutes % 60).toString().padStart(2, '0');
-    return `${hour}:${minute}`;
-}
-function normalizeQuietHoursWindow(raw) {
-    if (typeof raw === 'string') {
-        const parts = raw.split('-');
-        if (parts.length !== 2) {
-            return undefined;
-        }
-        const start = normalizeClockTimeString(parts[0]);
-        const end = normalizeClockTimeString(parts[1]);
-        if (!start || !end || start === end) {
-            return undefined;
-        }
-        return { start, end };
-    }
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return undefined;
-    }
-    const record = raw;
-    const start = normalizeClockTimeString(record.start ?? record.from ?? record.begin);
-    const end = normalizeClockTimeString(record.end ?? record.to ?? record.until);
-    if (!start || !end || start === end) {
-        return undefined;
-    }
-    return { start, end };
-}
-export function normalizeQuietHours(raw) {
-    if (raw === undefined || raw === null || raw === false) {
-        return undefined;
-    }
-    const entries = Array.isArray(raw) ? raw : [raw];
-    const windows = entries
-        .map((entry) => normalizeQuietHoursWindow(entry))
-        .filter((entry) => Boolean(entry));
-    return windows.length ? windows : undefined;
-}
-function parseRecurrenceKind(raw) {
-    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
-    if (!value) {
-        return undefined;
-    }
-    if (value === 'daily' || value === 'day') {
-        return 'daily';
-    }
-    if (value === 'weekly' || value === 'week') {
-        return 'weekly';
-    }
-    if (value === 'interval' || value === 'every_minutes' || value === 'every-minutes' || value === 'everyminutes') {
-        return 'interval';
-    }
-    return undefined;
-}
-function normalizeMaxRuns(raw, infiniteRaw) {
-    const infinite = infiniteRaw === true
-        || (typeof infiniteRaw === 'string' && ['true', '1', 'yes', 'on'].includes(infiniteRaw.trim().toLowerCase()))
-        || (typeof raw === 'string' && ['infinite', 'infinity', 'forever', 'unlimited', '*'].includes(raw.trim().toLowerCase()));
-    if (infinite) {
-        return undefined;
-    }
-    if (raw === undefined || raw === null || raw === '') {
-        return undefined;
-    }
-    const num = Number(raw);
-    const maxRuns = Number.isFinite(num) ? Math.floor(num) : NaN;
-    if (!Number.isFinite(maxRuns) || maxRuns <= 0) {
-        return null;
-    }
-    return maxRuns;
-}
-export function normalizeRecurrence(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return undefined;
-    }
-    const record = raw;
-    const kind = parseRecurrenceKind(record.kind ?? record.type ?? record.mode ?? record.every);
-    if (!kind) {
-        return undefined;
-    }
-    const maxRuns = normalizeMaxRuns(record.maxRuns, record.infinite);
-    if (maxRuns === null) {
-        return undefined;
-    }
-    const quietHours = normalizeQuietHours(record.quietHours ?? record.skipWindows ?? record.blackoutHours);
-    if (kind === 'interval') {
-        const everyRaw = Number(record.everyMinutes ?? record.minutes);
-        const everyMinutes = Number.isFinite(everyRaw) ? Math.floor(everyRaw) : NaN;
-        if (!Number.isFinite(everyMinutes) || everyMinutes <= 0) {
-            return undefined;
-        }
-        return {
-            kind,
-            everyMinutes,
-            ...(maxRuns === undefined ? {} : { maxRuns }),
-            ...(quietHours ? { quietHours } : {})
-        };
-    }
-    return {
-        kind,
-        ...(maxRuns === undefined ? {} : { maxRuns }),
-        ...(quietHours ? { quietHours } : {})
-    };
-}
-export function recurrenceHasRemainingRuns(recurrence, deliveryCountRaw) {
-    const deliveryCount = typeof deliveryCountRaw === 'number' && Number.isFinite(deliveryCountRaw)
-        ? Math.max(0, Math.floor(deliveryCountRaw))
-        : 0;
-    if (typeof recurrence.maxRuns !== 'number' || !Number.isFinite(recurrence.maxRuns)) {
-        return true;
-    }
-    return deliveryCount < recurrence.maxRuns;
-}
-export function recurrenceRemainingRuns(recurrence, deliveryCountRaw) {
-    if (typeof recurrence.maxRuns !== 'number' || !Number.isFinite(recurrence.maxRuns)) {
-        return null;
-    }
-    const deliveryCount = typeof deliveryCountRaw === 'number' && Number.isFinite(deliveryCountRaw)
-        ? Math.max(0, Math.floor(deliveryCountRaw))
-        : 0;
-    return Math.max(0, Math.floor(recurrence.maxRuns) - deliveryCount);
-}
-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 readMinutesOfDay(date) {
-    return date.getHours() * 60 + date.getMinutes();
-}
-function parseWindowMinutes(window) {
-    const start = parseClockTimeToken(window.start);
-    const end = parseClockTimeToken(window.end);
-    if (!Number.isFinite(start) || !Number.isFinite(end) || start === end) {
-        return null;
-    }
-    return { start: Math.floor(start), end: Math.floor(end) };
-}
-function isWithinWindow(minutes, window) {
-    if (window.start < window.end) {
-        return minutes >= window.start && minutes < window.end;
-    }
-    return minutes >= window.start || minutes < window.end;
-}
-function resolveWindowEndMs(ms, window) {
-    const date = new Date(ms);
-    const hours = Math.floor(window.end / 60);
-    const minutes = window.end % 60;
-    const currentMinutes = readMinutesOfDay(date);
-    const dayOffset = window.start < window.end
-        ? 0
-        : currentMinutes >= window.start
-            ? 1
-            : 0;
-    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + dayOffset, hours, minutes, 0, 0).getTime();
-}
-export function shiftOutOfQuietHours(ms, quietHours) {
-    let candidate = Math.floor(ms);
-    if (!Array.isArray(quietHours) || quietHours.length === 0) {
-        return candidate;
-    }
-    for (let index = 0; index < MAX_ITERATIONS; index += 1) {
-        const date = new Date(candidate);
-        const minutes = readMinutesOfDay(date);
-        const blockingEnds = quietHours
-            .map((window) => parseWindowMinutes(window))
-            .filter((window) => Boolean(window))
-            .filter((window) => isWithinWindow(minutes, window))
-            .map((window) => resolveWindowEndMs(candidate, window));
-        if (!blockingEnds.length) {
-            return candidate;
-        }
-        candidate = Math.max(...blockingEnds);
-    }
-    return candidate;
-}
-export function computeNextRecurringDueAtMs(currentDueAtMs, recurrence, atMs) {
-    if (!Number.isFinite(currentDueAtMs)) {
-        return null;
-    }
-    const stepMs = resolveRecurringStepMs(recurrence);
-    if (!stepMs || stepMs <= 0) {
-        return null;
-    }
-    let candidate = Math.floor(currentDueAtMs) + stepMs;
-    for (let index = 0; index < MAX_ITERATIONS; index += 1) {
-        if (candidate <= atMs) {
-            candidate += stepMs;
-            continue;
-        }
-        const shifted = shiftOutOfQuietHours(candidate, recurrence.quietHours);
-        if (!Number.isFinite(shifted) || shifted <= atMs) {
-            candidate += stepMs;
-            continue;
-        }
-        return Math.floor(shifted);
-    }
-    return null;
-}

package/vendor/@jsonstudio/llms/dist/servertool/clock/session-scope.d.ts

@@ -1,3 +0,0 @@
-export declare function buildClockSessionScopeFromDaemonId(_daemonId: string): string;
-export declare function extractClockDaemonIdFromSessionScope(_sessionScope: string): string | null;
-export declare function resolveClockSessionScope(primary?: Record<string, unknown> | null, fallback?: Record<string, unknown> | null): string | null;

package/vendor/@jsonstudio/llms/dist/servertool/clock/session-scope.js

@@ -1,41 +0,0 @@
-import { resolveClockSessionScopeWithNative } from '../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-semantics.js';
-export function buildClockSessionScopeFromDaemonId(_daemonId) {
-    return '';
-}
-export function extractClockDaemonIdFromSessionScope(_sessionScope) {
-    return null;
-}
-function readToken(value) {
-    if (typeof value !== 'string') {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed ? trimmed : null;
-}
-function readTmuxSessionId(record) {
-    if (!record || typeof record !== 'object') {
-        return null;
-    }
-    return (readToken(record.tmuxSessionId) ||
-        readToken(record.tmux_session_id) ||
-        readToken(record.clientTmuxSessionId) ||
-        readToken(record.client_tmux_session_id));
-}
-function readSessionId(record) {
-    if (!record || typeof record !== 'object') {
-        return null;
-    }
-    return readToken(record.sessionId) || readToken(record.session_id) || readToken(record.conversationId) || readToken(record.conversation_id);
-}
-export function resolveClockSessionScope(primary, fallback) {
-    const native = resolveClockSessionScopeWithNative(primary, fallback);
-    if (native && native.trim()) {
-        return native;
-    }
-    const tmuxSessionId = readTmuxSessionId(primary) || readTmuxSessionId(fallback);
-    if (tmuxSessionId) {
-        return `tmux:${tmuxSessionId}`;
-    }
-    const sessionId = readSessionId(primary) || readSessionId(fallback);
-    return sessionId || null;
-}

package/vendor/@jsonstudio/llms/dist/servertool/clock/session-store.d.ts

@@ -1,3 +0,0 @@
-import type { ClockConfigSnapshot, ClockSessionState } from './types.js';
-export declare function loadClockSessionState(sessionId: string, config: ClockConfigSnapshot): Promise<ClockSessionState>;
-export declare function clearClockSession(sessionId: string): Promise<void>;