@jagilber-org/index-server 1.22.0

package/dist/config/runtimeConfig.js

@@ -0,0 +1,380 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_PROFILES = void 0;
+exports.loadRuntimeConfig = loadRuntimeConfig;
+exports.getRuntimeConfig = getRuntimeConfig;
+exports.reloadRuntimeConfig = reloadRuntimeConfig;
+/**
+ * Unified runtime configuration loader — thin aggregate.
+ *
+ * All configuration is driven by INDEX_SERVER_ prefixed env vars.
+ * See docs/configuration.md for the full reference.
+ *
+ * Domain modules handle parsing for their respective areas:
+ *   - serverConfig.ts  : MCP server, bootstrap, transport, logging, metrics, tracing
+ *   - dashboardConfig.ts : HTTP server, TLS, WebSocket, persistence
+ *   - featureConfig.ts : feature flags, feedback, messaging, semantic, graph, storage
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const envUtils_1 = require("../utils/envUtils");
+const configUtils_1 = require("./configUtils");
+const dirConstants_1 = require("./dirConstants");
+const defaultValues_1 = require("./defaultValues");
+const serverConfig_1 = require("./serverConfig");
+const dashboardConfig_1 = require("./dashboardConfig");
+const featureConfig_1 = require("./featureConfig");
+function parseTiming() {
+    const map = {};
+    const timingSrc = process.env.INDEX_SERVER_TIMING_JSON;
+    if (timingSrc) {
+        let obj;
+        if (timingSrc.startsWith('{'))
+            obj = (0, configUtils_1.parseJSONMaybe)(timingSrc);
+        else if (fs_1.default.existsSync(timingSrc))
+            obj = (0, configUtils_1.parseJSONMaybe)(fs_1.default.readFileSync(timingSrc, 'utf8'));
+        if (obj && typeof obj === 'object') {
+            for (const [k, v] of Object.entries(obj)) {
+                if (typeof v === 'number' && Number.isFinite(v))
+                    map[k] = v;
+            }
+        }
+    }
+    return map;
+}
+function deriveIndexMode() {
+    const explicit = process.env.INDEX_SERVER_CACHE_MODE;
+    if (explicit)
+        return explicit;
+    const memo = process.env.INDEX_SERVER_MEMOIZE === '1';
+    const hash = process.env.INDEX_SERVER_MEMOIZE_HASH === '1';
+    const reload = process.env.INDEX_SERVER_ALWAYS_RELOAD === '1';
+    if (reload && memo && hash)
+        return 'reload+memo';
+    if (reload && memo)
+        return 'reload+memo';
+    if (reload)
+        return 'reload';
+    if (memo && hash)
+        return 'memoize+hash';
+    if (memo)
+        return 'memoize';
+    return 'normal';
+}
+function parseTrace() {
+    const set = new Set();
+    const raw = process.env.INDEX_SERVER_TRACE;
+    if (raw) {
+        raw.split(',').map(s => s.trim()).filter(Boolean).forEach(v => set.add(v));
+    }
+    return set;
+}
+function parseInitFeatures() {
+    const set = new Set();
+    const raw = process.env.INDEX_SERVER_INIT_FEATURES;
+    if (raw) {
+        raw.split(',').map(s => s.trim()).filter(Boolean).forEach(v => set.add(v));
+    }
+    return set;
+}
+function parseLogLevel(traceSet) {
+    const raw = process.env.INDEX_SERVER_LOG_LEVEL?.toLowerCase();
+    const valid = ['error', 'warn', 'info', 'debug', 'trace'];
+    if (raw && valid.includes(raw))
+        return raw;
+    if (traceSet.has('verbose'))
+        return 'trace';
+    if ((0, envUtils_1.isDebugOrVerbose)())
+        return 'debug';
+    return 'info';
+}
+function parseBufferRing() {
+    let append;
+    let preload = false;
+    const appendRaw = process.env.INDEX_SERVER_BUFFER_RING_APPEND;
+    const preloadRaw = process.env.INDEX_SERVER_BUFFER_RING_PRELOAD;
+    if (appendRaw === '0')
+        append = false;
+    else if (appendRaw === '1')
+        append = true;
+    if (preloadRaw === '1')
+        preload = true;
+    return { append: append ?? true, preload };
+}
+function parseMutation() {
+    if (process.env.INDEX_SERVER_MUTATION) {
+        if (process.env.INDEX_SERVER_MUTATION === '1' || process.env.INDEX_SERVER_MUTATION === 'true')
+            return true;
+        return false;
+    }
+    return false;
+}
+function parseCoverage() {
+    const fast = process.env.INDEX_SERVER_COVERAGE_FAST === '1' || process.env.INDEX_SERVER_TEST_MODE === 'coverage-fast';
+    const hardMinRaw = process.env.INDEX_SERVER_COVERAGE_HARD_MIN;
+    const targetRaw = process.env.INDEX_SERVER_COVERAGE_TARGET;
+    const hardMin = hardMinRaw ? Number(hardMinRaw) : undefined;
+    const target = targetRaw ? Number(targetRaw) : undefined;
+    const strictMode = (0, envUtils_1.parseBooleanEnv)(process.env.INDEX_SERVER_COVERAGE_STRICT, process.env.INDEX_SERVER_TEST_MODE === 'coverage-strict');
+    return { hardMin, target, fastMode: fast, strictMode };
+}
+function resolveInstructionsAuditLog() {
+    const defaultPath = (0, configUtils_1.toAbsolute)(path_1.default.join(dirConstants_1.DIR.LOGS_AUDIT));
+    const raw = process.env.INDEX_SERVER_AUDIT_LOG;
+    if (raw === undefined || raw.trim().length === 0) {
+        return { enabled: true, file: defaultPath, rawValue: undefined, usesDefault: true };
+    }
+    const trimmed = raw.trim();
+    if ((0, envUtils_1.isFalsyExtended)(trimmed)) {
+        return { enabled: false, rawValue: raw, usesDefault: false };
+    }
+    const defaultRequested = trimmed === '1' || envUtils_1.TRUTHY_OR_DEFAULT.includes(trimmed.toLowerCase());
+    return {
+        enabled: true,
+        file: defaultRequested ? defaultPath : (0, configUtils_1.toAbsolute)(trimmed),
+        rawValue: raw,
+        usesDefault: defaultRequested || trimmed.length === 0,
+    };
+}
+function resolveInstructionsDir() {
+    const raw = process.env.INDEX_SERVER_DIR;
+    const fallback = path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.INSTRUCTIONS);
+    return (0, configUtils_1.toAbsolute)(raw, fallback);
+}
+function parseIndexConfig() {
+    const baseDir = resolveInstructionsDir();
+    const normalizationRaw = process.env.INDEX_SERVER_NORMALIZATION_LOG;
+    let normalizationLog;
+    if (normalizationRaw) {
+        if ((0, envUtils_1.isFalsy)(normalizationRaw))
+            normalizationLog = false;
+        else if ((0, envUtils_1.isTruthy)(normalizationRaw))
+            normalizationLog = (0, configUtils_1.toAbsolute)(path_1.default.join(dirConstants_1.DIR.LOGS_NORMALIZATION));
+        else
+            normalizationLog = (0, configUtils_1.toAbsolute)(normalizationRaw);
+    }
+    const memoizeRaw = process.env.INDEX_SERVER_MEMOIZE;
+    const attempts = (0, configUtils_1.numberFromEnv)('INDEX_SERVER_READ_RETRIES', defaultValues_1.DEFAULT_LIMITS.READ_RETRIES);
+    const backoffMs = (0, configUtils_1.numberFromEnv)('INDEX_SERVER_READ_BACKOFF_MS', defaultValues_1.DEFAULT_LIMITS.READ_BACKOFF_MS);
+    const usageFlushMs = (0, configUtils_1.numberFromEnv)('INDEX_SERVER_USAGE_FLUSH_MS', defaultValues_1.DEFAULT_GOVERNANCE.USAGE_FLUSH_MS);
+    const hashHardeningEnabled = (0, envUtils_1.parseBooleanEnv)(process.env.INDEX_SERVER_GOV_HASH_HARDENING, true);
+    const canonVariantsRaw = (0, configUtils_1.optionalIntFromEnv)('INDEX_SERVER_GOV_HASH_CANON_VARIANTS');
+    const importSetSizeRaw = (0, configUtils_1.optionalIntFromEnv)('INDEX_SERVER_GOV_HASH_IMPORT_SET_SIZE');
+    const hashCanonVariants = (0, configUtils_1.clamp)(canonVariantsRaw ?? defaultValues_1.DEFAULT_GOVERNANCE.HASH_CANON_VARIANTS, 1, defaultValues_1.DEFAULT_GOVERNANCE.HASH_CANON_VARIANTS_MAX);
+    const hashImportSetSize = (0, configUtils_1.clamp)(importSetSizeRaw ?? defaultValues_1.DEFAULT_GOVERNANCE.HASH_IMPORT_SET_SIZE, 2, defaultValues_1.DEFAULT_GOVERNANCE.HASH_IMPORT_SET_SIZE_MAX);
+    const maxFiles = (0, configUtils_1.optionalIntFromEnv)('INDEX_SERVER_MAX_FILES');
+    const loadWarningThreshold = (0, configUtils_1.optionalIntFromEnv)('INDEX_SERVER_LOAD_WARN_MS');
+    const bodyWarnLength = (0, configUtils_1.clamp)((0, configUtils_1.numberFromEnv)('INDEX_SERVER_BODY_WARN_LENGTH', defaultValues_1.DEFAULT_LIMITS.BODY_WARN_LENGTH), defaultValues_1.DEFAULT_LIMITS.BODY_MIN_LENGTH, defaultValues_1.DEFAULT_LIMITS.BODY_MAX_LENGTH);
+    const bodyMaxLength = defaultValues_1.DEFAULT_LIMITS.BODY_MAX_LENGTH;
+    // Warn about removed legacy env var
+    if (process.env.INDEX_SERVER_BODY_MAX_LENGTH !== undefined) {
+        console.warn('[runtimeConfig] INDEX_SERVER_BODY_MAX_LENGTH is no longer recognized. Use INDEX_SERVER_BODY_WARN_LENGTH instead (default: 100000).');
+    }
+    return {
+        mode: deriveIndexMode(),
+        baseDir,
+        reloadAlways: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_ALWAYS_RELOAD'),
+        memoize: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_MEMOIZE'),
+        memoizeDisabledExplicitly: memoizeRaw !== undefined ? (0, envUtils_1.isFalsy)(memoizeRaw) : false,
+        memoizeHash: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_MEMOIZE_HASH'),
+        normalizationLog,
+        fileTrace: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_FILE_TRACE'),
+        eventSilent: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_EVENT_SILENT'),
+        readRetries: { attempts, backoffMs },
+        usageFlushMs,
+        disableUsageClamp: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DISABLE_USAGE_CLAMP'),
+        govHash: {
+            trailingNewline: (0, envUtils_1.getBooleanEnv)('GOV_HASH_TRAILING_NEWLINE'),
+            hashHardeningEnabled,
+            hashCanonVariants,
+            hashImportSetSize,
+        },
+        maxFiles,
+        loadWarningThreshold,
+        bodyWarnLength,
+        bodyMaxLength,
+        autoSplitOversized: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_AUTO_SPLIT_OVERSIZED'),
+        autoUsageTrack: (0, envUtils_1.parseBooleanEnv)(process.env.INDEX_SERVER_AUTO_USAGE_TRACK, true),
+    };
+}
+function parseInstructionsConfig(_mutationEnabled) {
+    const auditLog = resolveInstructionsAuditLog();
+    const workspaceId = process.env.INDEX_SERVER_WORKSPACE;
+    const manifestWriteRaw = process.env.INDEX_SERVER_MANIFEST_WRITE;
+    const manifestWriteEnabled = manifestWriteRaw === undefined ? true : !(0, envUtils_1.isFalsy)(manifestWriteRaw);
+    const forceFullList = (0, envUtils_1.getBooleanEnv)('FULL_LIST_GET') || (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_STRESS_MODE');
+    const sampleOverride = (0, configUtils_1.optionalIntFromEnv)('LIST_GET_SAMPLE_SIZE');
+    const effectiveSampleSize = sampleOverride;
+    const sampleSeed = (0, configUtils_1.optionalIntFromEnv)('LIST_GET_SAMPLE_SEED');
+    const concurrency = (0, configUtils_1.clamp)((0, configUtils_1.optionalIntFromEnv)('LIST_GET_CONCURRENCY') ?? 8, 1, 64);
+    const maxDurationMs = Math.max(500, (0, configUtils_1.optionalIntFromEnv)('LIST_GET_MAX_DURATION_MS') ?? 7000);
+    return {
+        workspaceId: workspaceId && workspaceId.trim().length ? workspaceId : undefined,
+        agentId: process.env.INDEX_SERVER_AGENT_ID || undefined,
+        canonicalDisable: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_CANONICAL_DISABLE'),
+        strictVisibility: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TEST_STRICT_VISIBILITY'),
+        strictCreate: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_STRICT_CREATE'),
+        strictRemove: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_STRICT_REMOVE'),
+        requireCategory: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_REQUIRE_CATEGORY'),
+        traceQueryDiag: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TRACE_QUERY_DIAG'),
+        manifest: {
+            writeEnabled: manifestWriteEnabled,
+            fastload: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_MANIFEST_FASTLOAD'),
+        },
+        ciContext: {
+            inCI: !!process.env.CI,
+            githubActions: !!process.env.GITHUB_ACTIONS,
+            tfBuild: !!process.env.TF_BUILD,
+        },
+        auditLog,
+        listValidation: {
+            forceFullScan: forceFullList,
+            allowSampling: !forceFullList,
+            effectiveSampleSize,
+            sampleSeed,
+            concurrency,
+            maxDurationMs,
+        },
+    };
+}
+function parseMutationConfig(mutationEnabled) {
+    // Auto-backup defaults to true when mutation is enabled (protects against accidental data loss).
+    const autoBackupDefault = mutationEnabled;
+    return {
+        enabled: mutationEnabled,
+        dispatcherTiming: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_ADD_TIMING'),
+        maxBulkDelete: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_MAX_BULK_DELETE', defaultValues_1.DEFAULT_LIMITS.MAX_BULK_DELETE),
+        backupBeforeBulkDelete: process.env.INDEX_SERVER_BACKUP_BEFORE_BULK_DELETE === undefined ? true : (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_BACKUP_BEFORE_BULK_DELETE'),
+        autoBackupEnabled: process.env.INDEX_SERVER_AUTO_BACKUP === undefined ? autoBackupDefault : (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_AUTO_BACKUP'),
+        autoBackupIntervalMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_AUTO_BACKUP_INTERVAL_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.AUTO_BACKUP_INTERVAL),
+        autoBackupMaxCount: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_AUTO_BACKUP_MAX_COUNT', defaultValues_1.DEFAULT_LIMITS.AUTO_BACKUP_MAX_COUNT),
+    };
+}
+/** Valid profile names supported by the wizard and runtime. */
+exports.VALID_PROFILES = ['default', 'enhanced', 'experimental'];
+/**
+ * Apply profile-aware environment defaults.
+ * Called early in loadRuntimeConfig, sets env vars only when not already set.
+ * This ensures the wizard's profile choice flows through to all downstream parsers.
+ */
+function applyProfileDefaults(profile) {
+    const setDefault = (key, value) => {
+        if (process.env[key] === undefined)
+            process.env[key] = value;
+    };
+    // All profiles enable dashboard by default
+    setDefault('INDEX_SERVER_DASHBOARD', '1');
+    if (profile === 'enhanced') {
+        setDefault('INDEX_SERVER_SEMANTIC_ENABLED', '1');
+        setDefault('INDEX_SERVER_SEMANTIC_LOCAL_ONLY', '0');
+        setDefault('INDEX_SERVER_LOG_FILE', '1');
+        setDefault('INDEX_SERVER_MUTATION', '1');
+        setDefault('INDEX_SERVER_DASHBOARD_TLS', '1');
+        setDefault('INDEX_SERVER_METRICS_FILE_STORAGE', '1');
+        setDefault('INDEX_SERVER_FEATURES', 'usage');
+    }
+    else if (profile === 'experimental') {
+        setDefault('INDEX_SERVER_SEMANTIC_ENABLED', '1');
+        setDefault('INDEX_SERVER_SEMANTIC_LOCAL_ONLY', '0');
+        setDefault('INDEX_SERVER_LOG_FILE', '1');
+        setDefault('INDEX_SERVER_MUTATION', '1');
+        setDefault('INDEX_SERVER_DASHBOARD_TLS', '1');
+        setDefault('INDEX_SERVER_METRICS_FILE_STORAGE', '1');
+        setDefault('INDEX_SERVER_FEATURES', 'usage');
+        setDefault('INDEX_SERVER_STORAGE_BACKEND', 'sqlite');
+        setDefault('INDEX_SERVER_LOG_LEVEL', 'debug');
+    }
+}
+/**
+ * Parse all environment variables and construct a fresh {@link RuntimeConfig} object.
+ * Prefer {@link getRuntimeConfig} for normal use — this function always re-parses.
+ * @returns Fully resolved runtime configuration object
+ */
+function loadRuntimeConfig() {
+    const rawProfile = (process.env.INDEX_SERVER_PROFILE || 'default').toLowerCase();
+    const profile = exports.VALID_PROFILES.includes(rawProfile) ? rawProfile : 'default';
+    applyProfileDefaults(profile);
+    const testMode = process.env.INDEX_SERVER_TEST_MODE;
+    const rawTiming = parseTiming();
+    const trace = parseTrace();
+    const initFeatures = parseInitFeatures();
+    const logLevel = parseLogLevel(trace);
+    const mutationEnabled = parseMutation();
+    const index = parseIndexConfig();
+    const dashboard = (0, dashboardConfig_1.parseDashboardConfig)(mutationEnabled, index.baseDir);
+    const server = (0, serverConfig_1.parseServerConfig)();
+    const logging = (0, serverConfig_1.parseLoggingConfig)(logLevel);
+    const metrics = (0, serverConfig_1.parseMetricsConfig)();
+    const instructions = parseInstructionsConfig(mutationEnabled);
+    const tracing = (0, serverConfig_1.parseTracingConfig)(trace, logLevel);
+    const mutation = parseMutationConfig(mutationEnabled);
+    const featureFlags = (0, featureConfig_1.parseFeatureFlagsConfig)();
+    const feedback = (0, featureConfig_1.parseFeedbackConfig)();
+    const messaging = (0, featureConfig_1.parseMessagingConfig)();
+    const semantic = (0, featureConfig_1.parseSemanticConfig)();
+    const minimal = (0, featureConfig_1.parseMinimalConfig)();
+    const bootstrapSeed = (0, featureConfig_1.parseBootstrapSeedConfig)();
+    const atomicFs = (0, serverConfig_1.parseAtomicFsConfig)();
+    const preflight = (0, serverConfig_1.parsePreflightConfig)();
+    const validation = (0, featureConfig_1.parseValidationConfig)();
+    const dynamic = (0, featureConfig_1.parseDynamicConfig)();
+    const graph = (0, featureConfig_1.parseGraphConfig)();
+    const storage = (0, featureConfig_1.parseStorageConfig)();
+    return {
+        profile,
+        testMode,
+        index,
+        mutationEnabled: mutation.enabled,
+        logLevel,
+        trace,
+        initFeatures,
+        bufferRing: parseBufferRing(),
+        timing: (key, fallback) => rawTiming[key] ?? fallback,
+        rawTiming,
+        coverage: parseCoverage(),
+        dashboard,
+        server,
+        logging,
+        metrics,
+        instructions,
+        tracing,
+        mutation,
+        featureFlags,
+        feedback,
+        messaging,
+        semantic,
+        minimal,
+        bootstrapSeed,
+        atomicFs,
+        preflight,
+        validation,
+        dynamic,
+        graph,
+        storage,
+    };
+}
+let _cached;
+/**
+ * Return the cached singleton {@link RuntimeConfig}, loading it on first call.
+ * @returns The application-wide runtime configuration
+ */
+function getRuntimeConfig() {
+    if (!_cached)
+        _cached = loadRuntimeConfig();
+    return _cached;
+}
+/**
+ * Force a reload of the runtime configuration by discarding the cache and re-parsing all env vars.
+ * @returns The freshly loaded runtime configuration
+ */
+function reloadRuntimeConfig() {
+    _cached = loadRuntimeConfig();
+    return _cached;
+}
+if (require.main === module) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify(getRuntimeConfig(), null, 2));
+}

