@jsonstudio/rcc 0.90.352 → 0.90.364

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

@@ -0,0 +1,318 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,248 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,3 @@
+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>;