@jagilber-org/index-server 1.28.1 → 1.28.4

package/dist/services/mcpConfig/flagCatalog.js

@@ -0,0 +1,301 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCUMENTED_INDEX_SERVER_FLAGS = void 0;
+exports.toForwardSlashes = toForwardSlashes;
+exports.resolveDataPaths = resolveDataPaths;
+exports.buildEnvCatalog = buildEnvCatalog;
+exports.activeEnvFromCatalog = activeEnvFromCatalog;
+const path_1 = __importDefault(require("path"));
+exports.DOCUMENTED_INDEX_SERVER_FLAGS = [
+    'INDEX_SERVER_ADD_TIMING',
+    'INDEX_SERVER_ADMIN_API_KEY',
+    'INDEX_SERVER_ADMIN_MAX_SESSION_HISTORY',
+    'INDEX_SERVER_AGENT_ID',
+    'INDEX_SERVER_ALWAYS_RELOAD',
+    'INDEX_SERVER_ATOMIC_WRITE_BACKOFF_MS',
+    'INDEX_SERVER_ATOMIC_WRITE_RETRIES',
+    'INDEX_SERVER_AUTH_KEY',
+    'INDEX_SERVER_AUTO_BACKUP',
+    'INDEX_SERVER_AUTO_BACKUP_INTERVAL_MS',
+    'INDEX_SERVER_AUTO_BACKUP_MAX_COUNT',
+    'INDEX_SERVER_AUTO_SEED',
+    'INDEX_SERVER_AUTO_SPLIT_OVERSIZED',
+    'INDEX_SERVER_AUTO_USAGE_TRACK',
+    'INDEX_SERVER_BACKUP_BEFORE_BULK_DELETE',
+    'INDEX_SERVER_BACKUPS_DIR',
+    'INDEX_SERVER_BODY_WARN_LENGTH',
+    'INDEX_SERVER_BOOTSTRAP_AUTOCONFIRM',
+    'INDEX_SERVER_BOOTSTRAP_TOKEN_TTL_SEC',
+    'INDEX_SERVER_BUFFER_RING_APPEND',
+    'INDEX_SERVER_BUFFER_RING_PRELOAD',
+    'INDEX_SERVER_CACHE_MODE',
+    'INDEX_SERVER_CANONICAL_DISABLE',
+    'INDEX_SERVER_DASHBOARD',
+    'INDEX_SERVER_DASHBOARD_GRAPH',
+    'INDEX_SERVER_DASHBOARD_HOST',
+    'INDEX_SERVER_DASHBOARD_PORT',
+    'INDEX_SERVER_DASHBOARD_TLS',
+    'INDEX_SERVER_DASHBOARD_TLS_CA',
+    'INDEX_SERVER_DASHBOARD_TLS_CERT',
+    'INDEX_SERVER_DASHBOARD_TLS_KEY',
+    'INDEX_SERVER_DASHBOARD_TRIES',
+    'INDEX_SERVER_DEBUG',
+    'INDEX_SERVER_DIR',
+    'INDEX_SERVER_DISABLE_EARLY_STDIN_BUFFER',
+    'INDEX_SERVER_DISABLE_USAGE_CLAMP',
+    'INDEX_SERVER_EMBEDDING_PATH',
+    'INDEX_SERVER_ENABLE_INDEX_SERVER_POLLER',
+    'INDEX_SERVER_EVENT_SILENT',
+    'INDEX_SERVER_FATAL_EXIT_DELAY_MS',
+    'INDEX_SERVER_FEATURES',
+    'INDEX_SERVER_FEEDBACK_DIR',
+    'INDEX_SERVER_FEEDBACK_MAX_ENTRIES',
+    'INDEX_SERVER_FILE_TRACE',
+    'INDEX_SERVER_FLAG_TOOLS_ADMIN',
+    'INDEX_SERVER_FLAG_TOOLS_EXTENDED',
+    'INDEX_SERVER_FLAGS_FILE',
+    'INDEX_SERVER_FORCE_REBUILD',
+    'INDEX_SERVER_GOV_HASH_CANON_VARIANTS',
+    'INDEX_SERVER_GOV_HASH_HARDENING',
+    'INDEX_SERVER_GOV_HASH_IMPORT_SET_SIZE',
+    'INDEX_SERVER_GRAPH_INCLUDE_PRIMARY_EDGES',
+    'INDEX_SERVER_GRAPH_LARGE_CATEGORY_CAP',
+    'INDEX_SERVER_HEALTH_ERROR_THRESHOLD',
+    'INDEX_SERVER_HEALTH_MEMORY_THRESHOLD',
+    'INDEX_SERVER_HEALTH_MIN_UPTIME',
+    'INDEX_SERVER_HEARTBEAT_MS',
+    'INDEX_SERVER_HTTP_METRICS',
+    'INDEX_SERVER_IDLE_KEEPALIVE_MS',
+    'INDEX_SERVER_IDLE_READY_SENTINEL',
+    'INDEX_SERVER_INIT_FEATURES',
+    'INDEX_SERVER_ISSUE_317_COUNTER',
+    'INDEX_SERVER_LEADER_PORT',
+    'INDEX_SERVER_LEADER_URL',
+    'INDEX_SERVER_LOAD_WARN_MS',
+    'INDEX_SERVER_LOG_DIAG',
+    'INDEX_SERVER_LOG_FILE',
+    'INDEX_SERVER_LOG_JSON',
+    'INDEX_SERVER_LOG_LEVEL',
+    'INDEX_SERVER_LOG_MUTATION',
+    'INDEX_SERVER_LOG_PROTOCOL',
+    'INDEX_SERVER_LOG_SEARCH',
+    'INDEX_SERVER_LOG_SYNC',
+    'INDEX_SERVER_LOG_TOOLS',
+    'INDEX_SERVER_MANIFEST_FASTLOAD',
+    'INDEX_SERVER_MANIFEST_WRITE',
+    'INDEX_SERVER_MAX_BULK_DELETE',
+    'INDEX_SERVER_MAX_CONNECTIONS',
+    'INDEX_SERVER_MAX_FILES',
+    'INDEX_SERVER_MEMOIZE',
+    'INDEX_SERVER_MEMOIZE_HASH',
+    'INDEX_SERVER_MEMORY_MONITOR',
+    'INDEX_SERVER_METRICS_DIR',
+    'INDEX_SERVER_METRICS_FILE_STORAGE',
+    'INDEX_SERVER_METRICS_MAX_FILES',
+    'INDEX_SERVER_MINIMAL_DEBUG',
+    'INDEX_SERVER_MODE',
+    'INDEX_SERVER_MUTATION',
+    'INDEX_SERVER_NORMALIZATION_LOG',
+    'INDEX_SERVER_POLL_MS',
+    'INDEX_SERVER_POLL_PROACTIVE',
+    'INDEX_SERVER_PREFLIGHT_MODULES',
+    'INDEX_SERVER_PREFLIGHT_STRICT',
+    'INDEX_SERVER_PROFILE',
+    'INDEX_SERVER_PWS_EXIT_MS',
+    'INDEX_SERVER_RATE_LIMIT',
+    'INDEX_SERVER_READ_BACKOFF_MS',
+    'INDEX_SERVER_READ_RETRIES',
+    'INDEX_SERVER_REFERENCE_MODE',
+    'INDEX_SERVER_REQUEST_TIMEOUT',
+    'INDEX_SERVER_REQUIRE_AUTH_ALL',
+    'INDEX_SERVER_REQUIRE_CATEGORY',
+    'INDEX_SERVER_RESOURCE_CAPACITY',
+    'INDEX_SERVER_RESOURCE_SAMPLE_INTERVAL_MS',
+    'INDEX_SERVER_SEED_VERBOSE',
+    'INDEX_SERVER_SEMANTIC_CACHE_DIR',
+    'INDEX_SERVER_SEMANTIC_DEVICE',
+    'INDEX_SERVER_SEMANTIC_ENABLED',
+    'INDEX_SERVER_SEMANTIC_LOCAL_ONLY',
+    'INDEX_SERVER_SEMANTIC_MODEL',
+    'INDEX_SERVER_SEARCH_OMIT_ZERO_QUERY',
+    'INDEX_SERVER_SESSION_BACKUP_INTEGRATION',
+    'INDEX_SERVER_SESSION_DEDUPLICATION_ENABLED',
+    'INDEX_SERVER_SESSION_MAX_CONNECTION_HISTORY_DAYS',
+    'INDEX_SERVER_SESSION_MAX_HISTORY_DAYS',
+    'INDEX_SERVER_SESSION_MAX_HISTORY_ENTRIES',
+    'INDEX_SERVER_SESSION_PERSISTENCE_DIR',
+    'INDEX_SERVER_SESSION_PERSISTENCE_ENABLED',
+    'INDEX_SERVER_SESSION_PERSISTENCE_INTERVAL_MS',
+    'INDEX_SERVER_SHARED_SERVER_SENTINEL',
+    'INDEX_SERVER_SQLITE_MIGRATE_ON_START',
+    'INDEX_SERVER_SQLITE_PATH',
+    'INDEX_SERVER_SQLITE_VEC_ENABLED',
+    'INDEX_SERVER_SQLITE_VEC_PATH',
+    'INDEX_SERVER_SQLITE_WAL',
+    'INDEX_SERVER_STALE_THRESHOLD_MS',
+    'INDEX_SERVER_STATE_DIR',
+    'INDEX_SERVER_STORAGE_BACKEND',
+    'INDEX_SERVER_STRESS_DIAG',
+    'INDEX_SERVER_STRESS_MODE',
+    'INDEX_SERVER_STRICT_',
+    'INDEX_SERVER_STRICT_CREATE',
+    'INDEX_SERVER_STRICT_REMOVE',
+    'INDEX_SERVER_TEST_MODE',
+    'INDEX_SERVER_TEST_STRICT_VISIBILITY',
+    'INDEX_SERVER_TIMING_JSON',
+    'INDEX_SERVER_TOOLCALL_APPEND_LOG',
+    'INDEX_SERVER_TOOLCALL_CHUNK_SIZE',
+    'INDEX_SERVER_TOOLCALL_COMPACT_MS',
+    'INDEX_SERVER_TOOLCALL_FLUSH_MS',
+    'INDEX_SERVER_TRACE',
+    'INDEX_SERVER_TRACE_',
+    'INDEX_SERVER_TRACE_ALL',
+    'INDEX_SERVER_TRACE_BUFFER_',
+    'INDEX_SERVER_TRACE_BUFFER_DUMP_ON_EXIT',
+    'INDEX_SERVER_TRACE_BUFFER_FILE',
+    'INDEX_SERVER_TRACE_BUFFER_SIZE',
+    'INDEX_SERVER_TRACE_CALLSITE',
+    'INDEX_SERVER_TRACE_CATEGORIES',
+    'INDEX_SERVER_TRACE_DIR',
+    'INDEX_SERVER_TRACE_DISPATCH_DIAG',
+    'INDEX_SERVER_TRACE_FILE',
+    'INDEX_SERVER_TRACE_FSYNC',
+    'INDEX_SERVER_TRACE_LEVEL',
+    'INDEX_SERVER_TRACE_MAX_FILE_SIZE',
+    'INDEX_SERVER_TRACE_PERSIST',
+    'INDEX_SERVER_TRACE_QUERY_DIAG',
+    'INDEX_SERVER_TRACE_SESSION',
+    'INDEX_SERVER_USAGE_FLUSH_MS',
+    'INDEX_SERVER_USAGE_SNAPSHOT_PATH',
+    'INDEX_SERVER_VALIDATION_MODE',
+    'INDEX_SERVER_VERBOSE_LOGGING',
+    'INDEX_SERVER_VISIBILITY_DIAG',
+    'INDEX_SERVER_WORKSPACE',
+];
+function toForwardSlashes(value) {
+    return value.split(path_1.default.sep).join('/');
+}
+function resolveDataPaths(root) {
+    const resolveUnder = (...segments) => toForwardSlashes(path_1.default.resolve(root, ...segments));
+    return {
+        instructions: resolveUnder('instructions'),
+        feedback: resolveUnder('feedback'),
+        backups: resolveUnder('backups'),
+        state: resolveUnder('data', 'state'),
+        auditLog: resolveUnder('logs', 'instruction-transactions.log.jsonl'),
+        logFile: resolveUnder('logs', 'mcp-server.log'),
+        metrics: resolveUnder('metrics'),
+        messaging: resolveUnder('data', 'messaging'),
+        embeddings: resolveUnder('data', 'embeddings.json'),
+        modelCache: resolveUnder('data', 'models'),
+        sqliteDb: resolveUnder('data', 'index.db'),
+        certs: resolveUnder('certs'),
+        flags: resolveUnder('flags.json'),
+    };
+}
+function buildEnvCatalog(config, paths) {
+    const isEnhanced = config.profile === 'enhanced' || config.profile === 'experimental';
+    const isSqlite = config.profile === 'experimental';
+    const entries = [
+        { section: 'Core Paths - where your data lives' },
+        { key: 'INDEX_SERVER_PROFILE', desc: 'Configuration profile: default | enhanced | experimental', active: true, value: config.profile },
+        { key: 'INDEX_SERVER_ALWAYS_RELOAD', desc: 'Reload index on each read for generated config verification', active: true, value: '1' },
+        { key: 'INDEX_SERVER_DIR', desc: 'Instruction catalog directory', active: false, value: paths.instructions },
+        { key: 'INDEX_SERVER_FEEDBACK_DIR', desc: 'Feedback entries storage directory', active: false, value: paths.feedback },
+        { key: 'INDEX_SERVER_BACKUPS_DIR', desc: 'Backup snapshots directory', active: false, value: paths.backups },
+        { key: 'INDEX_SERVER_STATE_DIR', desc: 'Runtime state files directory', active: false, value: paths.state },
+        { key: 'INDEX_SERVER_MESSAGING_DIR', desc: 'Message queue storage directory', active: false, value: paths.messaging },
+        { section: 'Dashboard - HTTP/HTTPS admin interface' },
+        { key: 'INDEX_SERVER_DASHBOARD', desc: 'Enable the web dashboard', active: true, value: '1' },
+        { key: 'INDEX_SERVER_DASHBOARD_PORT', desc: 'Dashboard listen port', active: true, value: String(config.port) },
+        { key: 'INDEX_SERVER_DASHBOARD_HOST', desc: 'Dashboard bind address', active: true, value: config.host },
+        { key: 'INDEX_SERVER_DASHBOARD_GRAPH', desc: 'Enable graph visualization', active: false, value: '0' },
+        { section: 'Security - mutation control and TLS' },
+        { key: 'INDEX_SERVER_MUTATION', desc: 'Enable write operations', active: true, value: config.mutation ? '1' : '0' },
+        { key: 'INDEX_SERVER_ADMIN_API_KEY', desc: 'Dashboard admin API key', active: false, value: '' },
+        { key: 'INDEX_SERVER_DASHBOARD_TLS', desc: 'Enable HTTPS dashboard', active: config.tls, value: config.tls ? '1' : '0' },
+        { key: 'INDEX_SERVER_DASHBOARD_TLS_CERT', desc: 'Path to TLS certificate file', active: false, value: `${paths.certs}/server.crt` },
+        { key: 'INDEX_SERVER_DASHBOARD_TLS_KEY', desc: 'Path to TLS private key file', active: false, value: `${paths.certs}/server.key` },
+        { key: 'INDEX_SERVER_DASHBOARD_TLS_CA', desc: 'Path to CA certificate', active: false, value: '' },
+        { section: 'Semantic Search - embeddings' },
+        { key: 'INDEX_SERVER_SEMANTIC_ENABLED', desc: 'Enable semantic search', active: isEnhanced, value: isEnhanced ? '1' : '0' },
+        { key: 'INDEX_SERVER_SEMANTIC_MODEL', desc: 'HuggingFace model name', active: false, value: 'Xenova/all-MiniLM-L6-v2' },
+        { key: 'INDEX_SERVER_SEMANTIC_DEVICE', desc: 'Compute device', active: false, value: 'cpu' },
+        { key: 'INDEX_SERVER_SEMANTIC_CACHE_DIR', desc: 'Downloaded model cache directory', active: false, value: paths.modelCache },
+        { key: 'INDEX_SERVER_EMBEDDING_PATH', desc: 'Cached embeddings file', active: false, value: paths.embeddings },
+        { key: 'INDEX_SERVER_SEMANTIC_LOCAL_ONLY', desc: 'Block remote model downloads', active: false, value: isEnhanced ? '0' : '1' },
+        { section: 'Storage Backend - JSON or SQLite' },
+        { key: 'INDEX_SERVER_STORAGE_BACKEND', desc: 'Storage engine', active: isSqlite, value: isSqlite ? 'sqlite' : 'json' },
+        { key: 'INDEX_SERVER_SQLITE_PATH', desc: 'SQLite database file path', active: false, value: paths.sqliteDb },
+        { key: 'INDEX_SERVER_SQLITE_WAL', desc: 'Enable SQLite WAL mode', active: false, value: '1' },
+        { key: 'INDEX_SERVER_SQLITE_MIGRATE_ON_START', desc: 'Auto-migrate JSON to SQLite', active: false, value: '1' },
+        { section: 'Logging and diagnostics' },
+        { key: 'INDEX_SERVER_LOG_LEVEL', desc: 'Log level', active: true, value: config.logLevel },
+        { key: 'INDEX_SERVER_LOG_FILE', desc: 'Enable file logging', active: isEnhanced, value: isEnhanced ? '1' : '0' },
+        { key: 'INDEX_SERVER_VERBOSE_LOGGING', desc: 'Verbose stderr output', active: false, value: '0' },
+        { key: 'INDEX_SERVER_LOG_JSON', desc: 'JSON-formatted logs', active: false, value: '0' },
+        { key: 'INDEX_SERVER_LOG_DIAG', desc: 'Diagnostic startup logging', active: false, value: '0' },
+        { key: 'INDEX_SERVER_AUDIT_LOG', desc: 'Audit log path', active: false, value: paths.auditLog },
+        { section: 'Backup and recovery' },
+        { key: 'INDEX_SERVER_AUTO_BACKUP', desc: 'Enable instruction backups', active: false, value: config.mutation ? '1' : '0' },
+        { key: 'INDEX_SERVER_AUTO_BACKUP_INTERVAL_MS', desc: 'Backup interval in ms', active: false, value: '3600000' },
+        { key: 'INDEX_SERVER_AUTO_BACKUP_MAX_COUNT', desc: 'Max instruction backups retained', active: false, value: '10' },
+        { key: 'INDEX_SERVER_BACKUP_BEFORE_BULK_DELETE', desc: 'Backup before bulk delete', active: false, value: '1' },
+        { section: 'Features and flags' },
+        { key: 'INDEX_SERVER_FEATURES', desc: 'Comma-separated feature flags', active: isEnhanced, value: isEnhanced ? 'usage' : '' },
+        { key: 'INDEX_SERVER_FLAG_TOOLS_EXTENDED', desc: 'Expose extended index mutation tools', active: true, value: '1' },
+        { key: 'INDEX_SERVER_SEARCH_OMIT_ZERO_QUERY', desc: 'Omit echoed query metadata on zero-result search responses', active: true, value: '1' },
+        { key: 'INDEX_SERVER_METRICS_FILE_STORAGE', desc: 'Persist metrics to disk', active: isEnhanced, value: isEnhanced ? '1' : '0' },
+        { key: 'INDEX_SERVER_METRICS_DIR', desc: 'Metrics storage directory', active: false, value: paths.metrics },
+        { key: 'INDEX_SERVER_FLAGS_FILE', desc: 'Feature flags JSON file path', active: false, value: paths.flags },
+        { section: 'Server and transport' },
+        { key: 'INDEX_SERVER_MODE', desc: 'Instance mode', active: false, value: 'standalone' },
+        { key: 'INDEX_SERVER_DISABLE_EARLY_STDIN_BUFFER', desc: 'Disable stdin handshake hardening', active: false, value: '0' },
+        { key: 'INDEX_SERVER_IDLE_KEEPALIVE_MS', desc: 'Keepalive interval in ms', active: false, value: '30000' },
+        { key: 'INDEX_SERVER_POLL_MS', desc: 'Index filesystem poll interval', active: false, value: '10000' },
+        { section: 'Advanced tuning' },
+        { key: 'INDEX_SERVER_BODY_WARN_LENGTH', desc: 'Instruction body warning length', active: false, value: '50000' },
+        { key: 'INDEX_SERVER_AUTO_SPLIT_OVERSIZED', desc: 'Auto-split oversized entries', active: false, value: '0' },
+        { key: 'INDEX_SERVER_READ_RETRIES', desc: 'File read retry attempts', active: false, value: '3' },
+        { key: 'INDEX_SERVER_MAX_BULK_DELETE', desc: 'Max bulk delete entries', active: false, value: '5' },
+        { key: 'INDEX_SERVER_FEEDBACK_MAX_ENTRIES', desc: 'Max feedback entries', active: false, value: '1000' },
+        { key: 'INDEX_SERVER_MESSAGING_MAX', desc: 'Max messages in queue', active: false, value: '10000' },
+        { key: 'INDEX_SERVER_MAX_CONNECTIONS', desc: 'Max dashboard connections', active: false, value: '100' },
+        { key: 'INDEX_SERVER_CACHE_MODE', desc: 'Index cache mode', active: false, value: 'normal' },
+        { key: 'INDEX_SERVER_WORKSPACE', desc: 'Workspace identifier', active: false, value: '' },
+        { key: 'INDEX_SERVER_AGENT_ID', desc: 'Agent identifier', active: false, value: '' },
+    ];
+    const seen = new Set(entries.flatMap(entry => 'key' in entry ? [entry.key] : []));
+    for (const flag of exports.DOCUMENTED_INDEX_SERVER_FLAGS) {
+        if (!seen.has(flag))
+            entries.push({ key: flag, desc: 'Documented runtime configuration flag', active: false, value: '' });
+    }
+    return entries.map((entry) => {
+        if ('section' in entry)
+            return entry;
+        const value = String(entry.value);
+        const variable = {
+            ...entry,
+            value,
+            defaultByProfile: {
+                default: value,
+                enhanced: value,
+                experimental: value,
+            },
+            mcpEnvVisibility: entry.active ? 'always' : 'when-set',
+            validate: 'string',
+        };
+        return variable;
+    });
+}
+function activeEnvFromCatalog(catalog) {
+    const env = {};
+    for (const entry of catalog) {
+        if ('key' in entry && entry.active)
+            env[entry.key] = entry.value;
+    }
+    return env;
+}

