@jagilber-org/index-server 1.19.1

package/dist/config/runtimeConfig.d.ts

@@ -0,0 +1,145 @@
+import { LogLevel } from './configUtils';
+import type { ServerConfig, LoggingConfig, MetricsConfig, AtomicFsConfig, PreflightConfig, TracingConfig } from './serverConfig';
+import type { DashboardConfig } from './dashboardConfig';
+import type { FeatureFlagsConfig, FeedbackConfig, MessagingConfig, SemanticConfig, MinimalConfig, BootstrapSeedConfig, ValidationConfig, DynamicConfig, GraphConfig, StorageConfig } from './featureConfig';
+export type IndexMode = 'normal' | 'memoize' | 'memoize+hash' | 'reload' | 'reload+memo';
+export type { LogLevel };
+export type { MessagingConfig } from './featureConfig';
+export type { StorageConfig } from './featureConfig';
+interface TimingMap {
+    [key: string]: number;
+}
+interface BufferRingConfig {
+    append: boolean;
+    preload: boolean;
+}
+interface CoverageConfig {
+    hardMin?: number;
+    target?: number;
+    fastMode: boolean;
+    strictMode: boolean;
+}
+interface IndexReadRetriesConfig {
+    attempts: number;
+    backoffMs: number;
+}
+interface IndexGovernanceConfig {
+    trailingNewline: boolean;
+    hashHardeningEnabled: boolean;
+    hashCanonVariants: number;
+    hashImportSetSize: number;
+}
+interface IndexConfig {
+    mode: IndexMode;
+    baseDir: string;
+    reloadAlways: boolean;
+    memoize: boolean;
+    memoizeDisabledExplicitly: boolean;
+    memoizeHash: boolean;
+    normalizationLog?: string | boolean;
+    fileTrace: boolean;
+    eventSilent: boolean;
+    readRetries: IndexReadRetriesConfig;
+    usageFlushMs: number;
+    disableUsageClamp: boolean;
+    govHash: IndexGovernanceConfig;
+    maxFiles?: number;
+    loadWarningThreshold?: number;
+    bodyMaxLength: number;
+    autoSplitOversized: boolean;
+    autoUsageTrack: boolean;
+}
+interface InstructionsManifestConfig {
+    writeEnabled: boolean;
+    fastload: boolean;
+}
+interface InstructionsCIContextConfig {
+    inCI: boolean;
+    githubActions: boolean;
+    tfBuild: boolean;
+}
+interface InstructionsAuditLogConfig {
+    enabled: boolean;
+    file?: string;
+    rawValue?: string;
+    usesDefault: boolean;
+}
+interface InstructionsListValidationConfig {
+    forceFullScan: boolean;
+    allowSampling: boolean;
+    effectiveSampleSize?: number;
+    sampleSeed?: number;
+    concurrency: number;
+    maxDurationMs: number;
+}
+interface InstructionsConfig {
+    workspaceId?: string;
+    agentId?: string;
+    canonicalDisable: boolean;
+    strictVisibility: boolean;
+    strictCreate: boolean;
+    strictRemove: boolean;
+    requireCategory: boolean;
+    traceQueryDiag: boolean;
+    manifest: InstructionsManifestConfig;
+    ciContext: InstructionsCIContextConfig;
+    auditLog: InstructionsAuditLogConfig;
+    listValidation: InstructionsListValidationConfig;
+}
+interface MutationConfig {
+    enabled: boolean;
+    dispatcherTiming: boolean;
+    maxBulkDelete: number;
+    backupBeforeBulkDelete: boolean;
+    autoBackupEnabled: boolean;
+    autoBackupIntervalMs: number;
+    autoBackupMaxCount: number;
+}
+export interface RuntimeConfig {
+    profile: string;
+    testMode: string | undefined;
+    index: IndexConfig;
+    mutationEnabled: boolean;
+    logLevel: LogLevel;
+    trace: Set<string>;
+    initFeatures: Set<string>;
+    bufferRing: BufferRingConfig;
+    timing: (key: string, fallback?: number) => number | undefined;
+    rawTiming: TimingMap;
+    coverage: CoverageConfig;
+    dashboard: DashboardConfig;
+    server: ServerConfig;
+    logging: LoggingConfig;
+    metrics: MetricsConfig;
+    instructions: InstructionsConfig;
+    tracing: TracingConfig;
+    mutation: MutationConfig;
+    featureFlags: FeatureFlagsConfig;
+    feedback: FeedbackConfig;
+    messaging: MessagingConfig;
+    semantic: SemanticConfig;
+    minimal: MinimalConfig;
+    bootstrapSeed: BootstrapSeedConfig;
+    atomicFs: AtomicFsConfig;
+    preflight: PreflightConfig;
+    validation: ValidationConfig;
+    dynamic: DynamicConfig;
+    graph: GraphConfig;
+    storage: StorageConfig;
+}
+/**
+ * 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
+ */
+export declare function loadRuntimeConfig(): RuntimeConfig;
+/**
+ * Return the cached singleton {@link RuntimeConfig}, loading it on first call.
+ * @returns The application-wide runtime configuration
+ */
+export declare function getRuntimeConfig(): RuntimeConfig;
+/**
+ * Force a reload of the runtime configuration by discarding the cache and re-parsing all env vars.
+ * @returns The freshly loaded runtime configuration
+ */
+export declare function reloadRuntimeConfig(): RuntimeConfig;

package/dist/config/runtimeConfig.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 bodyMaxLength = (0, configUtils_1.clamp)((0, configUtils_1.numberFromEnv)('INDEX_SERVER_BODY_MAX_LENGTH', defaultValues_1.DEFAULT_LIMITS.BODY_MAX_LENGTH), defaultValues_1.DEFAULT_LIMITS.BODY_MIN_LENGTH, defaultValues_1.DEFAULT_LIMITS.BODY_ABS_MAX_LENGTH);
+    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,
+        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) {
+    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: (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),
+    };
+}
+/**
+ * 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 profile = process.env.INDEX_SERVER_PROFILE || 'default';
+    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;