@jsonstudio/rcc 0.90.367 → 0.90.429

package/vendor/llmswitch-core/dist/router/virtual-router/types.js

@@ -1,34 +0,0 @@
-/**
- * Virtual Router 类型定义
- */
-export const DEFAULT_MODEL_CONTEXT_TOKENS = 200_000;
-export const DEFAULT_ROUTE = 'default';
-export const ROUTE_PRIORITY = [
-    'multimodal',
-    'vision',
-    'longcontext',
-    'web_search',
-    'thinking',
-    'coding',
-    'search',
-    'tools',
-    'background',
-    DEFAULT_ROUTE
-];
-export var VirtualRouterErrorCode;
-(function (VirtualRouterErrorCode) {
-    VirtualRouterErrorCode["NO_STANDARDIZED_REQUEST"] = "NO_STANDARDIZED_REQUEST";
-    VirtualRouterErrorCode["ROUTE_NOT_FOUND"] = "ROUTE_NOT_FOUND";
-    VirtualRouterErrorCode["PROVIDER_NOT_AVAILABLE"] = "PROVIDER_NOT_AVAILABLE";
-    VirtualRouterErrorCode["CONFIG_ERROR"] = "CONFIG_ERROR";
-})(VirtualRouterErrorCode || (VirtualRouterErrorCode = {}));
-export class VirtualRouterError extends Error {
-    code;
-    details;
-    constructor(message, code, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'VirtualRouterError';
-    }
-}

package/vendor/llmswitch-core/dist/runtime/user-data-paths.d.ts

@@ -1,5 +0,0 @@
-export declare function resolveRccUserDir(homeDir?: string): string;
-export declare function resolveLegacyRouteCodexUserDir(homeDir?: string): string;
-export declare function resolveRccPath(...segments: string[]): string;
-export declare function resolveLegacyRouteCodexPath(...segments: string[]): string;
-export declare function resolveRccPathForRead(...segments: string[]): string;

package/vendor/llmswitch-core/dist/runtime/user-data-paths.js

@@ -1,43 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-const PRIMARY_DIR_NAME = '.rcc';
-const LEGACY_DIR_NAME = '.routecodex';
-const USER_DIR_ENV_KEYS = ['RCC_HOME', 'ROUTECODEX_USER_DIR', 'ROUTECODEX_HOME'];
-function resolveHomeDir(homeDir) {
-    const explicit = String(homeDir || '').trim();
-    if (explicit) {
-        return path.resolve(explicit);
-    }
-    const envHome = String(process.env.HOME || '').trim();
-    if (envHome) {
-        return path.resolve(envHome);
-    }
-    return path.resolve(os.homedir());
-}
-function expandHome(value, homeDir) {
-    if (!value.startsWith('~/')) {
-        return value;
-    }
-    return path.join(resolveHomeDir(homeDir), value.slice(2));
-}
-export function resolveRccUserDir(homeDir) {
-    for (const key of USER_DIR_ENV_KEYS) {
-        const raw = String(process.env[key] || '').trim();
-        if (raw) {
-            return path.resolve(expandHome(raw, homeDir));
-        }
-    }
-    return path.join(resolveHomeDir(homeDir), PRIMARY_DIR_NAME);
-}
-export function resolveLegacyRouteCodexUserDir(homeDir) {
-    return path.join(resolveHomeDir(homeDir), LEGACY_DIR_NAME);
-}
-export function resolveRccPath(...segments) {
-    return path.join(resolveRccUserDir(), ...segments);
-}
-export function resolveLegacyRouteCodexPath(...segments) {
-    return path.join(resolveLegacyRouteCodexUserDir(), ...segments);
-}
-export function resolveRccPathForRead(...segments) {
-    return resolveRccPath(...segments);
-}

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