package/dist/services/mcpConfig/formats.d.ts

@@ -0,0 +1,30 @@
+import { McpDataPaths, McpProfileConfig } from './flagCatalog';
+import type { McpConfigFormat } from './paths';
+export interface McpServerEntry {
+    type?: string;
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    tools?: string[];
+}
+export interface ServerBuildConfig extends McpProfileConfig {
+    serverName: string;
+}
+export declare function rootKeyForFormat(format: McpConfigFormat): 'servers' | 'mcpServers';
+export declare function emptyConfigForFormat(format: McpConfigFormat): Record<string, unknown>;
+export declare function parseConfigText(format: McpConfigFormat, text: string): Record<string, unknown>;
+export declare function readConfigFile(format: McpConfigFormat, filePath: string): Record<string, unknown>;
+export declare function getServerMap(config: Record<string, unknown>, format: McpConfigFormat): Record<string, McpServerEntry>;
+export declare function resolveServerLaunch(config: {
+    root: string;
+}): {
+    command: string;
+    args: string[];
+    cwd?: string;
+    source: 'local' | 'packaged' | 'npx';
+};
+export declare function buildServerEntry(format: McpConfigFormat, config: ServerBuildConfig, paths: McpDataPaths, envOverrides?: Record<string, string>): McpServerEntry;
+export declare function renderConfig(format: McpConfigFormat, serverName: string, entry: McpServerEntry): string;
+export declare function upsertConfigText(format: McpConfigFormat, existingText: string, serverName: string, entry: McpServerEntry): string;
+export declare function removeConfigText(format: McpConfigFormat, existingText: string, serverName: string): string;