package/dist/config/serverConfig.d.ts

@@ -0,0 +1,90 @@
+import { LogLevel } from './configUtils';
+export type { LogLevel };
+interface ServerBootstrapConfig {
+    autoconfirm: boolean;
+    tokenTtlSec: number;
+    referenceMode: boolean;
+}
+interface ServerindexPollingConfig {
+    enabled: boolean;
+    proactive: boolean;
+    intervalMs: number;
+}
+export interface ServerConfig {
+    disableEarlyStdinBuffer: boolean;
+    fatalExitDelayMs: number;
+    idleKeepaliveMs: number;
+    sharedSentinel?: string;
+    bootstrap: ServerBootstrapConfig;
+    indexPolling: ServerindexPollingConfig;
+    multicoreTrace: boolean;
+    /** Multi-instance mode: standalone (default), leader, follower, auto [EXPERIMENTAL] */
+    instanceMode: 'standalone' | 'leader' | 'follower' | 'auto';
+    /** HTTP port for leader's MCP transport (thin clients connect here) */
+    leaderPort: number;
+    /** Leader heartbeat interval (ms) */
+    heartbeatIntervalMs: number;
+    /** Stale leader threshold (ms) — follower promotes after this */
+    staleThresholdMs: number;
+}
+export interface LoggingConfig {
+    level: LogLevel;
+    verbose: boolean;
+    json: boolean;
+    sync: boolean;
+    diagnostics: boolean;
+    protocol: boolean;
+    file?: string;
+    rawFileValue?: string;
+    sentinelRequested: boolean;
+}
+interface MetricsToolcallConfig {
+    chunkSize: number;
+    flushMs: number;
+    compactMs: number;
+    appendLogEnabled: boolean;
+}
+interface MetricsHealthConfig {
+    memoryThreshold: number;
+    errorRateThreshold: number;
+    minUptimeMs: number;
+}
+export interface MetricsConfig {
+    dir: string;
+    resourceCapacity: number;
+    sampleIntervalMs: number;
+    toolcall: MetricsToolcallConfig;
+    health: MetricsHealthConfig;
+    fileStorage: boolean;
+}
+export interface AtomicFsConfig {
+    retries: number;
+    backoffMs: number;
+}
+export interface PreflightConfig {
+    modules: string[];
+    strict: boolean;
+}
+interface TracingBufferConfig {
+    file?: string;
+    sizeBytes: number;
+    dumpOnExit: boolean;
+}
+export interface TracingConfig {
+    level: LogLevel | 'verbose';
+    categories: Set<string>;
+    buffer: TracingBufferConfig;
+    file?: string;
+    persist: boolean;
+    dir: string;
+    fsync: boolean;
+    maxFileSizeBytes: number;
+    sessionId?: string;
+    callsite: boolean;
+}
+export declare function parseServerConfig(): ServerConfig;
+export declare function parseLoggingConfig(level: LogLevel): LoggingConfig;
+export declare function parseMetricsConfig(): MetricsConfig;
+export declare function parseAtomicFsConfig(): AtomicFsConfig;
+export declare function parsePreflightConfig(): PreflightConfig;
+export declare function parseTracingConfig(traceSet: Set<string>, fallbackLevel: LogLevel): TracingConfig;