@@ -1,17 +0,0 @@
-import type { ClockConfigSnapshot } from './types.js';
-export declare const CLOCK_CONFIG_DEFAULTS: {
-    readonly retentionMs: number;
-    readonly dueWindowMs: 0;
-    readonly tickMs: 60000;
-    readonly holdNonStreaming: true;
-    readonly holdMaxMs: 60000;
-};
-export declare function normalizeClockConfig(raw: unknown): ClockConfigSnapshot | null;
-/**
- * Resolve the effective clock config for a request/session.
- *
- * - If a config object exists and enabled=true -> return normalized config.
- * - If the config is absent (undefined) -> default-enable using CLOCK_CONFIG_DEFAULTS.
- * - If the config is explicitly present but disabled/invalid -> return null.
- */
-export declare function resolveClockConfig(raw: unknown): ClockConfigSnapshot | null;

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

@@ -1,48 +0,0 @@
-import { resolveClockConfigWithNative } from '../../router/virtual-router/engine-selection/native-chat-process-clock-reminder-semantics.js';
-export const CLOCK_CONFIG_DEFAULTS = {
-    retentionMs: 20 * 60_000,
-    dueWindowMs: 0,
-    tickMs: 60_000,
-    holdNonStreaming: true,
-    holdMaxMs: 60_000
-};
-function toClockConfigSnapshot(value) {
-    if (!value) {
-        return null;
-    }
-    if (value.enabled !== true ||
-        typeof value.retentionMs !== 'number' ||
-        typeof value.dueWindowMs !== 'number' ||
-        typeof value.tickMs !== 'number' ||
-        typeof value.holdNonStreaming !== 'boolean' ||
-        typeof value.holdMaxMs !== 'number') {
-        return null;
-    }
-    return {
-        enabled: true,
-        retentionMs: value.retentionMs,
-        dueWindowMs: value.dueWindowMs,
-        tickMs: value.tickMs,
-        holdNonStreaming: value.holdNonStreaming,
-        holdMaxMs: value.holdMaxMs
-    };
-}
-export function normalizeClockConfig(raw) {
-    const resolved = resolveClockConfigWithNative(raw, false);
-    return toClockConfigSnapshot(resolved);
-}
-/**
- * Resolve the effective clock config for a request/session.
- *
- * - If a config object exists and enabled=true -> return normalized config.
- * - If the config is absent (undefined) -> default-enable using CLOCK_CONFIG_DEFAULTS.
- * - If the config is explicitly present but disabled/invalid -> return null.
- */
-export function resolveClockConfig(raw) {
-    const resolved = resolveClockConfigWithNative(raw, raw === undefined);
-    const normalized = toClockConfigSnapshot(resolved);
-    if (normalized) {
-        return normalized;
-    }
-    return null;
-}

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

@@ -1,24 +0,0 @@
-import type { ClockConfigSnapshot } from "./types.js";
-type ClockRuntimeHooks = {
-    isTmuxSessionAlive?: (tmuxSessionId: string) => boolean | Promise<boolean>;
-    dispatchDueTask?: (request: {
-        sessionId: string;
-        tmuxSessionId: string;
-        task: unknown;
-        injectText: string;
-    }) => Promise<{
-        ok: boolean;
-        cleanupSession?: boolean;
-        reason?: string;
-    } | null> | {
-        ok: boolean;
-        cleanupSession?: boolean;
-        reason?: string;
-    } | null;
-};
-export declare function setClockRuntimeHooks(hooks?: ClockRuntimeHooks): void;
-export declare function resetClockRuntimeHooksForTests(): void;
-export declare function startClockDaemonIfNeeded(config: ClockConfigSnapshot): Promise<void>;
-export declare function stopClockDaemonForTests(): Promise<void>;
-export declare function runClockDaemonTickForTests(): Promise<void>;
-export {};

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