package/dist/services/mcpConfig/formats.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootKeyForFormat = rootKeyForFormat;
+exports.emptyConfigForFormat = emptyConfigForFormat;
+exports.parseConfigText = parseConfigText;
+exports.readConfigFile = readConfigFile;
+exports.getServerMap = getServerMap;
+exports.resolveServerLaunch = resolveServerLaunch;
+exports.buildServerEntry = buildServerEntry;
+exports.renderConfig = renderConfig;
+exports.upsertConfigText = upsertConfigText;
+exports.removeConfigText = removeConfigText;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const jsoncEdit_1 = require("./jsoncEdit");
+const flagCatalog_1 = require("./flagCatalog");
+function rootKeyForFormat(format) {
+    return format === 'vscode' || format === 'vscode-global' ? 'servers' : 'mcpServers';
+}
+function emptyConfigForFormat(format) {
+    const rootKey = rootKeyForFormat(format);
+    const value = { [rootKey]: {} };
+    if (rootKey === 'servers')
+        value.inputs = [];
+    return value;
+}
+function parseConfigText(format, text) {
+    if (text.trim().length === 0)
+        return emptyConfigForFormat(format);
+    return format === 'vscode' || format === 'vscode-global'
+        ? (0, jsoncEdit_1.parseJsonc)(text)
+        : JSON.parse(text);
+}
+function readConfigFile(format, filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return emptyConfigForFormat(format);
+    return parseConfigText(format, fs_1.default.readFileSync(filePath, 'utf8'));
+}
+function getServerMap(config, format) {
+    const rootKey = rootKeyForFormat(format);
+    const servers = config[rootKey];
+    if (servers === undefined)
+        return {};
+    if (!servers || typeof servers !== 'object' || Array.isArray(servers)) {
+        throw new Error(`Invalid MCP config: ${rootKey} must be an object`);
+    }
+    return servers;
+}
+function resolveServerLaunch(config) {
+    const packageRoot = path_1.default.resolve(__dirname, '..', '..', '..');
+    const entryRelative = path_1.default.join('dist', 'server', 'index-server.js');
+    const localEntry = path_1.default.join(config.root, entryRelative);
+    const packagedEntry = path_1.default.join(packageRoot, entryRelative);
+    if (fs_1.default.existsSync(localEntry)) {
+        return { command: 'node', args: [(0, flagCatalog_1.toForwardSlashes)(entryRelative)], cwd: config.root, source: 'local' };
+    }
+    if (fs_1.default.existsSync(packagedEntry)) {
+        return { command: 'node', args: [(0, flagCatalog_1.toForwardSlashes)(packagedEntry)], source: 'packaged' };
+    }
+    return { command: 'npx', args: ['-y', '@jagilber-org/index-server'], source: 'npx' };
+}
+function buildServerEntry(format, config, paths, envOverrides = {}) {
+    const launch = resolveServerLaunch(config);
+    const catalog = (0, flagCatalog_1.buildEnvCatalog)(config, paths);
+    const env = { ...(0, flagCatalog_1.activeEnvFromCatalog)(catalog), ...envOverrides };
+    const entry = {
+        command: launch.command,
+        args: launch.args,
+        env,
+    };
+    if (format === 'vscode' || format === 'vscode-global')
+        entry.type = 'stdio';
+    if (format === 'vscode' && launch.cwd)
+        entry.cwd = (0, flagCatalog_1.toForwardSlashes)(launch.cwd);
+    if (format === 'vscode-global' && launch.command === 'node') {
+        const firstArg = launch.args[0] ?? '';
+        entry.args = [path_1.default.isAbsolute(firstArg) ? (0, flagCatalog_1.toForwardSlashes)(firstArg) : (0, flagCatalog_1.toForwardSlashes)(path_1.default.resolve(launch.cwd ?? config.root, firstArg))];
+        entry.cwd = (0, flagCatalog_1.toForwardSlashes)(path_1.default.resolve(__dirname, '..', '..', '..'));
+    }
+    return entry;
+}
+function renderConfig(format, serverName, entry) {
+    const config = emptyConfigForFormat(format);
+    const rootKey = rootKeyForFormat(format);
+    config[rootKey][serverName] = entry;
+    return format === 'vscode' || format === 'vscode-global'
+        ? JSON.stringify(config, null, 2)
+        : `${JSON.stringify(config, null, 2)}\n`;
+}
+function upsertConfigText(format, existingText, serverName, entry) {
+    if (format === 'vscode' || format === 'vscode-global') {
+        const base = existingText.trim().length > 0 ? existingText : JSON.stringify(emptyConfigForFormat(format), null, 2);
+        return (0, jsoncEdit_1.applyJsoncEdit)(base, [rootKeyForFormat(format), serverName], entry);
+    }
+    const config = parseConfigText(format, existingText);
+    const rootKey = rootKeyForFormat(format);
+    const servers = getServerMap(config, format);
+    servers[serverName] = entry;
+    config[rootKey] = servers;
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
+function removeConfigText(format, existingText, serverName) {
+    if (format === 'vscode' || format === 'vscode-global') {
+        const base = existingText.trim().length > 0 ? existingText : JSON.stringify(emptyConfigForFormat(format), null, 2);
+        return (0, jsoncEdit_1.applyJsoncEdit)(base, [rootKeyForFormat(format), serverName], undefined);
+    }
+    const config = parseConfigText(format, existingText);
+    const rootKey = rootKeyForFormat(format);
+    const servers = getServerMap(config, format);
+    delete servers[serverName];
+    config[rootKey] = servers;
+    return `${JSON.stringify(config, null, 2)}\n`;
+}

package/dist/services/mcpConfig/index.d.ts

@@ -0,0 +1,44 @@
+import { resolveServerLaunch, type McpServerEntry, type ServerBuildConfig } from './formats';
+import { buildEnvCatalog, resolveDataPaths } from './flagCatalog';
+import { resolveConfigTargets, type McpClientTarget, type McpConfigFormat, type McpScope, type McpTargetInfo } from './paths';
+import { type ValidationResult } from './validate';
+export type { McpClientTarget, McpConfigFormat, McpScope, McpTargetInfo, McpServerEntry, ServerBuildConfig, ValidationResult };
+export { buildEnvCatalog, resolveConfigTargets, resolveDataPaths, resolveServerLaunch };
+export interface McpOperationOptions {
+    target?: McpClientTarget;
+    targets?: McpClientTarget[];
+    scope?: McpScope;
+    root?: string;
+    name?: string;
+    profile?: 'default' | 'enhanced' | 'experimental';
+    port?: number;
+    host?: string;
+    tls?: boolean;
+    mutation?: boolean;
+    logLevel?: string;
+    env?: Record<string, string>;
+    dryRun?: boolean;
+    backup?: string;
+}
+export interface McpOperationResult {
+    ok: boolean;
+    action: string;
+    target: McpClientTarget;
+    format: McpConfigFormat;
+    path: string;
+    name?: string;
+    server?: McpServerEntry | null;
+    servers?: string[];
+    validation?: ValidationResult;
+    backupPath?: string;
+    dryRun?: boolean;
+}
+export declare function listServers(options?: McpOperationOptions): McpOperationResult;
+export declare function getServer(options?: McpOperationOptions): McpOperationResult;
+export declare function upsertServer(options?: McpOperationOptions): McpOperationResult;
+export declare function removeServer(options?: McpOperationOptions): McpOperationResult;
+export declare function restoreLatestBackup(options?: McpOperationOptions): McpOperationResult;
+export declare function restoreServer(options?: McpOperationOptions): McpOperationResult;
+export declare function validateFile(options?: McpOperationOptions): McpOperationResult;
+export declare function renderServerConfigForTarget(target: McpTargetInfo, options?: McpOperationOptions): string;
+export declare function writeGeneratedConfig(filePath: string, content: string): void;

package/dist/services/mcpConfig/index.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveServerLaunch = exports.resolveDataPaths = exports.resolveConfigTargets = exports.buildEnvCatalog = void 0;
+exports.listServers = listServers;
+exports.getServer = getServer;
+exports.upsertServer = upsertServer;
+exports.removeServer = removeServer;
+exports.restoreLatestBackup = restoreLatestBackup;
+exports.restoreServer = restoreServer;
+exports.validateFile = validateFile;
+exports.renderServerConfigForTarget = renderServerConfigForTarget;
+exports.writeGeneratedConfig = writeGeneratedConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const backup_1 = require("./backup");
+const formats_1 = require("./formats");
+Object.defineProperty(exports, "resolveServerLaunch", { enumerable: true, get: function () { return formats_1.resolveServerLaunch; } });
+const flagCatalog_1 = require("./flagCatalog");
+Object.defineProperty(exports, "buildEnvCatalog", { enumerable: true, get: function () { return flagCatalog_1.buildEnvCatalog; } });
+Object.defineProperty(exports, "resolveDataPaths", { enumerable: true, get: function () { return flagCatalog_1.resolveDataPaths; } });
+const paths_1 = require("./paths");
+Object.defineProperty(exports, "resolveConfigTargets", { enumerable: true, get: function () { return paths_1.resolveConfigTargets; } });
+const validate_1 = require("./validate");
+const backup_2 = require("./backup");
+function firstTarget(options) {
+    return (0, paths_1.resolveConfigTargets)({
+        target: options.target,
+        targets: options.targets,
+        scope: options.scope,
+        root: options.root,
+    })[0];
+}
+function defaultName(options) {
+    return options.name ?? 'index-server';
+}
+function buildConfig(options) {
+    const profile = options.profile ?? 'default';
+    const tls = options.tls ?? (profile === 'enhanced' || profile === 'experimental');
+    return {
+        profile,
+        root: path_1.default.resolve(options.root ?? process.env.INDEX_SERVER_MCP_CONFIG_ROOT ?? process.cwd()),
+        port: options.port ?? 8787,
+        host: options.host ?? '127.0.0.1',
+        tls,
+        mutation: options.mutation ?? true,
+        logLevel: options.logLevel ?? (profile === 'experimental' ? 'debug' : 'info'),
+        serverName: defaultName(options),
+    };
+}
+function readExistingText(filePath, format) {
+    if (fs_1.default.existsSync(filePath))
+        return fs_1.default.readFileSync(filePath, 'utf8');
+    return (0, formats_1.renderConfig)(format, '__placeholder__', {
+        command: 'node',
+        args: ['dist/server/index-server.js'],
+    }).split('__placeholder__').join('index-server');
+}
+function listServers(options = {}) {
+    const target = firstTarget(options);
+    const config = (0, formats_1.readConfigFile)(target.format, target.path);
+    const servers = Object.keys((0, formats_1.getServerMap)(config, target.format));
+    return { ok: true, action: 'list', ...target, servers };
+}
+function getServer(options = {}) {
+    const target = firstTarget(options);
+    const config = (0, formats_1.readConfigFile)(target.format, target.path);
+    const server = (0, formats_1.getServerMap)(config, target.format)[defaultName(options)] ?? null;
+    return { ok: true, action: 'get', ...target, name: defaultName(options), server };
+}
+function upsertServer(options = {}) {
+    const target = firstTarget(options);
+    const config = buildConfig(options);
+    const paths = (0, flagCatalog_1.resolveDataPaths)(config.root);
+    const entry = (0, formats_1.buildServerEntry)(target.format, config, paths, options.env);
+    const existingText = fs_1.default.existsSync(target.path) ? fs_1.default.readFileSync(target.path, 'utf8') : '';
+    if (existingText)
+        (0, validate_1.assertValidConfigObject)(target.format, (0, formats_1.parseConfigText)(target.format, existingText), 'read');
+    const nextText = (0, formats_1.upsertConfigText)(target.format, existingText, config.serverName, entry);
+    const nextConfig = (0, formats_1.parseConfigText)(target.format, nextText);
+    (0, validate_1.assertValidConfigObject)(target.format, nextConfig, 'write');
+    if (!options.dryRun) {
+        const backup = (0, backup_1.createBackup)(target.path, 'upsert', config.serverName);
+        (0, backup_2.atomicWriteText)(target.path, nextText);
+        (0, validate_1.assertValidConfigObject)(target.format, (0, formats_1.readConfigFile)(target.format, target.path), 'post-write');
+        return { ok: true, action: 'upsert', ...target, name: config.serverName, server: entry, backupPath: backup?.backupPath };
+    }
+    return { ok: true, action: 'upsert', ...target, name: config.serverName, server: entry, dryRun: true };
+}
+function removeServer(options = {}) {
+    const target = firstTarget(options);
+    const name = defaultName(options);
+    const existingText = readExistingText(target.path, target.format);
+    (0, validate_1.assertValidConfigObject)(target.format, (0, formats_1.parseConfigText)(target.format, existingText), 'read');
+    const nextText = (0, formats_1.removeConfigText)(target.format, existingText, name);
+    (0, validate_1.assertValidConfigObject)(target.format, (0, formats_1.parseConfigText)(target.format, nextText), 'write');
+    if (!options.dryRun) {
+        const backup = (0, backup_1.createBackup)(target.path, 'remove', name);
+        (0, backup_2.atomicWriteText)(target.path, nextText);
+        (0, validate_1.assertValidConfigObject)(target.format, (0, formats_1.readConfigFile)(target.format, target.path), 'post-write');
+        return { ok: true, action: 'remove', ...target, name, backupPath: backup?.backupPath };
+    }
+    return { ok: true, action: 'remove', ...target, name, dryRun: true };
+}
+function restoreLatestBackup(options = {}) {
+    const target = firstTarget(options);
+    const restored = (0, backup_1.restoreBackup)(target.path, options.backup);
+    (0, validate_1.assertValidConfigObject)(target.format, (0, formats_1.readConfigFile)(target.format, target.path), 'restore');
+    return { ok: true, action: 'restore', ...target, backupPath: restored.backupPath };
+}
+function restoreServer(options = {}) {
+    return restoreLatestBackup(options);
+}
+function validateFile(options = {}) {
+    const target = firstTarget(options);
+    const config = (0, formats_1.readConfigFile)(target.format, target.path);
+    const validation = (0, validate_1.validateConfigObject)(target.format, config);
+    return { ok: validation.ok, action: 'validate', ...target, validation };
+}
+function renderServerConfigForTarget(target, options = {}) {
+    const config = buildConfig({ ...options, target: target.target, scope: target.format === 'vscode-global' ? 'global' : options.scope });
+    const paths = (0, flagCatalog_1.resolveDataPaths)(config.root);
+    const entry = (0, formats_1.buildServerEntry)(target.format, config, paths, options.env);
+    return (0, formats_1.renderConfig)(target.format, config.serverName, entry);
+}
+function writeGeneratedConfig(filePath, content) {
+    (0, backup_2.atomicWriteText)(filePath, content);
+}

package/dist/services/mcpConfig/jsoncEdit.d.ts

@@ -0,0 +1,2 @@
+export declare function parseJsonc(text: string): Record<string, unknown>;
+export declare function applyJsoncEdit(text: string, editPath: Array<string | number>, value: unknown): string;

package/dist/services/mcpConfig/jsoncEdit.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonc = parseJsonc;
+exports.applyJsoncEdit = applyJsoncEdit;
+const jsonc_parser_1 = require("jsonc-parser");
+function formatErrors(errors) {
+    return errors.map(error => `${error.error} at offset ${error.offset}`).join(', ');
+}
+function parseJsonc(text) {
+    const errors = [];
+    const parsed = (0, jsonc_parser_1.parse)(text, errors, { allowTrailingComma: true, disallowComments: false });
+    if (errors.length > 0)
+        throw new Error(`Invalid JSONC: ${formatErrors(errors)}`);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Invalid JSONC: expected object root');
+    }
+    return parsed;
+}
+function applyJsoncEdit(text, editPath, value) {
+    const errors = [];
+    (0, jsonc_parser_1.parse)(text, errors, { allowTrailingComma: true, disallowComments: false });
+    if (errors.length > 0)
+        throw new Error(`Invalid JSONC: ${formatErrors(errors)}`);
+    const edits = (0, jsonc_parser_1.modify)(text, editPath, value, {
+        formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' },
+        getInsertionIndex: properties => properties.length,
+    });
+    return (0, jsonc_parser_1.applyEdits)(text, edits);
+}