package/dist/config/serverConfig.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseServerConfig = parseServerConfig;
+exports.parseLoggingConfig = parseLoggingConfig;
+exports.parseMetricsConfig = parseMetricsConfig;
+exports.parseAtomicFsConfig = parseAtomicFsConfig;
+exports.parsePreflightConfig = parsePreflightConfig;
+exports.parseTracingConfig = parseTracingConfig;
+/**
+ * Server domain config: MCP server, bootstrap, transport, protocol, logging,
+ * metrics, tracing, atomicFs, and preflight settings.
+ */
+const path_1 = __importDefault(require("path"));
+const envUtils_1 = require("../utils/envUtils");
+const configUtils_1 = require("./configUtils");
+const dirConstants_1 = require("./dirConstants");
+const defaultValues_1 = require("./defaultValues");
+function isDevMode() {
+    return process.env.NODE_ENV === 'development' || process.argv.some(a => a === '--watch' || a.includes('--watch'));
+}
+function parseServerConfig() {
+    const sharedSentinel = process.env.INDEX_SERVER_SHARED_SERVER_SENTINEL;
+    const rawMode = (process.env.INDEX_SERVER_MODE || 'standalone').trim().toLowerCase();
+    const validModes = ['standalone', 'leader', 'follower', 'auto'];
+    const instanceMode = validModes.includes(rawMode)
+        ? rawMode
+        : 'standalone';
+    return {
+        disableEarlyStdinBuffer: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DISABLE_EARLY_STDIN_BUFFER'),
+        fatalExitDelayMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_FATAL_EXIT_DELAY_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.FATAL_EXIT_DELAY),
+        idleKeepaliveMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_IDLE_KEEPALIVE_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.IDLE_KEEPALIVE),
+        sharedSentinel: sharedSentinel && sharedSentinel.trim().length ? sharedSentinel : undefined,
+        bootstrap: {
+            autoconfirm: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_BOOTSTRAP_AUTOCONFIRM'),
+            tokenTtlSec: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_BOOTSTRAP_TOKEN_TTL_SEC', defaultValues_1.DEFAULT_PORTS.BOOTSTRAP_TOKEN_TTL_SEC),
+            referenceMode: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_REFERENCE_MODE'),
+        },
+        indexPolling: {
+            enabled: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_ENABLE_INDEX_SERVER_POLLER'),
+            proactive: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_POLL_PROACTIVE'),
+            intervalMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_POLL_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.POLL_INTERVAL),
+        },
+        multicoreTrace: (0, envUtils_1.getBooleanEnv)('MULTICLIENT_TRACE'),
+        instanceMode,
+        leaderPort: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_LEADER_PORT', isDevMode() ? defaultValues_1.DEFAULT_PORTS.LEADER_DEV : defaultValues_1.DEFAULT_PORTS.LEADER),
+        heartbeatIntervalMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_HEARTBEAT_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.HEARTBEAT),
+        staleThresholdMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_STALE_THRESHOLD_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.STALE_THRESHOLD),
+    };
+}
+function resolveLogFile() {
+    const raw = process.env.INDEX_SERVER_LOG_FILE;
+    if (!raw)
+        return { raw: undefined, sentinelRequested: false };
+    const normalized = raw.trim().toLowerCase();
+    const isSentinel = raw === '1' || ['true', 'yes', 'on'].includes(normalized);
+    if (isSentinel) {
+        return {
+            file: (0, configUtils_1.toAbsolute)(path_1.default.join(dirConstants_1.DIR.LOGS_MCP_SERVER)),
+            raw,
+            sentinelRequested: true,
+        };
+    }
+    return { file: (0, configUtils_1.toAbsolute)(raw), raw, sentinelRequested: false };
+}
+function parseLoggingConfig(level) {
+    const fileInfo = resolveLogFile();
+    return {
+        level,
+        verbose: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_VERBOSE_LOGGING') || (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DEBUG'),
+        json: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_LOG_JSON'),
+        sync: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_LOG_SYNC'),
+        diagnostics: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_LOG_DIAG'),
+        protocol: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_LOG_PROTOCOL'),
+        file: fileInfo.file,
+        rawFileValue: fileInfo.raw,
+        sentinelRequested: fileInfo.sentinelRequested,
+    };
+}
+function parseMetricsConfig() {
+    return {
+        dir: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_METRICS_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.METRICS)),
+        resourceCapacity: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_RESOURCE_CAPACITY', defaultValues_1.DEFAULT_THRESHOLDS.RESOURCE_CAPACITY),
+        sampleIntervalMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_RESOURCE_SAMPLE_INTERVAL_MS', defaultValues_1.DEFAULT_THRESHOLDS.RESOURCE_SAMPLE_INTERVAL_MS),
+        toolcall: {
+            chunkSize: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_TOOLCALL_CHUNK_SIZE', defaultValues_1.DEFAULT_LIMITS.TOOLCALL_CHUNK_SIZE),
+            flushMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_TOOLCALL_FLUSH_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.TOOLCALL_FLUSH),
+            compactMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_TOOLCALL_COMPACT_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.TOOLCALL_COMPACT),
+            appendLogEnabled: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TOOLCALL_APPEND_LOG'),
+        },
+        health: {
+            memoryThreshold: (0, configUtils_1.floatFromEnv)('INDEX_SERVER_HEALTH_MEMORY_THRESHOLD', defaultValues_1.DEFAULT_THRESHOLDS.MEMORY_THRESHOLD),
+            errorRateThreshold: (0, configUtils_1.floatFromEnv)('INDEX_SERVER_HEALTH_ERROR_THRESHOLD', defaultValues_1.DEFAULT_THRESHOLDS.ERROR_RATE_THRESHOLD),
+            minUptimeMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_HEALTH_MIN_UPTIME', defaultValues_1.DEFAULT_TIMEOUTS_MS.HEALTH_MIN_UPTIME),
+        },
+        fileStorage: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_METRICS_FILE_STORAGE'),
+    };
+}
+function parseAtomicFsConfig() {
+    return {
+        retries: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_ATOMIC_WRITE_RETRIES', defaultValues_1.DEFAULT_LIMITS.ATOMIC_WRITE_RETRIES),
+        backoffMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_ATOMIC_WRITE_BACKOFF_MS', defaultValues_1.DEFAULT_LIMITS.ATOMIC_WRITE_BACKOFF_MS),
+    };
+}
+function parsePreflightConfig() {
+    const modules = (0, configUtils_1.parseCsvEnv)('INDEX_SERVER_PREFLIGHT_MODULES');
+    return {
+        modules: modules.length ? modules : ['mime-db', 'ajv', 'ajv-formats'],
+        strict: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_PREFLIGHT_STRICT'),
+    };
+}
+function resolveTraceLevel(traceSet, fallbackLevel) {
+    const raw = process.env.INDEX_SERVER_TRACE_LEVEL?.toLowerCase();
+    switch (raw) {
+        case 'verbose': return 'verbose';
+        case 'trace':
+        case 'files':
+        case 'perf':
+            return 'trace';
+        case 'debug':
+        case 'core':
+            return 'debug';
+        case 'warn':
+            return 'warn';
+        case 'error':
+            return 'error';
+        default:
+            if (traceSet.has('verbose'))
+                return 'verbose';
+            if (traceSet.size > 0)
+                return 'trace';
+            return fallbackLevel;
+    }
+}
+function resolveTracingBuffer() {
+    const rawFile = process.env.INDEX_SERVER_TRACE_BUFFER_FILE;
+    const trimmed = rawFile?.trim();
+    const file = trimmed && trimmed.length ? (0, configUtils_1.toAbsolute)(trimmed) : undefined;
+    const sizeBytes = (0, configUtils_1.optionalNumberFromEnv)('INDEX_SERVER_TRACE_BUFFER_SIZE') ?? 0;
+    const dumpOnExit = (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TRACE_BUFFER_DUMP_ON_EXIT');
+    return { file, sizeBytes, dumpOnExit };
+}
+function parseTracingConfig(traceSet, fallbackLevel) {
+    const categories = new Set((0, configUtils_1.parseCsvEnv)('INDEX_SERVER_TRACE_CATEGORIES'));
+    const buffer = resolveTracingBuffer();
+    const filePath = (() => {
+        const raw = process.env.INDEX_SERVER_TRACE_FILE;
+        if (!raw)
+            return undefined;
+        const trimmed = raw.trim();
+        return trimmed.length ? (0, configUtils_1.toAbsolute)(trimmed) : undefined;
+    })();
+    return {
+        level: resolveTraceLevel(traceSet, fallbackLevel),
+        categories,
+        buffer,
+        file: filePath,
+        persist: (0, envUtils_1.parseBooleanEnv)(process.env.INDEX_SERVER_TRACE_PERSIST, !!filePath),
+        dir: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_TRACE_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.LOGS_TRACE)),
+        fsync: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TRACE_FSYNC'),
+        maxFileSizeBytes: (0, configUtils_1.optionalIntFromEnv)('INDEX_SERVER_TRACE_MAX_FILE_SIZE') ?? 0,
+        sessionId: process.env.INDEX_SERVER_TRACE_SESSION || undefined,
+        callsite: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TRACE_CALLSITE'),
+    };
+}