@@ -1,207 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { readSessionDirEnv, resolveClockDir } from "./paths.js";
-import { cleanExpiredTasks, coerceState, nowMs } from "./state.js";
-import { readJsonFile, writeJsonFileAtomic } from "./io.js";
-import { startClockNtpSyncIfNeeded } from "./ntp.js";
-import { selectDueUndeliveredTasks, commitClockReservation, formatClockReminderText } from "./tasks.js";
-let daemonStarted = false;
-let daemonTimer;
-let daemonConfig;
-let runtimeHooks;
-export function setClockRuntimeHooks(hooks) {
-    runtimeHooks = hooks;
-}
-export function resetClockRuntimeHooksForTests() {
-    runtimeHooks = undefined;
-}
-function readString(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed || undefined;
-}
-function resolveStateSessionId(raw, fallbackFileSessionId) {
-    const rawSessionId = raw && typeof raw === "object"
-        ? readString(raw.sessionId)
-        : undefined;
-    return rawSessionId || fallbackFileSessionId;
-}
-function resolveStateTmuxSessionId(raw, sessionId) {
-    const rawTmuxSessionId = raw && typeof raw === "object"
-        ? readString(raw.tmuxSessionId)
-        : undefined;
-    if (rawTmuxSessionId) {
-        return rawTmuxSessionId;
-    }
-    if (sessionId.startsWith("tmux:")) {
-        const tmuxSessionId = sessionId.slice("tmux:".length).trim();
-        return tmuxSessionId || undefined;
-    }
-    return undefined;
-}
-function buildInjectText(task) {
-    return formatClockReminderText(task);
-}
-export async function startClockDaemonIfNeeded(config) {
-    daemonConfig = config;
-    if (daemonStarted) {
-        return;
-    }
-    const sessionDir = readSessionDirEnv();
-    if (!sessionDir) {
-        return;
-    }
-    daemonStarted = true;
-    // Best-effort NTP sync (do not block daemon startup).
-    void startClockNtpSyncIfNeeded(config);
-    const tickOnce = async () => {
-        const effective = daemonConfig;
-        if (!effective)
-            return;
-        const base = readSessionDirEnv();
-        if (!base)
-            return;
-        const dir = resolveClockDir(base);
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            const at = nowMs();
-            for (const entry of entries) {
-                if (!entry.isFile())
-                    continue;
-                if (!entry.name.endsWith(".json"))
-                    continue;
-                const filePath = path.join(dir, entry.name);
-                try {
-                    const raw = await readJsonFile(filePath);
-                    const sessionId = resolveStateSessionId(raw, entry.name.slice(0, -".json".length));
-                    const state = coerceState(raw, sessionId);
-                    const tmuxSessionId = resolveStateTmuxSessionId(raw, sessionId);
-                    const isAlive = runtimeHooks?.isTmuxSessionAlive;
-                    if (isAlive && tmuxSessionId) {
-                        const alive = await Promise.resolve(isAlive(tmuxSessionId));
-                        if (!alive) {
-                            await fs.rm(filePath, { force: true });
-                            continue;
-                        }
-                    }
-                    const dueTasks = selectDueUndeliveredTasks(state.tasks, effective, at);
-                    if (dueTasks.length > 0 &&
-                        runtimeHooks?.dispatchDueTask &&
-                        tmuxSessionId) {
-                        for (const task of dueTasks) {
-                            const injectText = buildInjectText(task);
-                            try {
-                                const result = await Promise.resolve(runtimeHooks.dispatchDueTask({
-                                    sessionId,
-                                    tmuxSessionId,
-                                    task,
-                                    injectText,
-                                }));
-                                if (result?.ok) {
-                                    const reservation = {
-                                        reservationId: `daemon:${task.taskId}:${at}`,
-                                        sessionId,
-                                        taskIds: [task.taskId],
-                                        reservedAtMs: at,
-                                    };
-                                    await commitClockReservation(reservation, effective);
-                                }
-                            }
-                            catch {
-                                // best-effort dispatch
-                            }
-                        }
-                    }
-                    const cleaned = cleanExpiredTasks(state.tasks, effective, at);
-                    if (!cleaned.length) {
-                        await fs.rm(filePath, { force: true });
-                        continue;
-                    }
-                    if (cleaned.length !== state.tasks.length) {
-                        const next = {
-                            ...state,
-                            tasks: cleaned,
-                            updatedAtMs: at,
-                        };
-                        await writeJsonFileAtomic(filePath, next);
-                    }
-                }
-                catch {
-                    // best-effort: ignore per-file errors
-                }
-            }
-        }
-        catch {
-            // best-effort: ignore global scan errors
-        }
-    };
-    // Startup scan (best-effort).
-    void tickOnce();
-    if (config.tickMs > 0) {
-        daemonTimer = setInterval(() => {
-            void tickOnce();
-        }, config.tickMs);
-        daemonTimer.unref?.();
-    }
-}
-export async function stopClockDaemonForTests() {
-    if (daemonTimer) {
-        clearInterval(daemonTimer);
-        daemonTimer = undefined;
-    }
-    daemonStarted = false;
-    daemonConfig = undefined;
-}
-export async function runClockDaemonTickForTests() {
-    const effective = daemonConfig;
-    if (!effective)
-        return;
-    const base = readSessionDirEnv();
-    if (!base)
-        return;
-    const dir = resolveClockDir(base);
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    const at = nowMs();
-    for (const entry of entries) {
-        if (!entry.isFile())
-            continue;
-        if (!entry.name.endsWith(".json"))
-            continue;
-        const filePath = path.join(dir, entry.name);
-        const raw = await readJsonFile(filePath);
-        const sessionId = resolveStateSessionId(raw, entry.name.slice(0, -".json".length));
-        const state = coerceState(raw, sessionId);
-        const tmuxSessionId = resolveStateTmuxSessionId(raw, sessionId);
-        const isAlive = runtimeHooks?.isTmuxSessionAlive;
-        if (isAlive && tmuxSessionId) {
-            const alive = await Promise.resolve(isAlive(tmuxSessionId));
-            if (!alive) {
-                await fs.rm(filePath, { force: true });
-                continue;
-            }
-        }
-        const dueTasks = selectDueUndeliveredTasks(state.tasks, effective, at);
-        if (dueTasks.length > 0 && runtimeHooks?.dispatchDueTask && tmuxSessionId) {
-            for (const task of dueTasks) {
-                const injectText = buildInjectText(task);
-                const result = await Promise.resolve(runtimeHooks.dispatchDueTask({
-                    sessionId,
-                    tmuxSessionId,
-                    task,
-                    injectText,
-                }));
-                if (result?.ok) {
-                    const reservation = {
-                        reservationId: `daemon:${task.taskId}:${at}`,
-                        sessionId,
-                        taskIds: [task.taskId],
-                        reservedAtMs: at,
-                    };
-                    await commitClockReservation(reservation, effective);
-                }
-            }
-        }
-    }
-}

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

@@ -1,2 +0,0 @@
-export declare function readJsonFile(filePath: string): Promise<unknown>;
-export declare function writeJsonFileAtomic(filePath: string, value: unknown): Promise<void>;

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

@@ -1,14 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-export async function readJsonFile(filePath) {
-    const buf = await fs.readFile(filePath);
-    return JSON.parse(buf.toString('utf8'));
-}
-export async function writeJsonFileAtomic(filePath, value) {
-    const dir = path.dirname(filePath);
-    await fs.mkdir(dir, { recursive: true });
-    const tmp = path.join(dir, `.tmp_${path.basename(filePath)}_${process.pid}_${Date.now()}_${Math.random().toString(16).slice(2)}`);
-    const payload = JSON.stringify(value, null, 2);
-    await fs.writeFile(tmp, payload, 'utf8');
-    await fs.rename(tmp, filePath);
-}

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

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

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

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

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

@@ -1,18 +0,0 @@
-import type { ClockConfigSnapshot, ClockNtpState } from './types.js';
-export declare function resolveServerTimezone(): string;
-export declare function formatLocalTime(ms: number): string;
-export declare function buildTimeTagLine(snapshot: ClockTimeSnapshot): string;
-export type ClockTimeSnapshot = {
-    active: boolean;
-    nowMs: number;
-    utc: string;
-    local: string;
-    timezone: string;
-    ntp: ClockNtpState;
-};
-export declare function syncClockWithNtpOnce(): Promise<void>;
-export declare function startClockNtpSyncIfNeeded(_config?: ClockConfigSnapshot): Promise<void>;
-export declare function getClockNtpState(): Promise<ClockNtpState>;
-export declare function getClockTimeSnapshot(): Promise<ClockTimeSnapshot>;
-export declare function getCurrentClockOffsetMs(): number;
-export declare function buildStableToolCallId(prefix?: string): string;